## API Report File for "@empathyco/x-components"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import type { ActionContext } from 'vuex';
import { default as AISpinnerIcon } from './ai-spinner-icon.vue';
import { default as AIStarIcon } from './ai-star.vue';
import type { AnyFunction } from '@empathyco/x-utils';
import type { App } from 'vue';
import { default as ArrowDownIcon } from './arrow-down.vue';
import { default as ArrowLeftIcon } from './arrow-left.vue';
import { default as ArrowRightIcon } from './arrow-right.vue';
import { default as ArrowUpIcon } from './arrow-up.vue';
import { default as BagIcon } from './bag.vue';
import { default as BarCodeIcon } from './bar-code.vue';
import { default as BarcodeTinyIcon } from './barcode-tiny.vue';
import { default as BaseFallbackImage } from './base-result-fallback-image.vue';
import { default as BasePlaceholderImage } from './base-result-placeholder-image.vue';
import { default as CartFilledIcon } from './cart-filled.vue';
import { default as CartIcon } from './cart.vue';
import { default as CheckboxSelectedFilledIcon } from './checkbox-selected-filled.vue';
import { default as CheckboxSelectedIcon } from './checkbox-selected.vue';
import { default as CheckboxUnselectedFilledIcon } from './checkbox-unselected-filled.vue';
import { default as CheckboxUnselectedIcon } from './checkbox-unselected.vue';
import { default as CheckIcon } from './check.vue';
import { default as CheckTinyIcon } from './check-tiny.vue';
import { default as ChevronDownIcon } from './chevron-down.vue';
import { default as ChevronLeftIcon } from './chevron-left.vue';
import { default as ChevronRightIcon } from './chevron-right.vue';
import { default as ChevronTinyDownIcon } from './chevron-tiny-down.vue';
import { default as ChevronTinyLeftIcon } from './chevron-tiny-left.vue';
import { default as ChevronTinyRightIcon } from './chevron-tiny-right.vue';
import { default as ChevronTinyUpIcon } from './chevron-tiny-up.vue';
import { default as ChevronUpIcon } from './chevron-up.vue';
import type { Component } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import type { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { default as CornerArrowLeft } from './corner-arrow-left.vue';
import { default as CornerArrowRight } from './corner-arrow-right.vue';
import { default as CrossIcon } from './cross.vue';
import { default as CrossTinyIcon } from './cross-tiny.vue';
import { CSSProperties } from 'vue';
import { default as CuratedCheckFilledIcon } from './curated-check-filled.vue';
import { default as CuratedCheckIcon } from './curated-check.vue';
import { default as CuratedCheckTinyFilledIcon } from './curated-check-tiny-filled.vue';
import { default as CuratedCheckTinyIcon } from './curated-check-tiny.vue';
import type { DeepPartial } from '@empathyco/x-utils';
import { DefineComponent } from 'vue';
import { default as DiagonalArrowLeftDownIcon } from './diagonal-arrow-left-down.vue';
import { default as DiagonalArrowLeftTopIcon } from './diagonal-arrow-left-top.vue';
import { default as DiagonalArrowRightDownIcon } from './diagonal-arrow-right-down.vue';
import { default as DiagonalArrowRightTopIcon } from './diagonal-arrow-right-top.vue';
import { Dictionary } from '@empathyco/x-utils';
import { Directive } from 'vue';
import { EndpointAdapter } from '@empathyco/x-adapter';
import { ExtractPropTypes } from 'vue';
import { default as FiltersIcon } from './filters.vue';
import { GlobalEventsProps } from 'vue-global-events';
import { default as Grid1ColIcon } from './grid-1-col.vue';
import { default as Grid2ColIcon } from './grid-2-col.vue';
import { default as Grid2RowsIcon } from './grid-2-rows.vue';
import { default as Grid4ColIcon } from './grid-4-col.vue';
import { default as HeartIcon } from './heart.vue';
import { default as HeartIconFilled } from './heart-filled.vue';
import { default as HideIcon } from './hide.vue';
import { default as HistoryIcon } from './history.vue';
import { default as HistoryTinyIcon } from './history-tiny.vue';
import { default as LightBulbOff } from './light-bulb-off.vue';
import { default as LightBulbOn } from './light-bulb-on.vue';
import { default as MenuIcon } from './menu.vue';
import { default as MinusIcon } from './minus.vue';
import { default as MinusTinyIcon } from './minus-tiny.vue';
import type { Module } from 'vuex';
import type { Observable } from 'rxjs';
import type { Plugin as Plugin_2 } from 'vue';
import { default as PlusIcon } from './plus.vue';
import { default as PlusTinyIcon } from './plus-tiny.vue';
import type { PropType } from 'vue';
import { PublicProps } from 'vue';
import { default as RadioButtonSelectedIcon } from './radiobutton-selected.vue';
import { default as RadioButtonUnselectedIcon } from './radiobutton-unselected.vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import type { RequiredProperties } from '@empathyco/x-utils';
import { default as SearchIcon } from './search.vue';
import { default as SearchTinyIcon } from './search-tiny.vue';
import { default as SettingsIcon } from './settings.vue';
import type { SetupContext } from 'vue';
import { ShallowRef } from 'vue';
import { default as ShowIcon } from './show.vue';
import { Slot } from 'vue';
import { default as SortAZIcon } from './sort-az.vue';
import { default as SortPriceDownIcon } from './sort-price-down.vue';
import { default as SortPriceUpIcon } from './sort-price-up.vue';
import { default as SortRelevancyIcon } from './sort-relevancy.vue';
import { default as SortZAIcon } from './sort-za.vue';
import { default as SpinnerIcon } from './spinner.vue';
import { default as StarFilledIcon } from './star-filled.vue';
import { default as StarIcon } from './star.vue';
import type { StorageService } from '@empathyco/x-utils';
import type { Store } from 'vuex';
import type { StyleValue } from 'vue';
import type { Subject } from 'rxjs';
import type { Subscription } from 'rxjs';
import { default as TagFilledIcon } from './tag-filled.vue';
import { default as TagIcon } from './tag.vue';
import { default as TrashIcon } from './trash.vue';
import { default as TrashOpenIcon } from './trash-open.vue';
import { default as TrendingIcon } from './trending.vue';
import { default as TrendingTinyIcon } from './trending-tiny.vue';
import { default as UserFilledIcon } from './user-filled.vue';
import { default as UserIcon } from './user.vue';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import type { WatchOptions } from 'vue';
import type { WatchStopHandle } from 'vue';
import { WritableComputedRef } from 'vue';

// @internal
export interface AbsoluteDistances {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public
export type ActionNamesFor<ModuleName extends XModuleName> = keyof ExtractActions<XModulesTree[ModuleName]>;

// @public
export type ActionsClass<Module extends AnyXStoreModule> = Partial<Module['actions']>;

// @public
export type ActionsDictionary<Actions> = Record<keyof Actions, (payload?: any) => any>;

// @public
export type ActionsTree<State extends Dictionary, Getters extends Dictionary, Mutations extends MutationsDictionary<Mutations>, Actions extends ActionsDictionary<Actions>> = {
    [Key in keyof Actions]: (context: XActionContext<State, Getters, Mutations, Actions>, payload: ExtractPayload<Actions[Key]>) => ReturnType<Actions[Key]> | Promise<ReturnType<Actions[Key]>>;
};

// @public
export const addQueryPreviewInstanceWire: Wire<string>;

// @public
export const addQueryToHistory: (input: HistoryQueriesActionContext, query: string) => void | Promise<void>;

// @public
export class AddQueryToHistoryAction implements ActionsClass<HistoryQueriesXStoreModule> {
    addQueryToHistory(input: HistoryQueriesActionContext, query: string): void | Promise<void>;
    // Warning: (ae-forgotten-export) The symbol "HistoryQuery_2" needs to be exported by the entry point index.d.ts
    //
    // @internal
    protected createHistoryQuery(query: string): HistoryQuery_2;
    // @internal
    protected createNewHistory(currentHistory: HistoryQuery_2[], normalizedQuery: string): HistoryQuery_2[] | null;
    // @internal
    protected isAddAction(input: Pair<string[]>, input2: Pair<string>): boolean;
    // @internal
    protected isQueryBeingRefined(lastWords: string[], newWords: string[]): boolean;
    // @internal
    protected isReplaceAction(input: Pair<string[]>, input2: Pair<string>): boolean;
    // @internal
    protected removeNewQueryFromHistory(currentHistory: HistoryQuery_2[], normalizedQuery: string): HistoryQuery_2[];
}

// @public
export const addQueryToHistoryQueries: Wire<string>;

// @public
export const addQueryToHistoryQueriesFromPreview: AnyWire;

// @public
export type AiActionContext = XActionContext<AiState, AiGetters, AiMutations, AiActions>;

// @public
export interface AiActions {
    // Warning: (ae-forgotten-export) The symbol "AiSuggestionsRequest" needs to be exported by the entry point index.d.ts
    fetchAndSaveAiSuggestions: (request: AiSuggestionsRequest | null) => void;
    fetchAndSaveAiSuggestionsSearch: (expanded: boolean) => void;
    saveOrigin: (originInit: QueryOriginInit) => void;
    setUrlParams: (urlParams: UrlParams) => void;
}

// @public (undocumented)
export const AiCarousel: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
slidingPanelClasses: {
type: StringConstructor;
};
slidingPanelContainerClasses: {
type: StringConstructor;
};
slidingPanelButtonsClasses: {
type: StringConstructor;
};
}>, {
emptyTaggingRequest: TaggingRequest;
isNoResults: ComputedRef<boolean>;
isTitleOverflowing: Ref<boolean, boolean>;
queries: ComputedRef<AiSuggestionQuery[]>;
query: ComputedRef<string>;
suggestionsSearch: ComputedRef<AiSuggestionSearch[]>;
tagging: ComputedRef<AiSuggestionTagging | undefined>;
title: ComputedRef<string>;
titleExpanded: Ref<boolean, boolean>;
titleRef: Ref<HTMLElement | null, HTMLElement | null>;
toggleTitleExpansion: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
slidingPanelClasses: {
type: StringConstructor;
};
slidingPanelContainerClasses: {
type: StringConstructor;
};
slidingPanelButtonsClasses: {
type: StringConstructor;
};
}>> & Readonly<{}>, {}, {}, {
ChangeHeight: DefineComponent<    {}, {}, any>;
DisplayClickProvider: DefineComponent<    {}, {}, any>;
DisplayEmitter: DefineComponent<    {}, {}, any>;
CollapseHeight: DefineComponent<    {}, {}, any>;
AIStarIcon: DefineComponent<    {}, {}, any>;
ChevronDownIcon: DefineComponent<    {}, {}, any>;
SlidingPanel: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface AiConfig {
    lowResultsThreshold: number;
}

// @internal
export const aiEmitters: {
    AiSuggestionsRequestUpdated: (_: AiState, getters: Returns<GettersTree<AiState, AiGetters>>) => AiSuggestionsRequest | null;
    AiSuggestionsSearchRequestUpdated: (_: AiState, getters: Returns<GettersTree<AiState, AiGetters>>) => AiSuggestionsSearchRequest | null;
    AiSuggestionsSearchChanged: (state: AiState) => AiSuggestionSearch[];
};

// @public
export interface AiGetters {
    query: string;
    suggestionsRequest: AiSuggestionsRequest | null;
    suggestionsSearchRequest: AiSuggestionsSearchRequest | null;
}

// @public
export interface AiMutations extends ConfigMutations<AiState>, QueryMutations {
    resetAiState: () => void;
    // Warning: (ae-forgotten-export) The symbol "RelatedTag_2" needs to be exported by the entry point index.d.ts
    setAiRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setIsNoResults: (isNoResults: boolean) => void;
    setOrigin: (origin: QueryOrigin | undefined | null) => void;
    setParams: (params: Dictionary<unknown>) => void;
    setQueries: (queries: AiSuggestionQuery[]) => void;
    setResponseText: (responseText: string) => void;
    setSearchTotalResults: (totalResults: number) => void;
    // Warning: (ae-forgotten-export) The symbol "Filter" needs to be exported by the entry point index.d.ts
    setSelectedFilters: (selectedFilters: Filter[]) => void;
    setSuggestionsSearch: (suggestionsSearch: AiSuggestionSearch[]) => void;
    setSuggestionsSearchStatus: (status: RequestStatus) => void;
    setSuggestionsStatus: (status: RequestStatus) => void;
    setSuggestionText: (suggestionText: string) => void;
    setTagging: (tagging: AiSuggestionTagging) => void;
}

// @public (undocumented)
export const AiOverview: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
titleLoading: {
type: StringConstructor;
default: string;
};
autoExpandInSearchNoResults: {
type: BooleanConstructor;
default: boolean;
};
contentClasses: {
type: StringConstructor;
};
slidingPanelsClasses: {
type: StringConstructor;
};
slidingPanelContainersClasses: {
type: StringConstructor;
};
slidingPanelButtonsClasses: {
type: StringConstructor;
};
}>, {
aiOverviewRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
emptyTaggingRequest: TaggingRequest;
expanded: Ref<boolean, boolean>;
parsedResponseText: ComputedRef<string | Promise<string>>;
suggestionsLoading: ComputedRef<boolean>;
suggestionsSearch: ComputedRef<AiSuggestionSearch[]>;
suggestionText: ComputedRef<string>;
shouldAnimateSuggestion: Ref<boolean, boolean>;
query: ComputedRef<string>;
tagging: ComputedRef<AiSuggestionTagging | undefined>;
isNoResults: ComputedRef<boolean>;
queries: ComputedRef<AiSuggestionQuery[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
titleLoading: {
type: StringConstructor;
default: string;
};
autoExpandInSearchNoResults: {
type: BooleanConstructor;
default: boolean;
};
contentClasses: {
type: StringConstructor;
};
slidingPanelsClasses: {
type: StringConstructor;
};
slidingPanelContainersClasses: {
type: StringConstructor;
};
slidingPanelButtonsClasses: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
titleLoading: string;
autoExpandInSearchNoResults: boolean;
}, {}, {
AIStarIcon: DefineComponent<    {}, {}, any>;
ArrowRightIcon: DefineComponent<    {}, {}, any>;
BaseEventButton: DefineComponent<    {}, {}, any>;
CollapseHeight: DefineComponent<    {}, {}, any>;
ChangeHeight: DefineComponent<    {}, {}, any>;
Fade: DefineComponent<    {}, {}, any>;
SlidingPanel: DefineComponent<    {}, {}, any>;
SpinnerIcon: DefineComponent<    {}, {}, any>;
DisplayEmitter: DefineComponent<    {}, {}, any>;
DisplayClickProvider: DefineComponent<    {}, {}, any>;
}, {
typing: Directive<TypingHTMLElement, TypingOptions>;
}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const aiQuery: AiXStoreModule['getters']['query'];

export { AISpinnerIcon }

export { AIStarIcon }

// @public
export interface AiState extends QueryState {
    // (undocumented)
    config: AiConfig;
    isNoResults: boolean;
    origin: QueryOrigin | null;
    params: Dictionary<unknown>;
    // (undocumented)
    queries: AiSuggestionQuery[];
    relatedTags: RelatedTag_2[];
    responseText: string;
    searchTotalResults: number;
    selectedFilters: Dictionary<Filter[]>;
    suggestionsSearch: AiSuggestionSearch[];
    suggestionsSearchStatus: RequestStatus;
    suggestionsStatus: RequestStatus;
    // (undocumented)
    suggestionText: string;
    // (undocumented)
    tagging: AiSuggestionTagging | undefined;
}

// @public
export const aiSuggestionsRequest: AiXStoreModule['getters']['suggestionsRequest'];

// @public
export const aiSuggestionsSearchRequest: AiXStoreModule['getters']['suggestionsSearchRequest'];

// @internal
export const aiWiring: {
    ParamsLoadedFromUrl: {
        setUrlParamsWire: Wire<UrlParams>;
    };
    ExtraParamsChanged: {
        setExtraParamsWire: Wire<Dictionary<unknown>>;
    };
    UserClearedQuery: {
        resetAiQueryWire: AnyWire;
        resetSearchTotalResultsWire: AnyWire;
    };
    AiSuggestionsRequestUpdated: {
        resetAiStateWire: AnyWire;
        fetchAndSaveAiSuggestionsWire: Wire<AiSuggestionsRequest | null>;
    };
    AiSuggestionsSearchRequestUpdated: {
        fetchAndSaveAiSuggestionsSearchWire: AnyWire;
    };
    SelectedRelatedTagsChanged: {
        setAiRelatedTagsWire: Wire<RelatedTag_2[]>;
    };
    SelectedFiltersForRequestChanged: {
        setSelectedFiltersWire: Wire<Filter[]>;
    };
    AiComponentMounted: {
        saveAiOriginWire: AnyWire;
    };
    SearchResponseChanged: {
        setAiQueryWire: AnyWire;
        setSearchTotalResultsWire: AnyWire;
    };
};

// @public
export interface AiXEvents {
    // (undocumented)
    AiComponentMounted: void;
    // (undocumented)
    AiSuggestionsRequestUpdated: AiSuggestionsRequest | null;
    // (undocumented)
    AiSuggestionsSearchChanged: AiSuggestionSearch[];
    // (undocumented)
    AiSuggestionsSearchRequestUpdated: AiSuggestionsSearchRequest | null;
    // (undocumented)
    UserClickedAiOverviewExpandButton: boolean;
    // Warning: (ae-forgotten-export) The symbol "Result" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    UserClickedAnAiOverviewResult: Result;
}

// @public
export type AiXModule = XModule<AiXStoreModule>;

// @public
export const aiXModule: AiXModule;

// @public
export type AiXStoreModule = XStoreModule<AiState, AiGetters, AiMutations, AiActions>;

// @internal
export const aiXStoreModule: AiXStoreModule;

// @public
export const AllFilter: DefineComponent<ExtractPropTypes<    {
facet: {
type: PropType<Facet>;
required: true;
};
}>, {
clickEvent: ComputedRef<Partial<XEventsTypes>>;
cssClasses: ComputedRef<    {
'xds:selected x-all-filter--is-selected': boolean;
}>;
isSelected: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facet: {
type: PropType<Facet>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public (undocumented)
export const AnimateClipPath: DefineComponent<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>> & Readonly<{}>, {
animationOrigin: AnimationOrigin;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public (undocumented)
export const AnimateScale: DefineComponent<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>> & Readonly<{}>, {
animationOrigin: AnimationOrigin;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public (undocumented)
export const AnimateTranslate: DefineComponent<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animationOrigin: {
type: PropType<AnimationOrigin>;
default: string;
};
}>> & Readonly<{}>, {
animationOrigin: AnimationOrigin;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const AnimateWidth: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const AnimationProp: (StringConstructor | ObjectConstructor | FunctionConstructor)[];

// @public
export type AnyActionsTree = ActionsTree<Dictionary, Dictionary, MutationsDictionary<any>, ActionsDictionary<any>>;

// @public
export type AnyGettersTree = GettersTree<Dictionary, Dictionary>;

// @public
export type AnyMutationsTree = MutationsTree<Dictionary, MutationsDictionary<any>>;

// @public
export type AnySimpleStateSelector = SimpleStateSelector<any, any, any>;

// @public
export type AnyStateSelector = StateSelector<any, any, any>;

// @public
export type AnyStoreEmitters = StoreEmitters<AnyXStoreModule>;

// @public
export type AnyWire = Wire<any>;

// @public
export type AnyXModule = XModule<AnyXStoreModule>;

// @public
export type AnyXStoreModule = XStoreModule<any, any, any, any>;

// @public
export type AnyXStoreModuleOption = XStoreModuleOptions<AnyXStoreModule>;

// Warning: (ae-forgotten-export) The symbol "HierarchicalFilter_2" needs to be exported by the entry point index.d.ts
//
// @public
export function applyHierarchicalSelection(filters: HierarchicalFilter_2[], selectedIds: Set<string | number>): void;

// @public
export function areFiltersDifferent(someFilters: Filter[], anotherFilters: Filter[]): boolean;

// @public
export function arrayToObject(array: string[]): Record<string, string>;

// @public
export function arrayToObject<ArrayType>(array: ArrayType[], key: PropsWithType<ArrayType, string | number>): Record<string, ArrayType>;

export { ArrowDownIcon }

// @public
export type ArrowKey = 'ArrowUp' | 'ArrowDown' | 'ArrowRight' | 'ArrowLeft';

export { ArrowLeftIcon }

export { ArrowRightIcon }

export { ArrowUpIcon }

// @public
export function assertXPluginOptionsAreValid(options: XPluginOptions | undefined): asserts options is XPluginOptions;

// @public
export const AutoProgressBar: DefineComponent<ExtractPropTypes<    {
isLoading: {
type: BooleanConstructor;
default: boolean;
};
durationInSeconds: {
type: NumberConstructor;
default: number;
};
}>, {
cssStyles: ComputedRef<StyleValue>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
isLoading: {
type: BooleanConstructor;
default: boolean;
};
durationInSeconds: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
isLoading: boolean;
durationInSeconds: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { BagIcon }

// @public
export const Banner: DefineComponent<ExtractPropTypes<    {
banner: {
type: PropType<Banner_2>;
required: true;
};
titleClass: StringConstructor;
}>, {
imageFailed: Ref<boolean, boolean>;
anchorEvents: () => Partial<{ [key in keyof GlobalEventHandlersEventMap]: () => void; }>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
banner: {
type: PropType<Banner_2>;
required: true;
};
titleClass: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BannersList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { BarCodeIcon }

export { BarcodeTinyIcon }

// @public
export const BaseAddToCart: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
metadata: Omit<WireMetadata, "moduleName" | "origin" | "location">;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseColumnPickerDropdown: DefineComponent<ExtractPropTypes<    {
columns: {
type: PropType<number[]>;
required: true;
};
modelValue: NumberConstructor;
animation: PropType<string | Component>;
}>, {
emitEvents: (column: number) => void;
hasToggleSlot: boolean;
selectedColumns: Ref<number, number>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
columns: {
type: PropType<number[]>;
required: true;
};
modelValue: NumberConstructor;
animation: PropType<string | Component>;
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
BaseDropdown: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseColumnPickerList: DefineComponent<ExtractPropTypes<    {
columns: {
type: PropType<number[]>;
required: true;
};
modelValue: NumberConstructor;
buttonClass: StringConstructor;
}>, {
columnsWithCssClasses: ComputedRef<ColumnPickerItem[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
columns: {
type: PropType<number[]>;
required: true;
};
modelValue: NumberConstructor;
buttonClass: StringConstructor;
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseCurrency: DefineComponent<ExtractPropTypes<    {
value: {
type: NumberConstructor;
required: true;
};
format: {
type: StringConstructor;
};
}>, {
currency: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: NumberConstructor;
required: true;
};
format: {
type: StringConstructor;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseDropdown: DefineComponent<ExtractPropTypes<    {
items: {
type: PropType<DropdownItem[]>;
required: true;
};
modelValue: {
type: PropType<DropdownItem | null>;
validator: (v: any) => boolean;
required: true;
};
ariaLabel: StringConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
searchTimeoutMs: {
type: NumberConstructor;
default: number;
};
}>, {
hasToggleSlot: boolean;
closeAndFocusToggleButton: () => void;
dropdownCSSClasses: ComputedRef<    {
'x-dropdown--is-open': Ref<boolean, boolean>;
}>;
emitSelectedItemChanged: (item: DropdownItem) => void;
highlightFirstItem: () => void;
highlightLastItem: () => void;
highlightNextItem: () => void;
highlightPreviousItem: () => void;
highlightedItemIndex: Ref<number, number>;
isOpen: Ref<boolean, boolean>;
itemsButtonRefs: Ref<(HTMLButtonElement | null)[], (HTMLButtonElement | null)[]>;
itemsCSSClasses: ComputedRef<    {
'x-dropdown__item--is-selected': boolean;
'x-dropdown__item--is-highlighted': boolean;
}[]>;
listId: string;
open: () => boolean;
rootRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
toggle: () => boolean;
toggleButtonRef: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
updateSearchBuffer: (event: KeyboardEvent) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: PropType<DropdownItem[]>;
required: true;
};
modelValue: {
type: PropType<DropdownItem | null>;
validator: (v: any) => boolean;
required: true;
};
ariaLabel: StringConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
searchTimeoutMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
animation: string | Function | Record<string, any>;
searchTimeoutMs: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseEventButton: DefineComponent<ExtractPropTypes<    {
events: {
type: PropType<Partial<XEventsTypes>>;
required: true;
};
metadata: {
type: PropType<Omit<WireMetadata, "moduleName">>;
};
}>, {
emitEvents: () => void;
rootRef: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
events: {
type: PropType<Partial<XEventsTypes>>;
required: true;
};
metadata: {
type: PropType<Omit<WireMetadata, "moduleName">>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseEventsModal: DefineComponent<ExtractPropTypes<    {
eventsToOpenModal: {
type: PropType<XEvent[]>;
default: () => XEvent[];
};
eventsToCloseModal: {
type: PropType<XEvent[]>;
default: () => XEvent[];
};
bodyClickEvent: {
type: PropType<XEvent>;
default: string;
};
animation: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
}>, {
isOpen: Ref<boolean, boolean>;
openerElement: Ref<HTMLElement | undefined, HTMLElement | undefined>;
baseModalEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
emitBodyClickEvent: (event: MouseEvent | FocusEvent) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
eventsToOpenModal: {
type: PropType<XEvent[]>;
default: () => XEvent[];
};
eventsToCloseModal: {
type: PropType<XEvent[]>;
default: () => XEvent[];
};
bodyClickEvent: {
type: PropType<XEvent>;
default: string;
};
animation: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
}>> & Readonly<{}>, {
eventsToOpenModal: (keyof XEventsTypes)[];
eventsToCloseModal: (keyof XEventsTypes)[];
bodyClickEvent: keyof XEventsTypes;
}, {}, {
BaseModal: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseEventsModalClose: DefineComponent<ExtractPropTypes<    {
closingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
closingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>> & Readonly<{}>, {
closingEvent: "UserClickedCloseEventsModal" | "UserClickedCloseX" | "UserClickedOutOfMainModal" | "UserClickedOpenEventsModal" | "UserClickedOpenX" | "UserClickedOutOfEventsModal" | "UserOpenXProgrammatically" | "UserReachedEmpathizeTop" | "EmpathizeClosed" | "EmpathizeOpened" | "UserClosedEmpathize" | "UserPressedClearHistoryQueries" | "UserClickedEnableHistoryQueries" | "UserClickedDisableHistoryQueries" | "UserClickedConfirmDisableHistoryQueries" | "UserClickedDismissDisableHistoryQueries" | "ScrollRestoreSucceeded" | "ScrollRestoreFailed" | "UserHoveredInSearchBox" | "UserHoveredOutSearchBox" | "UserBlurredSearchBox" | "UserClickedSearchBox" | "UserFocusedSearchBox" | "UserPressedClearSearchBoxButton" | "ReloadSearchRequested" | "UserReachedResultsListEnd" | "UserClickedAbortARedirection" | "RelatedPromptsUnmounted" | "ReloadRelatedPromptsRequested" | "AiComponentMounted";
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseEventsModalOpen: DefineComponent<ExtractPropTypes<    {
openingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
openingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>> & Readonly<{}>, {
openingEvent: "UserClickedCloseEventsModal" | "UserClickedCloseX" | "UserClickedOutOfMainModal" | "UserClickedOpenEventsModal" | "UserClickedOpenX" | "UserClickedOutOfEventsModal" | "UserOpenXProgrammatically" | "UserReachedEmpathizeTop" | "EmpathizeClosed" | "EmpathizeOpened" | "UserClosedEmpathize" | "UserPressedClearHistoryQueries" | "UserClickedEnableHistoryQueries" | "UserClickedDisableHistoryQueries" | "UserClickedConfirmDisableHistoryQueries" | "UserClickedDismissDisableHistoryQueries" | "ScrollRestoreSucceeded" | "ScrollRestoreFailed" | "UserHoveredInSearchBox" | "UserHoveredOutSearchBox" | "UserBlurredSearchBox" | "UserClickedSearchBox" | "UserFocusedSearchBox" | "UserPressedClearSearchBoxButton" | "ReloadSearchRequested" | "UserReachedResultsListEnd" | "UserClickedAbortARedirection" | "RelatedPromptsUnmounted" | "ReloadRelatedPromptsRequested" | "AiComponentMounted";
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export { BaseFallbackImage }

// @internal
export abstract class BaseFilterEntityModifier<Metadata extends Dictionary = Dictionary> implements FilterEntity<Metadata> {
    constructor(store: Store<RootXStoreState>, entity: FilterEntity);
    deselect(filter: Filter, metadata?: Metadata): void;
    // (undocumented)
    protected entity: FilterEntity;
    select(filter: Filter): void;
    // (undocumented)
    protected store: Store<RootXStoreState>;
}

// @public
export const BaseGrid: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
columns: {
type: NumberConstructor;
default: number;
};
items: {
type: PropType<ListItem[]>;
};
}>, {
gridItems: ComputedRef<GridItem[]>;
cssClasses: ComputedRef<string>;
style: ComputedRef<Partial<CSSStyleDeclaration>>;
gridEl: Ref<HTMLElement | {
$el: HTMLElement;
} | undefined, HTMLElement | {
$el: HTMLElement;
} | undefined>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
columns: {
type: NumberConstructor;
default: number;
};
items: {
type: PropType<ListItem[]>;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
columns: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseHeaderTogglePanel: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
startCollapsed: BooleanConstructor;
headerClass: StringConstructor;
}>, {
open: Ref<boolean, boolean>;
toggleOpen: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
startCollapsed: BooleanConstructor;
headerClass: StringConstructor;
}>> & Readonly<{}>, {
startCollapsed: boolean;
animation: string | Function | Record<string, any>;
}, {}, {
BaseTogglePanel: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseIdModal: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
};
modalId: {
type: StringConstructor;
required: true;
};
}>, {
el: Readonly<ShallowRef<any>>;
isOpen: Ref<boolean, boolean>;
emitClickOutOfModal: (event: MouseEvent | FocusEvent) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
};
modalId: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseModal: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseIdModalClose: DefineComponent<ExtractPropTypes<    {
modalId: {
type: StringConstructor;
required: true;
};
}>, {
closeModal: (input: Event) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modalId: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseIdModalOpen: DefineComponent<ExtractPropTypes<    {
modalId: {
type: StringConstructor;
required: true;
};
}>, {
openModal: (input: Event) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modalId: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseIdTogglePanel: DefineComponent<ExtractPropTypes<    {
startOpen: {
type: BooleanConstructor;
default: boolean;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
panelId: {
type: StringConstructor;
required: true;
};
}>, {
isOpen: Ref<boolean, boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
startOpen: {
type: BooleanConstructor;
default: boolean;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
panelId: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {
startOpen: boolean;
animation: string | Function | Record<string, any>;
}, {}, {
BaseTogglePanel: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseIdTogglePanelButton: DefineComponent<ExtractPropTypes<    {
panelId: {
type: StringConstructor;
required: true;
};
}>, {
isPanelOpen: Ref<boolean, boolean>;
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
panelId: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseKeyboardNavigation: DefineComponent<ExtractPropTypes<    {
navigationHijacker: {
type: PropType<TakeNavigationControl[]>;
default: () => {
xEvent: string;
moduleName: string;
direction: string;
}[];
};
eventsForDirectionLimit: {
type: PropType<Partial<EventsForDirectionLimit>>;
default: () => {
ArrowUp: string;
};
};
}>, {
el: Ref<HTMLElement | undefined, HTMLElement | undefined>;
focusNextNavigableElement: (direction: ArrowKey | KeyboardEvent) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
navigationHijacker: {
type: PropType<TakeNavigationControl[]>;
default: () => {
xEvent: string;
moduleName: string;
direction: string;
}[];
};
eventsForDirectionLimit: {
type: PropType<Partial<EventsForDirectionLimit>>;
default: () => {
ArrowUp: string;
};
};
}>> & Readonly<{}>, {
navigationHijacker: TakeNavigationControl[];
eventsForDirectionLimit: Partial<EventsForDirectionLimit>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseModal: DefineComponent<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
required: true;
};
focusOnOpen: {
type: BooleanConstructor;
default: boolean;
};
referenceSelector: StringConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
overlayAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
contentClass: StringConstructor;
overlayClass: StringConstructor;
}>, {
emitOverlayClicked: (event: Event) => void;
isWaitingForLeave: Ref<boolean, boolean>;
modalContentRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
modalRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("click:overlay" | "focusin:body")[], "click:overlay" | "focusin:body", PublicProps, Readonly<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
required: true;
};
focusOnOpen: {
type: BooleanConstructor;
default: boolean;
};
referenceSelector: StringConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
overlayAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
contentClass: StringConstructor;
overlayClass: StringConstructor;
}>> & Readonly<{
"onClick:overlay"?: ((...args: any[]) => any) | undefined;
"onFocusin:body"?: ((...args: any[]) => any) | undefined;
}>, {
focusOnOpen: boolean;
animation: string | Function | Record<string, any>;
overlayAnimation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { BasePlaceholderImage }

// @public
export const BasePriceFilterLabel: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<{
range: RangeValue;
}>;
required: true;
};
format: {
type: StringConstructor;
};
lessThan: {
type: StringConstructor;
required: true;
};
fromTo: {
type: StringConstructor;
required: true;
};
from: {
type: StringConstructor;
required: true;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<{
range: RangeValue;
}>;
required: true;
};
format: {
type: StringConstructor;
};
lessThan: {
type: StringConstructor;
required: true;
};
fromTo: {
type: StringConstructor;
required: true;
};
from: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseCurrency: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseRating: DefineComponent<ExtractPropTypes<    {
value: {
type: NumberConstructor;
required: true;
};
max: {
type: NumberConstructor;
default: number;
};
}>, {
calculateFilledWrapperWidth: ComputedRef<string>;
ariaLabel: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: NumberConstructor;
required: true;
};
max: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
max: number;
}, {}, {
DefaultIcon: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseRatingFilterLabel: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<BooleanFilter>;
required: true;
};
max: {
type: NumberConstructor;
default: number;
};
}>, {
value: ComputedRef<number>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<BooleanFilter>;
required: true;
};
max: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
max: number;
}, {}, {
BaseRating: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseResultCurrentPrice: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
format: {
type: StringConstructor;
};
}>, {
dynamicClasses: ComputedRef<VueCSSClasses>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
format: {
type: StringConstructor;
};
}>> & Readonly<{}>, {}, {}, {
BaseCurrency: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseResultImage: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
loadAnimation: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
hoverAnimation: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
};
showNextImageOnHover: {
type: BooleanConstructor;
default: boolean;
};
}>, {
pendingImages: Ref<string[], string[]>;
loadedImages: Ref<string[], string[]>;
isHovering: Ref<boolean, boolean>;
userHasHoveredImage: Ref<boolean, boolean>;
loaderStyles: CSSProperties;
animation: ComputedRef<string | Function | Record<string, any>>;
imageSrc: ComputedRef<string>;
shouldLoadNextImage: ComputedRef<boolean>;
flagImageAsFailed: () => void;
flagImageLoaded: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
loadAnimation: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
hoverAnimation: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
};
showNextImageOnHover: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
loadAnimation: string | Function | Record<string, any>;
showNextImageOnHover: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseResultLink: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>, {
el: Ref<any, any>;
emitUserClickedAResult: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseResultPreviousPrice: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
format: {
type: StringConstructor;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
format: {
type: StringConstructor;
};
}>> & Readonly<{}>, {}, {}, {
BaseCurrency: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseResultRating: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
link: {
type: StringConstructor;
};
}>, {
el: Ref<HTMLElement | null | undefined, HTMLElement | null | undefined>;
emitClickedEvent: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
link: {
type: StringConstructor;
};
}>> & Readonly<{}>, {}, {}, {
BaseRating: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseScroll: DefineComponent<ExtractPropTypes<    {
distanceToBottom: {
type: NumberConstructor;
default: number;
};
firstElementThresholdPx: {
type: NumberConstructor;
default: number;
};
throttleMs: {
type: NumberConstructor;
default: number;
};
resetOnChange: {
type: BooleanConstructor;
default: boolean;
};
resetOn: {
type: PropType<XEvent | XEvent[]>;
default: () => string[];
};
}>, {
throttledStoreScrollData: ComputedRef<ThrottleFunction<[]>>;
baseScrollEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("scroll" | "scroll:at-start" | "scroll:almost-at-end" | "scroll:at-end" | "scroll:direction-change")[], "scroll" | "scroll:at-start" | "scroll:almost-at-end" | "scroll:at-end" | "scroll:direction-change", PublicProps, Readonly<ExtractPropTypes<    {
distanceToBottom: {
type: NumberConstructor;
default: number;
};
firstElementThresholdPx: {
type: NumberConstructor;
default: number;
};
throttleMs: {
type: NumberConstructor;
default: number;
};
resetOnChange: {
type: BooleanConstructor;
default: boolean;
};
resetOn: {
type: PropType<XEvent | XEvent[]>;
default: () => string[];
};
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
"onScroll:at-start"?: ((...args: any[]) => any) | undefined;
"onScroll:almost-at-end"?: ((...args: any[]) => any) | undefined;
"onScroll:at-end"?: ((...args: any[]) => any) | undefined;
"onScroll:direction-change"?: ((...args: any[]) => any) | undefined;
}>, {
distanceToBottom: number;
firstElementThresholdPx: number;
throttleMs: number;
resetOnChange: boolean;
resetOn: keyof XEventsTypes | (keyof XEventsTypes)[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseSlider: DefineComponent<ExtractPropTypes<    {
threshold: {
type: PropType<{
min: number;
max: number;
}>;
default: () => {
min: number;
max: number;
};
};
modelValue: {
type: PropType<{
min: number;
max: number;
}>;
required: true;
};
contentClass: {
type: StringConstructor;
default: string;
};
}>, {
slider: Ref<HTMLElement | undefined, HTMLElement | undefined>;
rangeSelected: ComputedRef<number[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
threshold: {
type: PropType<{
min: number;
max: number;
}>;
default: () => {
min: number;
max: number;
};
};
modelValue: {
type: PropType<{
min: number;
max: number;
}>;
required: true;
};
contentClass: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
threshold: {
min: number;
max: number;
};
contentClass: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseSuggestion: DefineComponent<ExtractPropTypes<    {
query: {
type: StringConstructor;
default: string;
};
suggestion: {
type: PropType<Suggestion>;
required: true;
};
feature: {
type: PropType<QueryFeature>;
};
suggestionSelectedEvents: {
type: PropType<Partial<XEventsTypes>>;
required: true;
};
highlightCurated: {
type: BooleanConstructor;
};
}>, {
el: Ref<HTMLElement | null, HTMLElement | null>;
filter: ComputedRef<BooleanFilter | undefined>;
emitEvents: () => void;
dynamicCSSClasses: ComputedRef<VueCSSClasses>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
query: {
type: StringConstructor;
default: string;
};
suggestion: {
type: PropType<Suggestion>;
required: true;
};
feature: {
type: PropType<QueryFeature>;
};
suggestionSelectedEvents: {
type: PropType<Partial<XEventsTypes>>;
required: true;
};
highlightCurated: {
type: BooleanConstructor;
};
}>> & Readonly<{}>, {
query: string;
highlightCurated: boolean;
}, {}, {
Highlight: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseSuggestions: DefineComponent<ExtractPropTypes<    {
suggestions: {
type: PropType<Suggestion[]>;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
showFacets: {
type: BooleanConstructor;
default: boolean;
};
showPlainSuggestion: {
type: BooleanConstructor;
default: boolean;
};
suggestionItemClass: StringConstructor;
}>, {
suggestionsToRender: ComputedRef<Suggestion[]>;
suggestionsKeys: ComputedRef<string[]>;
getSuggestionFilter: (suggestion: Suggestion) => Filter | undefined;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestions: {
type: PropType<Suggestion[]>;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
showFacets: {
type: BooleanConstructor;
default: boolean;
};
showPlainSuggestion: {
type: BooleanConstructor;
default: boolean;
};
suggestionItemClass: StringConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
showFacets: boolean;
showPlainSuggestion: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseSwitch: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
}>, {
cssClasses: ComputedRef<VueCSSClasses>;
toggle: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseTabsPanel: DefineComponent<ExtractPropTypes<    {
tabsAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
contentAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
initialTab: {
type: StringConstructor;
default: string;
};
allowTabDeselect: {
type: BooleanConstructor;
default: boolean;
};
activeTabClass: StringConstructor;
contentClass: StringConstructor;
tabClass: StringConstructor;
tabsListClass: StringConstructor;
}>, {
selectedTab: Ref<string, string>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
getTabs: () => string[];
selectTab: (tab: string) => void;
tabIsSelected: (tab: string) => boolean;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tabsAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
contentAnimation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
initialTab: {
type: StringConstructor;
default: string;
};
allowTabDeselect: {
type: BooleanConstructor;
default: boolean;
};
activeTabClass: StringConstructor;
contentClass: StringConstructor;
tabClass: StringConstructor;
tabsListClass: StringConstructor;
}>> & Readonly<{}>, {
tabsAnimation: string | Function | Record<string, any>;
contentAnimation: string | Function | Record<string, any>;
initialTab: string;
allowTabDeselect: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public (undocumented)
export const BaseTeleport: DefineComponent<ExtractPropTypes<    {
target: {
type: PropType<string | Element>;
required: true;
};
position: {
type: PropType<"beforebegin" | "afterbegin" | "beforeend" | "afterend" | "onlychild">;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
hostStyle: PropType<string | CSSStyleDeclaration>;
}>, {
teleportHost: Ref<HTMLElement | undefined, HTMLElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
target: {
type: PropType<string | Element>;
required: true;
};
position: {
type: PropType<"beforebegin" | "afterbegin" | "beforeend" | "afterend" | "onlychild">;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
hostStyle: PropType<string | CSSStyleDeclaration>;
}>> & Readonly<{}>, {
position: "beforebegin" | "afterbegin" | "beforeend" | "afterend" | "onlychild";
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseTogglePanel: DefineComponent<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const BaseVariableColumnGrid: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
items: PropType<ListItem[]>;
columns: {
type: NumberConstructor;
default: number;
};
}>, {
columnsToRender: ComputedRef<number>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
items: PropType<ListItem[]>;
columns: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
columns: number;
}, {}, {
BaseGrid: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export class BaseXAPI implements XAPI {
    addProductToCart(productId?: string): void;
    // @internal
    protected bus: XBus<XEventsTypes, WireMetadata>;
    close(): void;
    getSnippetConfig: () => SnippetConfig;
    init(config: SnippetConfig): Promise<void>;
    // @internal
    protected initCallback: (config: SnippetConfig) => any;
    // @internal
    protected isXInitialized: boolean;
    search(query?: string): void;
    // @internal
    setBus(bus: XBus<XEventsTypes, WireMetadata>): void;
    setInitCallback(initCallback: (config: SnippetConfig) => any): void;
    setSnippetConfig(config: Partial<SnippetConfig>): void;
    // @internal
    setSnippetConfigCallback(snippetCallback: (config: Partial<SnippetConfig>) => void): void;
    // @internal
    setSnippetConfigGetter(snippetConfigGetter: () => NormalisedSnippetConfig): void;
    // @internal
    protected snippetCallback: (config: Partial<SnippetConfig>) => void;
}

// @public
export class BaseXPriorityQueue<SomeRecord extends Dictionary, SomeData extends Dictionary = Dictionary> implements XPriorityQueue<SomeRecord, SomeData> {
    constructor(comparatorFn?: NumberComparatorFn);
    at(index: number): XPriorityQueueNode<SomeRecord, SomeData> | undefined;
    clear(): void;
    // @internal
    protected comparatorFn: NumberComparatorFn;
    isEmpty(): boolean;
    get keys(): (keyof SomeRecord)[];
    // @internal
    protected nodes: XPriorityQueueNode<SomeRecord, SomeData>[];
    peek(): XPriorityQueueNode<SomeRecord, SomeData> | undefined;
    pop(): XPriorityQueueNode<SomeRecord, SomeData> | undefined;
    push(key: keyof SomeRecord, priority: number, data?: SomeData): void;
    size(): number;
    toString(): string;
}

// @public
export class BaseXPriorityQueueNode<SomeRecord extends Dictionary, SomeData extends Dictionary> implements XPriorityQueueNode<SomeRecord, SomeData> {
    constructor(key: keyof SomeRecord, priority: number, data?: SomeData);
    // (undocumented)
    readonly data: SomeData;
    // (undocumented)
    readonly key: keyof SomeRecord;
    // (undocumented)
    readonly priority: number;
    toString(): string;
}

// @public
export const bus: XPriorityBus<XEventsTypes, WireMetadata>;

// @public
export const cancelFetchAndSaveControls: () => void;

// @public
export const cancelFetchAndSaveIdentifierResults: () => void;

// @public
export const cancelFetchAndSaveIdentifierResultsWire: AnyWire;

// @public
export const cancelFetchAndSaveNextQueries: () => void;

// @public
export const cancelFetchAndSavePartialResultsEnrichment: () => void;

// @public
export const cancelFetchAndSavePopularSearches: () => void;

// @public
export const cancelFetchAndSaveQuerySuggestions: () => void;

// @public
export const cancelFetchAndSaveRecommendations: () => void;

// @public
export const cancelFetchAndSaveRelatedPrompts: () => void;

// @public
export const cancelFetchAndSaveRelatedTags: () => void;

// @public
export const cancelFetchAndSaveRelatedTagsWire: AnyWire;

// @public
export const cancelFetchAndSaveResultsEnrichment: () => void;

// @public
export const cancelFetchAndSaveSearchResponse: () => void;

// @public
export const cancelFetchAndSaveSearchResponseWire: AnyWire;

// @public
export const cancelFetchAndSaveSuggestionsWire: AnyWire;

// @internal
export function cancellablePromise<T, K = unknown>(promise: Promise<T>, cancelCallback?: (payload?: K) => void): CancellablePromiseFunction<T, K>;

// @internal
export interface CancellablePromiseFunction<T, K = unknown> {
    cancel: (payload?: K) => void;
    promise: Promise<T>;
}

// @internal
export const CancelSymbol: unique symbol;

// @public
export function capitalize<StrType extends string>(str: StrType): Capitalize<StrType>;

export { CartFilledIcon }

export { CartIcon }

// @public (undocumented)
export const ChangeHeight: DefineComponent<    {}, {
wrapper: Ref<HTMLElement | undefined, HTMLElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { CheckboxSelectedFilledIcon }

export { CheckboxSelectedIcon }

export { CheckboxUnselectedFilledIcon }

export { CheckboxUnselectedIcon }

export { CheckIcon }

export { CheckTinyIcon }

export { ChevronDownIcon }

export { ChevronLeftIcon }

export { ChevronRightIcon }

export { ChevronTinyDownIcon }

export { ChevronTinyLeftIcon }

export { ChevronTinyRightIcon }

export { ChevronTinyUpIcon }

export { ChevronUpIcon }

// @internal
export function cleanGettersProxyCache(): void;

// @public
export const ClearFilters: DefineComponent<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
}>, {
selectedFilters: ComputedRef<Filter[]>;
hasSelectedFilters: ComputedRef<boolean>;
isVisible: ComputedRef<boolean>;
events: ComputedRef<Partial<XEventsTypes>>;
cssClasses: ComputedRef<VueCSSClasses>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
}>> & Readonly<{}>, {
alwaysVisible: boolean;
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const ClearHistoryQueries: DefineComponent<    {}, {
dynamicClasses: ComputedRef<VueCSSClasses>;
clearHistoryQueriesEvents: Partial<XEventsTypes>;
isHistoryQueriesEmpty: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const clearHistoryQueries: AnyWire;

// @public
export const clearHistoryQueriesQuery: AnyWire;

// @public
export const clearIdentifierResultsQuery: AnyWire;

// @public
export const clearPendingScrollToWire: AnyWire;

// @public
export const clearQueryPreviewWire: Wire<string>;

// @public
export const clearQuerySuggestionsQuery: AnyWire;

// @public
export const clearQueryWire: AnyWire;

// @public
export const clearRelatedTagsQuery: AnyWire;

// @public
export const ClearSearchInput: DefineComponent<    {}, {
dynamicClasses: ComputedRef<VueCSSClasses>;
clearSearchInputEvents: Ref<    {
UserPressedClearSearchBoxButton: undefined;
}, {
UserPressedClearSearchBoxButton: undefined;
} | {
UserPressedClearSearchBoxButton: undefined;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const clearSearchQuery: AnyWire;

// @public
export const clearSelectedQueryPreviewWire: AnyWire;

// @public
export const clearSelectedRelatedTags: AnyWire;

// @public
export function clone<Something>(something: Something): Something;

// @public
export const CloseMainModal: DefineComponent<    {}, {
closingEvent: "UserClickedCloseX";
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseEventsModalClose: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const CollapseHeight: DefineComponent<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>, {
expand: (element: Element) => void;
cleanUpAnimationStyles: (element: Element) => void;
collapse: (element: Element) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
appear: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const CollapseWidth: DefineComponent<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>, {
expand: (element: Element) => void;
cleanUpAnimationStyles: (element: Element) => void;
collapse: (element: Element) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
appear: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface ConfigMutations<T extends {
    config: T['config'];
}> {
    mergeConfig: (config: T['config']) => void;
    setConfig: (config: T['config']) => void;
}

export { CornerArrowLeft }

export { CornerArrowRight }

// @internal
export function createEmitterArrayFilter<T>(comparator: keyof T | ((item1: T, item2: T) => boolean)): (newCollection: Array<T>, oldCollection: Array<T>) => boolean;

// @public
export function createFetchAndSaveActions<Context extends XActionContext<StatusState, object, StatusMutations, object>, Request, Response>(input: FetchAndSaveHooks<Context, Request, Response>): FetchAndSaveActions<Context, Request>;

// @internal
export function createOrigin(input: QueryOriginInit): QueryOrigin | ResultOrigin | null;

// Warning: (ae-forgotten-export) The symbol "RawFilter" needs to be exported by the entry point index.d.ts
//
// @public
export function createRawFilters(filterIds: Array<Filter['id']>): RawFilter[];

// @public
export function createRelatedTagsQueryGetter<State extends QueryState, Getters>(input: CreateRelatedTagsQueryGetterOptions<State, Getters>): (state: State, getters: Getters) => string;

// @public
export interface CreateRelatedTagsQueryGetterOptions<State, Getters> {
    getRelatedTags: (state: State, getters: Getters) => RelatedTag_2[];
}

// Warning: (ae-forgotten-export) The symbol "Taggable" needs to be exported by the entry point index.d.ts
//
// @public
export function createSetQueryTaggingFromQueryPreview(): Wire<Taggable>;

// @public
export function createStoreEmitters<Module extends AnyXStoreModule, Emitters extends StoreEmitters<Module>>(_storeModule: Module, emitters: Emitters): Emitters;

// Warning: (ae-forgotten-export) The symbol "Tagging_2" needs to be exported by the entry point index.d.ts
//
// @public
export function createTrackDisplayWire(property: keyof Tagging_2): Wire<Taggable>;

// @public
export function createTrackRelatedPromptToolingDisplayClickWire(): Wire<any>;

// @public
export function createTrackToolingAdd2CartWire(): Wire<Taggable>;

// @public
export function createTrackToolingDisplayWire(): Wire<Taggable>;

// @public
export function createTrackWire(property: keyof Tagging_2): Wire<Taggable>;

// @public
export function createUseDevice<Device extends string>(devices: Record<Device, number>): () => UseDeviceReturn<Device>;

// @public
export function createWireFromFunction<Payload>(fn: (parameters: WireParams<Payload>) => void): Wire<Payload>;

// @public
export function createWiring<T extends Partial<Wiring>>(wiring: T): T;

// @public
export const CrossFade: DefineComponent<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
appear: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { CrossIcon }

export { CrossTinyIcon }

export { CuratedCheckFilledIcon }

export { CuratedCheckIcon }

export { CuratedCheckTinyFilledIcon }

export { CuratedCheckTinyIcon }

// @public
export function currencyFormatter(value: number, format?: string): string;

// @public
export function debounce<Payload>(wire: Wire<Payload>, timeInMs: TimeSelector | number, options?: TimedWireOperatorOptions): Wire<Payload>;

// @public
export interface DebouncedFunction<Params extends any[]> {
    // (undocumented)
    (...args: Params): void;
    // (undocumented)
    cancel: () => void;
}

// @public
export const debounceFunction: <Params extends any[]>(fn: (...args: Params) => void, debounceTimeInMs: number, input?: DebounceOptions) => DebouncedFunction<Params>;

// @public
export interface DebounceOptions {
    // (undocumented)
    leading?: boolean;
    // (undocumented)
    trailing?: boolean;
}

// @public
export type DecoratorFor<Type> = <Key extends string, Target extends Record<Key, Type>>(target: Target, key: Key) => void;

// @public
export function deepFilter<Item extends {
    [key in Key]?: Item[];
}, Key extends keyof Item>(array: Item[], condition: (item: Item) => boolean, childrenKey: Key): Item[];

// @public
export function deepFlat<Item extends {
    [key in Key]?: Item[];
}, Key extends keyof Item>(array: Item[], childrenKey: Key): Item[];

// @public
export class DefaultExternalTaggingService implements ExternalTaggingService {
    constructor(localStorageService?: StorageService, sessionStorageService?: StorageService);
    static readonly ADD_TO_CART_ID_KEY = "checkout";
    // @internal
    protected getPathName(url: string): string;
    // @internal
    protected getStorageId(keyPrefix: string, id?: string): string | null;
    static instance: ExternalTaggingService;
    // (undocumented)
    protected localStorageService: StorageService;
    moveToSessionStorage(id?: string): void;
    static readonly RESULT_CLICKED_ID_KEY = "add-to-cart";
    // (undocumented)
    protected sessionStorageService: StorageService;
    // @internal
    protected showWarningMessage(): void;
    // (undocumented)
    protected get storageKey(): string;
    // (undocumented)
    protected get storageTTLMs(): number;
    // (undocumented)
    protected get store(): Store<RootXStoreState>;
    storeAddToCart(result: Result): void;
    storeResultClicked(result: Result): void;
    trackAddToCart(id?: string): void;
}

// @public
export class DefaultFacetsService implements FacetsService {
    // Warning: (ae-incompatible-release-tags) The symbol "__constructor" is marked as @public, but its signature references "FilterEntityFactory" which is marked as @internal
    constructor(filterEntityFactory?: FilterEntityFactory);
    // (undocumented)
    clearFilters(facetIds?: Array<Facet['id']>, metadata?: FiltersMetadata): void;
    // (undocumented)
    clearFiltersWithMetadata(input?: {
        facetIds?: Array<Facet['id']>;
        metadata?: FiltersMetadata;
    }): void;
    // (undocumented)
    deselect(filter: Filter, metadata?: Dictionary): void;
    // Warning: (ae-incompatible-release-tags) The symbol "filterEntityFactory" is marked as @public, but its signature references "FilterEntityFactory" which is marked as @internal
    //
    // (undocumented)
    protected filterEntityFactory: FilterEntityFactory;
    // @internal
    protected flatFilters(facetsGroup: FacetsGroup): Filter[];
    // @internal
    protected getFilterEntity(filter: Filter): FilterEntity;
    // @internal
    protected getSelectedFilters(): FacetsGetters['selectedFilters'];
    static instance: FacetsService;
    // @internal
    protected removeFacet(facet: Omit<Facet, 'filters'>): void;
    // @internal
    protected removeFilters(filters: Filter[]): void;
    // @internal
    protected removeGroupFacets(groupId: FacetsGroup['id']): Omit<Facet, 'filters'>[];
    // @internal
    protected removeGroupFilters(groupId: FacetsGroup['id']): Filter[];
    // (undocumented)
    select(filterOrFilters: Filter | Filter[]): void;
    // (undocumented)
    selectPreselectedFilters(): void;
    // @internal
    protected setFacet(input: Facet): void;
    // @internal
    protected setFacetGroup(facetGroup: FacetGroupEntry): void;
    // (undocumented)
    setFacets(facetsGroup: FacetsGroup): void;
    // @internal
    protected setFilters(filters: Filter[]): void;
    // @internal
    protected setPreselectedFilter(filters: Filter[]): void;
    // @internal
    setQuery(query: string): void;
    // @internal
    protected get store(): Store<RootXStoreState>;
    // (undocumented)
    toggle(filter: Filter): void;
    // (undocumented)
    updateFacets(facetsGroup: FacetsGroup): void;
    protected updateFiltersSelectedState(newFilters: Filter[], previousFilters?: Filter[]): void;
    // (undocumented)
    updatePreselectedFilters(filters: Filter[]): void;
    // @internal
    protected updateStore(facetsGroup: FacetsGroup): Filter[];
}

// @public
export class DefaultResultsEnrichmentService implements ResultsEnrichmentService {
    constructor();
    fetchResults(_: Result[]): Promise<any[]>;
    static instance: ResultsEnrichmentService;
    // (undocumented)
    protected get store(): Store<RootXStoreState>;
    updateResults(_: Result[], __: any[]): void;
}

// @public
export interface DeviceActions {
}

// @public
export const DeviceDetector: DefineComponent<ExtractPropTypes<    {
breakpoints: {
type: PropType<Record<Device, MaxWidth>>;
default: () => {};
};
force: PropType<Device>;
throttleMs: {
type: NumberConstructor;
default: number;
};
}>, {
throttledStoreWindowWidth: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
breakpoints: {
type: PropType<Record<Device, MaxWidth>>;
default: () => {};
};
force: PropType<Device>;
throttleMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
breakpoints: Record<string, number>;
throttleMs: number;
}, {}, {
GlobalEvents: new () => {
$props: VNodeProps & GlobalEventsProps;
};
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export const deviceEmitters: {};

// @public
export interface DeviceGetters {
}

// @public
export interface DeviceMutations {
    setName: (device: string | null) => void;
}

// @public
export interface DeviceState {
    name: string | null;
}

// @internal
export const deviceWiring: {
    DeviceProvided: {
        setName: Wire<string | null>;
    };
};

// @public
export interface DeviceXEvents {
    DeviceProvided: string | null;
}

// @public
export type DeviceXModule = XModule<DeviceXStoreModule>;

// @public
export const deviceXModule: DeviceXModule;

// @public
export type DeviceXStoreModule = XStoreModule<DeviceState, DeviceGetters, DeviceMutations, DeviceActions>;

// @internal
export const deviceXStoreModule: DeviceXStoreModule;

export { DiagonalArrowLeftDownIcon }

export { DiagonalArrowLeftTopIcon }

export { DiagonalArrowRightDownIcon }

export { DiagonalArrowRightTopIcon }

// @public
export class DirectionalFocusNavigationService implements SpatialNavigation {
    constructor(
    container: HTMLElement,
    focusableSelectors?: string);
    // @internal
    filterCandidates(rawCandidates: HTMLElement[]): HTMLElement[];
    navigateTo(arrowKey: ArrowKey): HTMLElement;
}

// @internal
export const DISABLE_ANIMATIONS_KEY: XInjectKey<boolean | undefined>;

// @public (undocumented)
export const DisplayClickProvider: DefineComponent<ExtractPropTypes<    {
resultFeature: {
type: PropType<ResultFeature>;
required: true;
};
ignoreResultClickEvent: {
type: BooleanConstructor;
default: boolean;
};
toolingDisplayTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
toolingAdd2CartTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
queryTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
resultFeature: {
type: PropType<ResultFeature>;
required: true;
};
ignoreResultClickEvent: {
type: BooleanConstructor;
default: boolean;
};
toolingDisplayTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
toolingAdd2CartTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
queryTagging: {
type: PropType<TaggingRequest>;
required: false;
default: undefined;
};
}>> & Readonly<{}>, {
ignoreResultClickEvent: boolean;
toolingDisplayTagging: TaggingRequest;
toolingAdd2CartTagging: TaggingRequest;
queryTagging: TaggingRequest;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const DisplayEmitter: DefineComponent<ExtractPropTypes<    {
payload: {
type: PropType<TaggingRequest>;
required: true;
};
eventMetadata: {
type: PropType<Omit<WireMetadata, "moduleName" | "origin" | "location">>;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
payload: {
type: PropType<TaggingRequest>;
required: true;
};
eventMetadata: {
type: PropType<Omit<WireMetadata, "moduleName" | "origin" | "location">>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface DisplayWireMetadata extends WireMetadata {
    displayOriginalQuery: string;
}

// @public
export type DocumentDirection = 'ltr' | 'rtl';

// @public
export const EditableNumberRangeFilter: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<EditableNumberRangeFilter_2>;
required: true;
};
isInstant: BooleanConstructor;
hasClearButton: {
type: BooleanConstructor;
default: boolean;
};
inputsClass: StringConstructor;
buttonsClass: StringConstructor;
}>, {
rangeFilterMin: string;
rangeFilterMax: string;
cssClasses: ComputedRef<    {
'x-editable-number-range-filter--error': boolean;
}>;
min: Ref<number | null, number | null>;
max: Ref<number | null, number | null>;
setMin: (value: number) => void;
setMax: (value: number) => void;
emitUserModifiedFilter: () => void;
clearValues: () => void;
hasError: ComputedRef<boolean>;
isAnyRange: ComputedRef<boolean>;
renderClearButton: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<EditableNumberRangeFilter_2>;
required: true;
};
isInstant: BooleanConstructor;
hasClearButton: {
type: BooleanConstructor;
default: boolean;
};
inputsClass: StringConstructor;
buttonsClass: StringConstructor;
}>> & Readonly<{}>, {
isInstant: boolean;
hasClearButton: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export class EditableNumberRangeFilterEntity implements FilterEntity {
    constructor(store: Store<RootXStoreState>);
    // (undocumented)
    static accepts(filter: Filter): boolean;
    deselect(filterParam: Filter): void;
    protected getFilterByFacet(facetId: Facet['id']): EditableNumberRangeFilter_2 | undefined;
    protected getNewFilterId(filter: Pick<EditableNumberRangeFilter_2, 'range' | 'facetId'>): string;
    protected isSelected(filter: EditableNumberRangeFilter_2): boolean;
    protected removePreviousFilter(facetId: Facet['id']): void;
    select(filterParam: Filter): void;
    // (undocumented)
    protected store: Store<RootXStoreState>;
}

// @public
export interface EmittedData<SomeEvents extends Dictionary, SomeEvent extends keyof SomeEvents, SomeEventMetadata extends Dictionary> {
    event: SomeEvent;
    eventPayload: EventPayload<SomeEvents, SomeEvent>;
    metadata: SomeEventMetadata;
}

// @public
export type Emitter<SomeEvents extends Dictionary, SomeEvent extends keyof SomeEvents, SomeEventMetadata extends Dictionary> = Subject<SubjectPayload<EventPayload<SomeEvents, SomeEvent>, SomeEventMetadata>>;

// @public
export type Emitters<SomeEvents extends Dictionary, SomeEventMetadata extends Dictionary> = {
    [SomeEvent in keyof SomeEvents]?: Emitter<SomeEvents, SomeEvent, SomeEventMetadata>;
};

// @public
export const Empathize: DefineComponent<ExtractPropTypes<    {
eventsToOpenEmpathize: {
type: PropType<XEvent[]>;
default: () => string[];
};
eventsToCloseEmpathize: {
type: PropType<XEvent[]>;
default: () => string[];
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
hasContent: {
type: BooleanConstructor;
default: boolean;
};
searchAndCloseOnNoContent: {
type: BooleanConstructor;
default: boolean;
};
searchAndCloseDebounceInMs: {
type: NumberConstructor;
default: number;
};
}>, {
empathizeRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
isOpenAndHasContent: ComputedRef<boolean>;
open: () => void;
close: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
eventsToOpenEmpathize: {
type: PropType<XEvent[]>;
default: () => string[];
};
eventsToCloseEmpathize: {
type: PropType<XEvent[]>;
default: () => string[];
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
hasContent: {
type: BooleanConstructor;
default: boolean;
};
searchAndCloseOnNoContent: {
type: BooleanConstructor;
default: boolean;
};
searchAndCloseDebounceInMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
eventsToOpenEmpathize: (keyof XEventsTypes)[];
eventsToCloseEmpathize: (keyof XEventsTypes)[];
animation: string | Function | Record<string, any>;
hasContent: boolean;
searchAndCloseOnNoContent: boolean;
searchAndCloseDebounceInMs: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface EmpathizeActions {
}

// @public
export interface EmpathizeConfig {
}

// @internal
export const empathizeEmitters: {};

// @public
export interface EmpathizeGetters {
}

// @public
export interface EmpathizeMutations extends ConfigMutations<EmpathizeState> {
    setIsOpen: (isOpen: boolean) => void;
}

// @public
export interface EmpathizeState {
    config: EmpathizeConfig;
    isOpen: boolean;
}

// @internal
export const empathizeWiring: {
    EmpathizeOpened: {
        setIsOpen: AnyWire;
    };
    EmpathizeClosed: {
        setIsNotOpen: AnyWire;
    };
};

// @public
export interface EmpathizeXEvents {
    EmpathizeClosed: void;
    EmpathizeOpened: void;
    UserClosedEmpathize: void;
}

// @public
export type EmpathizeXModule = XModule<EmpathizeXStoreModule>;

// @public
export const empathizeXModule: EmpathizeXModule;

// @public
export type EmpathizeXStoreModule = XStoreModule<EmpathizeState, EmpathizeGetters, EmpathizeMutations, EmpathizeActions>;

// @internal
export const empathizeXStoreModule: EmpathizeXStoreModule;

// @public
export type EventPayload<SomeEvents extends Dictionary, SomeEvent extends keyof SomeEvents> = SomeEvents[SomeEvent] extends void ? undefined : SomeEvents[SomeEvent];

// @public
export type EventsForDirectionLimit = {
    [key in ArrowKey]: PropsWithType<XEventsTypes, void>;
};

// @public
export const ExcludeFiltersWithNoResults: DefineComponent<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const ExperienceControls: DefineComponent<    {}, () => void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type ExperienceControlsActionContext = XActionContext<ExperienceControlsState, ExperienceControlsGetters, ExperienceControlsMutations, ExperienceControlsActions>;

// @public
export interface ExperienceControlsActions {
    cancelFetchAndSaveControls: () => void;
    fetchAndSaveExperienceControlsResponse: (request: ExperienceControlsRequest | null) => void;
    // Warning: (ae-forgotten-export) The symbol "ExperienceControlsRequest" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "ExperienceControlsResponse" needs to be exported by the entry point index.d.ts
    fetchExperienceControlsResponse: (request: ExperienceControlsRequest | null) => ExperienceControlsResponse;
}

// @internal
export const experienceControlsEmitters: {
    ExperienceControlsEventsChanged: {
        selector: (state: ExperienceControlsState) => Partial<XEventsTypes>;
    };
    ExperienceControlsRequestUpdated: (_: ExperienceControlsState, getters: Returns<GettersTree<ExperienceControlsState, ExperienceControlsGetters>>) => ExperienceControlsRequest | null;
};

// @public
export interface ExperienceControlsGetters {
    experienceControlsRequest: ExperienceControlsRequest | null;
}

// @public
export interface ExperienceControlsMutations extends StatusMutations {
    setControls: (controls: Dictionary<unknown>) => void;
    setEvents: (events: Partial<XEventsTypes>) => void;
    setParams: (params: Dictionary<unknown>) => void;
}

// @public
export const experienceControlsRequest: ExperienceControlsXStoreModule['getters']['experienceControlsRequest'];

// @public
export interface ExperienceControlsState extends StatusState {
    controls: Dictionary<unknown>;
    // (undocumented)
    events: Partial<XEventsTypes>;
    // (undocumented)
    params: Dictionary<unknown>;
}

// @internal
export const experienceControlsWiring: {
    ExtraParamsChanged: {
        setParamsWire: Wire<Dictionary<unknown>>;
    };
    ExperienceControlsRequestUpdated: {
        fetchAndSaveExperienceControlsWire: Wire<ExperienceControlsRequest | null>;
    };
};

// @public
export interface ExperienceControlsXEvents {
    // (undocumented)
    ExperienceControlsEventsChanged: Partial<XEventsTypes>;
    // (undocumented)
    ExperienceControlsRequestUpdated: ExperienceControlsRequest | null;
}

// @public
export type ExperienceControlsXModule = XModule<ExperienceControlsXStoreModule>;

// @public
export const experienceControlsXModule: ExperienceControlsXModule;

// @public
export type ExperienceControlsXStoreModule = XStoreModule<ExperienceControlsState, ExperienceControlsGetters, ExperienceControlsMutations, ExperienceControlsActions>;

// @internal
export const experienceControlsXStoreModule: ExperienceControlsXStoreModule;

// @public
export interface ExternalTaggingService {
    moveToSessionStorage: (id?: string) => void;
    storeAddToCart: (result: Result) => void;
    storeResultClicked: (result: Result) => void;
    trackAddToCart: (id?: string) => void;
}

// @public
export type ExtractActionPayload<ModuleName extends XModuleName, ActionName extends ActionNamesFor<ModuleName>> = ExtractPayload<ExtractActions<XModulesTree[ModuleName]>[ActionName]>;

// @public
export type ExtractActionReturn<Action extends (payload?: any) => any> = ReturnType<Action> extends Promise<any> ? ReturnType<Action> : Promise<ReturnType<Action>>;

// @public
export type ExtractActions<Module extends AnyXModule> = Module extends XModule<XStoreModule<any, any, any, infer Actions>> ? Actions : never;

// @public
export type ExtractGetters<Module extends XModuleName> = XModulesTree[Module] extends XModule<XStoreModule<any, infer Getter, any, any>> ? Getter : never;

// @public
export type ExtractMutationPayload<ModuleName extends XModuleName, MutationName extends MutationNamesFor<ModuleName>> = ExtractPayload<ExtractMutations<XModulesTree[ModuleName]>[MutationName]>;

// @public
export type ExtractMutations<Module extends AnyXModule> = Module extends XModule<XStoreModule<any, any, infer Mutations, any>> ? Mutations : never;

// @public
export type ExtractPayload<SomeFunction> = SomeFunction extends (payload?: any) => any ? Parameters<SomeFunction>[0] : never;

// @public
export type ExtractState<Module extends XModuleName> = XModulesTree[Module] extends XModule<XStoreModule<infer State, any, any, any>> ? State : never;

// @public
export const ExtraParams: DefineComponent<ExtractPropTypes<    {
values: {
type: PropType<Dictionary<unknown>>;
required: true;
};
}>, () => void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
values: {
type: PropType<Dictionary<unknown>>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface ExtraParamsActions {
}

// @internal
export const extraParamsEmitters: {
    ExtraParamsChanged: {
        selector: (state: ExtraParamsState) => Dictionary<unknown>;
        metadata: {
            priority: number;
        };
    };
};

// @public
export interface ExtraParamsGetters {
}

// @public
export interface ExtraParamsMutations {
    // (undocumented)
    setParams: (params: Dictionary<unknown>) => void;
}

// @public
export interface ExtraParamsState {
    // (undocumented)
    params: Dictionary<unknown>;
}

// @internal
export const extraParamsWiring: {
    UserChangedExtraParams: {
        setExtraParams: Wire<Dictionary<unknown>>;
    };
    ExtraParamsProvided: {
        setExtraParams: Wire<Dictionary<unknown>>;
    };
    ExtraParamsLoadedFromUrl: {
        setExtraParams: Wire<Dictionary<unknown>>;
    };
};

// @public
export interface ExtraParamsXEvents {
    ExtraParamsChanged: Dictionary<unknown>;
    ExtraParamsInitialized: Dictionary<unknown>;
    ExtraParamsProvided: Dictionary<unknown>;
    UserChangedExtraParams: Dictionary<unknown>;
}

// @public
export type ExtraParamsXModule = XModule<ExtraParamsXStoreModule>;

// @public
export const extraParamsXModule: ExtraParamsXModule;

// @public
export type ExtraParamsXStoreModule = XStoreModule<ExtraParamsState, ExtraParamsGetters, ExtraParamsMutations, ExtraParamsActions>;

// @internal
export const extraParamsXStoreModule: ExtraParamsXStoreModule;

// @public
export interface ExtraPluginsOptions {
    app: App;
    bus: XBus<XEventsTypes, WireMetadata>;
    snippet: NormalisedSnippetConfig;
}

// @public
export interface FacetGroupEntry {
    facetId: Facet['id'];
    groupId: GroupId;
}

// @public
export const Facets: DefineComponent<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
renderableFacets: StringConstructor;
}>, {
selectedFiltersByFacet: ComputedRef<FiltersByFacet>;
hasFacets: ComputedRef<boolean>;
mappedFacets: ComputedRef<Dictionary<RenderFacet>>;
hasSlot: (name: string) => boolean;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
renderableFacets: StringConstructor;
}>> & Readonly<{}>, {
alwaysVisible: boolean;
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const facets: FacetsXStoreModule['getters']['facets'];

// @public
export interface FacetsActions {
    cancelFetchAndSaveFacetsResponse: () => void;
    // Warning: (ae-forgotten-export) The symbol "FacetsRequest" needs to be exported by the entry point index.d.ts
    fetchAndSaveFacetsResponse: (request: FacetsRequest | null) => void;
    // Warning: (ae-forgotten-export) The symbol "FacetsResponse" needs to be exported by the entry point index.d.ts
    fetchFacetsResponse: (request: FacetsRequest) => FacetsResponse;
    saveOrigin: (originInit: QueryOriginInit) => void;
}

// @public
export type FacetsActionsContext = XActionContext<FacetsState, FacetsGetters, FacetsMutations, FacetsActions>;

// @public
export interface FacetsConfig {
    filtersStrategyForRequest: filtersStrategyForRequest;
}

// @internal
export const facetsEmitters: {
    SelectedFiltersChanged: {
        selector: (_: FacetsState, getters: Returns<GettersTree<FacetsState, FacetsGetters>>) => Filter[];
        filter: typeof areFiltersDifferent;
        metadata: {
            priority: number;
        };
    };
    SelectedFiltersForRequestChanged: {
        selector: (_: FacetsState, getters: Returns<GettersTree<FacetsState, FacetsGetters>>) => Filter[];
        filter: typeof areFiltersDifferent;
        metadata: {
            priority: number;
        };
    };
    FacetsQueryChanged: {
        selector: (state: FacetsState) => string;
        filter: typeof isNewQuery;
    };
};

// @public
export interface FacetsGetters {
    facets: Record<Facet['id'], Facet>;
    request: FacetsRequest | null;
    selectedFilters: Filter[];
    selectedFiltersByFacet: FiltersByFacet;
    selectedFiltersForRequest: Filter[];
}

// @public
export interface FacetsGroup {
    facets: Facet[];
    id: string;
}

// @public
export interface FacetsMutations extends StatusMutations, QueryMutations, ConfigMutations<FacetsState> {
    clearStickyFilters: () => void;
    mutateFilter: (payload: MutateFilterPayload) => void;
    removeFacet: (facet: Facet) => void;
    removeFilter: (filter: Filter) => void;
    removeFilters: (filters: Filter[]) => void;
    removeStickyFilter: (filter: RawFilter) => void;
    setFacet: (facet: Facet) => void;
    setFacetGroup: (facetGroupEntry: FacetGroupEntry) => void;
    setFilters: (filters: Filter[]) => void;
    setOrigin: (origin: QueryOrigin | undefined | null) => void;
    setParams: (params: Dictionary<unknown>) => void;
    setPreselectedFilters: (filters: RawFilter[]) => void;
    setStickyFilter: (filter: RawFilter) => void;
}

// @public
export const FacetsProvider: DefineComponent<ExtractPropTypes<    {
groupId: {
type: PropType<GroupId>;
default: string;
};
facets: {
type: PropType<Facet[]>;
required: true;
};
}>, () => string, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
groupId: {
type: PropType<GroupId>;
default: string;
};
facets: {
type: PropType<Facet[]>;
required: true;
};
}>> & Readonly<{}>, {
groupId: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface FacetsService {
    clearFilters: (facetIds?: Array<Facet['id']>, metadata?: FiltersMetadata) => void;
    clearFiltersWithMetadata: (payload?: {
        facetIds?: Array<Facet['id']>;
        metadata?: FiltersMetadata;
    }) => void;
    deselect: (filter: Filter, metadata?: FiltersMetadata) => void;
    select: (filter: Filter | Filter[]) => void;
    selectPreselectedFilters: () => void;
    setFacets: (facetsGroup: FacetsGroup) => void;
    setQuery: (query: string) => void;
    toggle: (filter: Filter) => void;
    updateFacets: (facetsGroup: FacetsGroup) => void;
    updatePreselectedFilters: (filters: Filter[]) => void;
}

// @public
export interface FacetsState extends StatusState, QueryState {
    config: FacetsConfig;
    facets: Record<Facet['id'], Omit<Facet, 'filters'>>;
    filters: Record<Filter['id'], Filter>;
    groups: Record<Facet['id'], GroupId>;
    origin: QueryOrigin | null;
    params: Dictionary<unknown>;
    preselectedFilters: RawFilter[];
    stickyFilters: Record<Filter['id'], Filter>;
}

// @internal
export const facetsWiring: {
    ParamsLoadedFromUrl: {
        clearAllFiltersWire: AnyWire;
        setFiltersFromUrl: Wire<UrlParams>;
    };
    PreselectedFiltersProvided: {
        updatePreselectedFilters: Wire<Filter[]>;
    };
    FacetsChanged: {
        updateFacetsGroupWithSearchFacetsWire: Wire<Facet[]>;
    };
    FacetsGroupProvided: {
        setFacetsGroupWire: Wire<FacetsGroup>;
    };
    UserAcceptedAQuery: {
        setQuery: Wire<string>;
    };
    FacetsQueryChanged: {
        clearAllFiltersOnSecondQuery: Wire<any>;
    };
    UserChangedExtraParams: {
        clearAllFiltersButStickyWire: AnyWire;
    };
    UserClickedAFilter: {
        toggleFilterWire: Wire<Filter>;
    };
    UserClickedClearAllFilters: {
        clearFiltersWire: Wire<(string | number)[] | undefined>;
    };
    UserModifiedEditableNumberRangeFilter: {
        selectFilterWire: Wire<Filter | Filter[]>;
    };
    UserClickedAllFilter: {
        clearFiltersWire: Wire<(string | number)[] | undefined>;
    };
    UserClearedQuery: {
        clearAllFiltersButStickyWire: AnyWire;
        setQuery: Wire<string>;
    };
    UserClickedOpenX: {
        selectPreselectedFilterWire: Wire<undefined>;
    };
    SearchResponseChanged: {
        clearStickyFilters: Wire<InternalSearchResponse>;
    };
    UserAcceptedAQueryPreview: {
        setQueryFromPreview: AnyWire;
        setSelectedFiltersFromPreview: AnyWire;
    };
    UserSelectedAHistoryQuery: {
        setFiltersFromHistoryQueries: AnyWire;
    };
};

// @public
export interface FacetsXEvents {
    FacetsGroupChanged: FacetsGroup;
    FacetsGroupProvided: FacetsGroup;
    FacetsQueryChanged: string;
    PreselectedFiltersProvided: RawFilter[];
    SelectedFiltersChanged: Filter[];
    SelectedFiltersForRequestChanged: Filter[];
    UserChangedSelectedFilters: Filter[];
    UserClickedAFilter: Filter;
    UserClickedAHierarchicalFilter: HierarchicalFilter_2;
    UserClickedAllFilter: [Facet['id']];
    // Warning: (ae-forgotten-export) The symbol "NumberRangeFilter_2" needs to be exported by the entry point index.d.ts
    UserClickedANumberRangeFilter: NumberRangeFilter_2;
    // Warning: (ae-forgotten-export) The symbol "SimpleFilter_2" needs to be exported by the entry point index.d.ts
    UserClickedASimpleFilter: SimpleFilter_2;
    UserClickedClearAllFilters: Array<Facet['id']> | undefined;
    UserModifiedEditableNumberRangeFilter: EditableNumberRangeFilter_2;
}

// @public
export type FacetsXModule = XModule<FacetsXStoreModule>;

// @public
export const facetsXModule: FacetsXModule;

// @public
export type FacetsXStoreModule = XStoreModule<FacetsState, FacetsGetters, FacetsMutations, FacetsActions>;

// @internal
export const facetsXStoreModule: FacetsXStoreModule;

// @public
export const Fade: DefineComponent<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
appear: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const FadeAndSlide: DefineComponent<ExtractPropTypes<    {
tag: StringConstructor;
appear: {
type: BooleanConstructor;
default: boolean;
};
}>, {
name: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: StringConstructor;
appear: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
appear: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const FallbackDisclaimer: DefineComponent<    {}, {
query: ComputedRef<string>;
fromNoResultsWithFilters: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type FeatureLocation = 'external' | 'my_history' | 'no_query' | 'results' | 'no_results' | 'low_results' | 'none' | 'predictive_layer' | 'pdp' | 'url_history' | 'url_history_pdp' | 'related_prompts' | 'add2cart' | 'overview';

// @public
export interface FetchAndSaveActions<Context extends XActionContext<StatusState, object, StatusMutations, object>, Request> {
    cancelPrevious: () => void;
    fetchAndSave: (context: Context, request: Request) => void | Promise<void>;
}

// @public
export const fetchAndSaveAiSuggestions: AiXStoreModule['actions']['fetchAndSaveAiSuggestions'];

// @public
export const fetchAndSaveAiSuggestionsSearch: AiXStoreModule['actions']['fetchAndSaveAiSuggestionsSearch'];

// @public
export const fetchAndSaveExperienceControlsResponse: (context: ExperienceControlsActionContext, request: ExperienceControlsRequest | null) => void | Promise<void>;

// @public
export const fetchAndSaveExperienceControlsWire: Wire<ExperienceControlsRequest | null>;

// @public
export interface FetchAndSaveHooks<Context extends XActionContext<StatusState, object, StatusMutations, object>, Request, Response> {
    fetch: (context: Context, request: Request) => Promise<Response>;
    onCancel?: () => void;
    onError?: (error: unknown) => void;
    onSuccess: (context: Context, response: Response) => void;
}

// Warning: (ae-forgotten-export) The symbol "IdentifierResultsRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveIdentifierResults: (context: IdentifierResultsActionsContext, request: IdentifierResultsRequest | null) => void | Promise<void>;

// @public
export const fetchAndSaveIdentifierResultsWire: Wire<IdentifierResultsRequest | null>;

// Warning: (ae-forgotten-export) The symbol "NextQueriesRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveNextQueries: (context: NextQueriesActionContext, request: NextQueriesRequest | null) => void | Promise<void>;

// @public
export const fetchAndSaveNextQueriesWire: Wire<NextQueriesRequest | null>;

// @public
export const fetchAndSaveNextQueryPreviewWire: AnyWire;

// Warning: (ae-forgotten-export) The symbol "PartialResult" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSavePartialResultsEnrichment: (context: SearchActionContext, request: PartialResult[]) => void | Promise<void>;

// @public
export const fetchAndSavePartialResultsEnrichmentWire: Wire<PartialResult[]>;

// Warning: (ae-forgotten-export) The symbol "PopularSearchesRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSavePopularSearches: (context: PopularSearchesActionContext, request: PopularSearchesRequest) => void | Promise<void>;

// @public
export const fetchAndSaveQueryPreview: QueriesPreviewXStoreModule['actions']['fetchAndSaveQueryPreview'];

// @public
export const fetchAndSaveQueryPreviewResultsEnrichmentWire: Wire<QueryPreviewItem>;

// Warning: (ae-forgotten-export) The symbol "SearchRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveQueryPreviewWire: Wire<SearchRequest>;

// Warning: (ae-forgotten-export) The symbol "QuerySuggestionsRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveQuerySuggestions: (context: QuerySuggestionsActionContext, request: QuerySuggestionsRequest | null) => void | Promise<void>;

// Warning: (ae-forgotten-export) The symbol "RecommendationsRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveRecommendations: (context: RecommendationsActionContext, request: RecommendationsRequest | null) => void | Promise<void>;

// Warning: (ae-forgotten-export) The symbol "RelatedPromptsRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveRelatedPrompts: (context: RelatedPromptsActionContext, request: RelatedPromptsRequest | null) => void | Promise<void>;

// Warning: (ae-forgotten-export) The symbol "RelatedTagsRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveRelatedTags: (context: RelatedTagsActionContext, request: RelatedTagsRequest | null) => void | Promise<void>;

// @public
export const fetchAndSaveRelatedTagsWire: Wire<RelatedTagsRequest | null>;

// @public
export const fetchAndSaveResultsEnrichment: (context: SearchActionContext, request: Result[]) => void | Promise<void>;

// @public
export const fetchAndSaveResultsEnrichmentWire: Wire<Result[]>;

// @public
export const fetchAndSaveSearchResponse: (context: SearchActionContext, request: InternalSearchRequest | null) => void | Promise<void>;

// @public
export const fetchAndSaveSearchResponseWire: Wire<InternalSearchRequest | null>;

// @public
export const fetchAndSaveSemanticQuery: SemanticQueriesXStoreModule['actions']['fetchAndSaveSemanticQuery'];

// Warning: (ae-forgotten-export) The symbol "SemanticQueriesRequest" needs to be exported by the entry point index.d.ts
//
// @public
export const fetchAndSaveSemanticQueryWire: Wire<SemanticQueriesRequest | null>;

// @public
export const fetchAndSaveSuggestionsWire: Wire<QuerySuggestionsRequest | null>;

// @public
export const fetchExperienceControlsResponse: ExperienceControlsXStoreModule['actions']['fetchExperienceControlsResponse'];

// @public
export const fetchIdentifierResults: IdentifierResultsXStoreModule['actions']['fetchIdentifierResults'];

// @public
export const fetchNextQueries: NextQueriesXStoreModule['actions']['fetchNextQueries'];

// @public
export const fetchPopularSearches: PopularSearchesXStoreModule['actions']['fetchSuggestions'];

// @public
export const fetchQueryPreview: QueriesPreviewXStoreModule['actions']['fetchQueryPreview'];

// @public
export const fetchQuerySuggestions: QuerySuggestionsXStoreModule['actions']['fetchSuggestions'];

// @public
export const fetchRecommendations: RecommendationsXStoreModule['actions']['fetchRecommendations'];

// @public
export const fetchRelatedPrompts: RelatedPromptsXStoreModule['actions']['fetchRelatedPrompts'];

// @public
export const fetchRelatedTags: RelatedTagsXStoreModule['actions']['fetchRelatedTags'];

// @public
export const fetchSearchResponse: SearchXStoreModule['actions']['fetchSearchResponse'];

// @public
export const fetchSemanticQuery: SemanticQueriesXStoreModule['actions']['fetchSemanticQuery'];

// @public
export function filter<Payload>(wire: Wire<Payload>, filterFn: (parameters: WireParams<Payload>) => boolean): Wire<Payload>;

// @public
export function filterBlacklistedModules<Payload>(wire: Wire<Payload>, blacklist: Array<XModuleName | null>): Wire<Payload>;

// @internal
export interface FilterEntity<Metadata extends Dictionary = Dictionary<unknown>> {
    deselect: (filter: Filter, metadata?: Metadata) => void;
    select: (filter: Filter) => void;
}

// @internal
export interface FilterEntityConstructor {
    // (undocumented)
    new (store: Store<RootXStoreState>): FilterEntity;
    accepts: (filter: Filter) => boolean;
}

// @internal
export class FilterEntityFactory {
    // Warning: (ae-forgotten-export) The symbol "UNKNOWN_FACET_KEY" needs to be exported by the entry point index.d.ts
    protected cache: Record<Facet['id'] | typeof UNKNOWN_FACET_KEY, FilterEntity>;
    protected createFilterEntity(store: Store<RootXStoreState>, filter: Filter): FilterEntity;
    protected entities: FilterEntityConstructor[];
    getFilterEntity(store: Store<RootXStoreState>, filter: Filter): FilterEntity;
    static instance: FilterEntityFactory;
    protected modifiersByFacetId: Record<Facet['id'], FilterEntityModifier[]>;
    // Warning: (ae-forgotten-export) The symbol "FilterModelName" needs to be exported by the entry point index.d.ts
    protected modifiersByFilterModelName: Partial<Record<FilterModelName, FilterEntityModifier[]>>;
    registerFilterEntity(entity: FilterEntityConstructor): void;
    registerModifierByFacetId(facetId: Facet['id'], ...modifiers: FilterEntityModifier[]): void;
    registerModifierByFilterModelName(filterModelName: FilterModelName, ...modifiers: FilterEntityModifier[]): void;
    protected updateModifiers(modifiersRecord: Record<string, FilterEntityModifier[]>, modifierKey: string | number, modifiers: FilterEntityModifier[]): void;
}

// @internal
export interface FilterEntityModifier<Metadata extends Dictionary = Dictionary> {
    // (undocumented)
    new (store: Store<RootXStoreState>, entity: FilterEntity<Metadata>): FilterEntity<Metadata>;
}

// @public
export function filterFalsyPayload<Payload>(wire: Wire<Exclude<Payload, null | undefined | false | 0 | ''>>): Wire<Payload>;

// @public
export type FiltersByFacet = Record<Facet['id'], Filter[]>;

export { FiltersIcon }

// @public
export const FiltersList: DefineComponent<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, {
hasFiltersToRender: ComputedRef<boolean>;
cssClasses: ComputedRef<VueCSSClasses>;
renderedFilters: ComputedRef<Filter[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface FiltersMetadata {
    keepSticky?: boolean;
}

// @public
export const FiltersSearch: DefineComponent<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
debounceInMs: {
type: NumberConstructor;
default: number;
};
}>, {
clearQuery: () => void;
setQuery: (query: string) => void;
cssClasses: ComputedRef<VueCSSClasses>;
siftedFilters: ComputedRef<Filter[]>;
query: Ref<string, string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
debounceInMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
debounceInMs: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type filtersStrategyForRequest = 'all' | 'leaves-only';

// @public
export function filterTruthyPayload<Payload>(wire: Wire<Payload>): Wire<Payload>;

// @public
export function filterWhitelistedModules<Payload>(wire: Wire<Payload>, whitelist: Array<XModuleName | null>): Wire<Payload>;

// @public
export type FirstParameter<SomeFunction extends AnyFunction> = Parameters<SomeFunction>[0];

// @public
export function flatHierarchicalFilters(hierarchicalFilters: HierarchicalFilter_2[]): HierarchicalFilter_2[];

// @public
export function flattenAllFilters(facets: Facet[]): Filter[];

// @public
export const FOCUSABLE_SELECTORS = "a[href], button:not([disabled]), details, input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";

// @public
export function getActiveElement(root?: Document | ShadowRoot): Element | null;

// @public
export function getGetterPath<ModuleName extends XModuleName>(moduleName: ModuleName, getterName: keyof ExtractGetters<ModuleName>): string;

// @internal
export function getGettersProxy<ModuleName extends XModuleName>(getters: Dictionary, moduleName: ModuleName): ExtractGetters<ModuleName>;

// @internal
export function getGettersProxyFromModule<ModuleName extends XModuleName>(getters: Dictionary, moduleName: ModuleName, storeModule: AnyXStoreModule): ExtractGetters<ModuleName>;

// @public
export function getRootXComponent(component: ComponentPublicInstance | null): ComponentPublicInstance | undefined;

// @public
export function getStateAndGettersFromModule<ModuleName extends XModuleName>(state: RootXStoreState, getters: Dictionary, moduleName: ModuleName): StoreModuleStateAndGetters<ModuleName>;

// @public
export function getTargetElement(event: Event): Element;

// @public
export type GettersClass<Module extends AnyXStoreModule> = Partial<Module['getters']>;

// @public
export type GettersTree<State extends Dictionary, Getters extends Dictionary> = {
    [Key in keyof Getters]: (state: State, getters: Getters, rootState: RootXStoreState, rootGetters: any) => Getters[Key];
};

// @public
export const getURLParameter: (param: string) => string | null;

// @internal
export function getXComponentXModuleName(component: ComponentPublicInstance | undefined): XModuleName | null;

// @public
export const GlobalXBus: DefineComponent<ExtractPropTypes<    {
listeners: {
type: PropType<XEventListeners>;
required: true;
};
}>, () => string, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
listeners: {
type: PropType<XEventListeners>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { Grid1ColIcon }

export { Grid2ColIcon }

export { Grid2RowsIcon }

export { Grid4ColIcon }

// @public
export type GroupId = string;

// @public
export function groupItemsBy<ArrayType, ReturnType extends string | number>(array: ArrayType[], groupBy: (item: ArrayType, index: number) => ReturnType): Record<ReturnType, ArrayType[]>;

// @internal
export const HAS_MORE_ITEMS_KEY: XInjectKey<boolean | undefined>;

export { HeartIcon }

export { HeartIconFilled }

export { HideIcon }

// @public
export const HierarchicalFilter: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<HierarchicalFilter_2>;
required: true;
};
childrenAnimation: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
childrenFiltersClass: StringConstructor;
filterItemClass: StringConstructor;
}>, {
innerClickEvents: ComputedRef<    {
ColumnsNumberProvided?: number | undefined;
RenderedColumnsNumberChanged?: number | undefined;
SuggestionsDisplayed?: Suggestion[] | undefined;
TogglePanelStateChanged?: boolean | undefined;
UserAcceptedAQuery?: string | undefined;
UserAcceptedSpellcheckQuery?: string | undefined;
UserClickedAResult?: Result | undefined;
UserClickedADisplayResult?: Result | undefined;
UserClickedCloseEventsModal?: void | undefined;
UserClickedCloseModal?: string | undefined;
UserClickedCloseX?: void | undefined;
UserClickedOutOfMainModal?: void | undefined;
UserClickedColumnPicker?: number | undefined;
UserClickedOpenEventsModal?: void | undefined;
UserClickedOpenModal?: string | undefined;
UserClickedOpenX?: void | undefined;
UserClickedOutOfEventsModal?: void | undefined;
UserClickedOutOfModal?: string | undefined;
UserClickedPanelToggleButton?: string | undefined;
UserClickedResultAddToCart?: Result | undefined;
UserClickedAResultRating?: Result | undefined;
UserClickedScrollToTop?: string | undefined;
UserOpenXProgrammatically?: void | undefined;
UserPressedArrowKey?: ArrowKey | undefined;
UserReachedEmpathizeTop?: void | undefined;
UserSelectedAResultVariant?: {
result: Result;
variant: ResultVariant;
level: number;
queryPreviewHash: ComputedRef<string> | null;
} | undefined;
UserSelectedASuggestion?: Suggestion | undefined;
SnippetCallbackExecuted?: {
event: XEvent;
callbackReturn: unknown;
payload: ExtractPayload<XEvent>;
metadata: WireMetadata;
} | undefined;
ModuleRegistered?: keyof XModulesTree | undefined;
DeviceProvided?: string | null | undefined;
EmpathizeClosed?: void | undefined;
EmpathizeOpened?: void | undefined;
UserClosedEmpathize?: void | undefined;
UserChangedExtraParams?: Dictionary<unknown> | undefined;
ExtraParamsChanged?: Dictionary<unknown> | undefined;
ExtraParamsProvided?: Dictionary<unknown> | undefined;
ExtraParamsInitialized?: Dictionary<unknown> | undefined;
FacetsGroupChanged?: FacetsGroup | undefined;
FacetsGroupProvided?: FacetsGroup | undefined;
PreselectedFiltersProvided?: RawFilter[] | undefined;
SelectedFiltersChanged?: Filter[] | undefined;
SelectedFiltersForRequestChanged?: Filter[] | undefined;
UserChangedSelectedFilters?: Filter[] | undefined;
UserClickedAFilter?: Filter | undefined;
UserClickedAHierarchicalFilter: HierarchicalFilter_2;
UserClickedANumberRangeFilter?: NumberRangeFilter_2 | undefined;
UserClickedASimpleFilter?: SimpleFilter_2 | undefined;
UserClickedAllFilter?: [string | number] | undefined;
UserModifiedEditableNumberRangeFilter?: EditableNumberRangeFilter_2 | undefined;
UserClickedClearAllFilters?: Array<Facet["id"]> | undefined;
FacetsQueryChanged?: string | undefined;
HistoryQueriesDisplayed?: HistoryQuery_2[] | undefined;
HistoryQueriesQueryChanged?: string | undefined;
HistoryQueriesStorageKeyChanged?: string | undefined;
SessionHistoryQueriesChanged?: HistoryQuery_2[] | undefined;
UserPressedClearHistoryQueries?: void | undefined;
UserPressedRemoveHistoryQuery?: HistoryQuery_2 | undefined;
UserSelectedAHistoryQuery?: HistoryQuery_2 | undefined;
UserClickedEnableHistoryQueries?: void | undefined;
UserClickedDisableHistoryQueries?: void | undefined;
UserClickedConfirmDisableHistoryQueries?: void | undefined;
UserClickedDismissDisableHistoryQueries?: void | undefined;
IdentifierResultsChanged?: Result[] | undefined;
IdentifierResultsRequestUpdated?: IdentifierResultsRequest | null | undefined;
UserClickedAIdentifierResult?: Result | undefined;
NextQueriesChanged?: NextQuery_2[] | undefined;
NextQueriesDisplayed?: NextQuery_2[] | undefined;
NextQueriesRequestUpdated?: NextQueriesRequest | null | undefined;
UserSelectedANextQuery?: NextQuery_2 | undefined;
NextQueryPreviewMountedHook?: string | undefined;
PopularSearchesRequestUpdated?: PopularSearchesRequest | undefined;
PopularSearchDisplayed?: Suggestion[] | undefined;
UserSelectedAPopularSearch?: Suggestion | undefined;
QueryPreviewRequestUpdated?: SearchRequest | undefined;
UserAcceptedAQueryPreview?: QueryPreviewInfo | undefined;
QueryPreviewUnselected?: Dictionary<unknown> | undefined;
QueryPreviewMounted?: string | undefined;
QueryPreviewUnmounted?: {
queryPreviewHash: string;
cache: boolean;
} | undefined;
QueriesPreviewChanged?: Dictionary<QueryPreviewItem> | undefined;
QueryPreviewResultReceived?: QueryPreviewItem | undefined;
QuerySuggestionsChanged?: Suggestion[] | undefined;
QuerySuggestionsRequestUpdated?: QuerySuggestionsRequest | null | undefined;
UserSelectedAQuerySuggestion?: Suggestion | undefined;
RecommendationsChanged?: Result[] | undefined;
RecommendationsRequestUpdated?: RecommendationsRequest | undefined;
UserClickedARecommendation?: Result | undefined;
RelatedTagsChanged?: RelatedTag_2[] | undefined;
RelatedTagsRequestUpdated?: RelatedTagsRequest | null | undefined;
SelectedRelatedTagsChanged?: RelatedTag_2[] | undefined;
UserDeselectedARelatedTag?: RelatedTag_2 | undefined;
UserPickedARelatedTag?: RelatedTag_2 | undefined;
UserSelectedARelatedTag?: RelatedTag_2 | undefined;
ScrollRestoreSucceeded?: void | undefined;
ScrollRestoreFailed?: void | undefined;
UserAlmostReachedScrollEnd?: boolean | undefined;
UserChangedScrollDirection?: ScrollDirection | undefined;
UserReachedScrollEnd?: boolean | undefined;
UserReachedScrollStart?: boolean | undefined;
UserScrolled?: number | undefined;
UserScrolledToElement?: string | undefined;
SearchBoxQueryChanged?: string | undefined;
UserHoveredInSearchBox?: void | undefined;
UserHoveredOutSearchBox?: void | undefined;
UserBlurredSearchBox?: void | undefined;
UserClearedQuery?: string | undefined;
UserClickedSearchBox?: void | undefined;
UserFocusedSearchBox?: void | undefined;
UserIsTypingAQuery?: string | undefined;
UserPressedClearSearchBoxButton?: void | undefined;
UserPressedEnterKey?: string | undefined;
UserPressedSearchButton?: string | undefined;
UserTalked?: string | undefined;
FacetsChanged?: Facet[] | undefined;
PageChanged?: number | undefined;
PartialResultsChanged?: PartialResult[] | undefined;
ReloadSearchRequested?: void | undefined;
ResultsChanged?: Result[] | undefined;
SearchRequestChanged?: InternalSearchRequest | null | undefined;
SearchRequestUpdated?: InternalSearchRequest | null | undefined;
SearchResponseChanged?: InternalSearchResponse | undefined;
SearchTaggingChanged?: TaggingRequest | undefined;
SortChanged?: string | undefined;
SpellcheckChanged?: string | undefined;
UserClickedASort?: string | undefined;
SelectedSortProvided?: string | undefined;
UserClickedPartialQuery?: string | undefined;
UserReachedResultsListEnd?: void | undefined;
UserClickedARedirection?: Redirection_2 | undefined;
UserClickedAPromoted?: Promoted_2 | undefined;
UserClickedABanner?: Banner_2 | undefined;
UserClickedAbortARedirection?: void | undefined;
UserSelectedAPage?: number | undefined;
SemanticQueryRequestUpdated?: SemanticQueriesRequest | null | undefined;
SemanticQueriesResponseChanged?: SemanticQuery_2[] | undefined;
UserSelectedASemanticQuery?: SemanticQuery_2 | undefined;
ConsentChanged?: boolean | undefined;
ConsentProvided?: boolean | undefined;
PDPIsLoaded?: string | undefined;
ResultURLTrackingEnabled?: string | undefined;
SearchTaggingReceived?: TaggingRequest | undefined;
TrackableElementDisplayed?: Taggable | undefined;
UserClickedPDPAddToCart?: string | undefined;
TaggingConfigProvided?: TaggingConfig | undefined;
ExperienceControlsEventsChanged?: Partial<XEventsTypes> | undefined;
ExperienceControlsRequestUpdated?: ExperienceControlsRequest | null | undefined;
ParamsLoadedFromUrl?: UrlParams | undefined;
ExtraParamsLoadedFromUrl?: Dictionary<unknown> | undefined;
PushableUrlStateUpdated?: UrlParams | undefined;
ReplaceableUrlStateUpdated?: UrlParams | undefined;
RelatedPromptsRequestUpdated?: RelatedPromptsRequest | null | undefined;
SelectedRelatedPromptChanged?: number | undefined;
UserSelectedARelatedPrompt?: number | undefined;
UserSelectedARelatedPromptQuery?: number | undefined;
UserClickedARelatedPromptResult?: Result | undefined;
UserClickedARelatedPromptAdd2Cart?: Result | undefined;
RelatedPromptsResponseChanged?: RelatedPrompt_2[] | undefined;
RelatedPromptsUnmounted?: void | undefined;
ReloadRelatedPromptsRequested?: void | undefined;
AiSuggestionsRequestUpdated?: AiSuggestionsRequest | null | undefined;
AiSuggestionsSearchRequestUpdated?: AiSuggestionsSearchRequest | null | undefined;
AiSuggestionsSearchChanged?: AiSuggestionSearch[] | undefined;
UserClickedAiOverviewExpandButton?: boolean | undefined;
UserClickedAnAiOverviewResult?: Result | undefined;
AiComponentMounted?: void | undefined;
}>;
innerCssClasses: ComputedRef<(string | Dictionary<boolean>)[]>;
renderedChildrenFilters: ComputedRef<HierarchicalFilter_2[]>;
getChildFilterClickEvents: (childFilter: HierarchicalFilter_2) => Partial<XEventsTypes>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<HierarchicalFilter_2>;
required: true;
};
childrenAnimation: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
childrenFiltersClass: StringConstructor;
filterItemClass: StringConstructor;
}>> & Readonly<{}>, {
cssClasses: (string | Dictionary<boolean>)[];
}, {}, {
FiltersList: DefineComponent<    {}, {}, any>;
RenderlessFilter: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export class HierarchicalFilterEntity implements FilterEntity {
    constructor(store: Store<RootXStoreState>);
    // Warning: (ae-forgotten-export) The symbol "isHierarchicalFilter" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static accepts: typeof isHierarchicalFilter;
    deselect(filterParam: Filter): void;
    protected deselectDescendants(filter: HierarchicalFilter_2): void;
    protected getFilterById(id: HierarchicalFilter_2['id']): HierarchicalFilter_2;
    protected saveFilter(filter: HierarchicalFilter_2, newFilterState?: Partial<HierarchicalFilter_2>): void;
    select(filterParam: Filter): void;
    protected selectAncestors(filter: HierarchicalFilter_2): void;
    // (undocumented)
    protected store: Store<RootXStoreState>;
}

// @public
const Highlight_2: DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: string;
};
highlight: {
type: StringConstructor;
default: string;
};
matchClass: {
type: StringConstructor;
default: string;
};
noMatchClass: {
type: StringConstructor;
default: string;
};
matchingPartClass: {
type: StringConstructor;
default: string;
};
}>, {
hasMatch: ComputedRef<boolean>;
matchParts: ComputedRef<    {
start: string;
match: string;
end: string;
}>;
dynamicCSSClasses: ComputedRef<    {
[x: string]: boolean;
'x-highlight--has-match': boolean;
'xds:highlight-text': boolean;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: string;
};
highlight: {
type: StringConstructor;
default: string;
};
matchClass: {
type: StringConstructor;
default: string;
};
noMatchClass: {
type: StringConstructor;
default: string;
};
matchingPartClass: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
text: string;
highlight: string;
matchClass: string;
noMatchClass: string;
matchingPartClass: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Highlight_2 as Highlight }

export { HistoryIcon }

// @public
export const HistoryQueries: DefineComponent<    {}, {
historyQueriesWithResults: ComputedRef<HistoryQuery_2[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseSuggestions: DefineComponent<    {}, {}, any>;
HistoryQuery: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const historyQueries: (input: HistoryQueriesState) => HistoryQuery_2[];

// @public
export type HistoryQueriesActionContext = XActionContext<HistoryQueriesState, HistoryQueriesGetters, HistoryQueriesMutations, HistoryQueriesActions>;

// @public
export interface HistoryQueriesActions {
    addQueryToHistory: (query: string) => void;
    loadHistoryQueriesFromBrowserStorage: () => void;
    refreshSession: () => void;
    removeFromHistory: (historyQuery: HistoryQuery_2) => void;
    setHistoryQueries: (historyQueries: HistoryQuery_2[]) => void;
    setUrlParams: (urlParams: UrlParams) => void;
    toggleHistoryQueries: (isEnabled: boolean) => void;
    updateHistoryQueriesWithSearchResponse: (searchResponse: InternalSearchResponse) => void;
}

// @public
export interface HistoryQueriesConfig {
    debounceInMs: number;
    hideIfEqualsQuery: boolean;
    maxItemsToStore: number;
    sessionTTLInMs: number;
}

// @internal
export const historyQueriesEmitters: {
    SessionHistoryQueriesChanged: (_state: HistoryQueriesState, getters: Returns<GettersTree<HistoryQueriesState, HistoryQueriesGetters>>) => HistoryQuery_2[];
    HistoryQueriesQueryChanged: {
        immediate: true;
        selector: (state: HistoryQueriesState) => string;
    };
    HistoryQueriesStorageKeyChanged: {
        immediate: true;
        selector: (_state: HistoryQueriesState, getters: Returns<GettersTree<HistoryQueriesState, HistoryQueriesGetters>>) => string;
    };
};

// @public
export class HistoryQueriesGetter implements GettersClass<HistoryQueriesXStoreModule> {
    historyQueries(input: HistoryQueriesState): HistoryQuery_2[];
    // @internal
    protected searchInHistoryQueries(normalizedQuery: string, hideIfEqualsQuery: boolean): (historyQuery: HistoryQuery_2) => boolean;
}

// @public
export interface HistoryQueriesGetters {
    historyQueries: HistoryQuery_2[];
    historyQueriesWithResults: HistoryQuery_2[];
    normalizedQuery: string;
    sessionHistoryQueries: HistoryQuery_2[];
    storageKey: string;
}

// @public
export interface HistoryQueriesMutations extends QueryMutations, ConfigMutations<HistoryQueriesState> {
    setHistoryQueries: (historyQueries: HistoryQuery_2[]) => void;
    setIsEnabled: (isEnabled: boolean) => void;
    setSearchSelectedFilters: (filters: Filter[]) => void;
    setSessionTimeStamp: (timeStamp: number) => void;
}

// @public
export interface HistoryQueriesState extends QueryState {
    config: HistoryQueriesConfig;
    historyQueries: HistoryQuery_2[];
    isEnabled: boolean;
    sessionTimeStampInMs: number;
}

// @public
export const HistoryQueriesSwitch: DefineComponent<    {}, {
toggle: () => void;
isEnabled: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseSwitch: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export const historyQueriesWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
    };
    HistoryQueriesQueryChanged: {
        refreshHistoryQueriesSession: AnyWire;
    };
    HistoryQueriesStorageKeyChanged: {
        loadHistoryQueriesFromBrowserStorageWire: AnyWire;
    };
    UserClearedQuery: {
        clearHistoryQueriesQuery: AnyWire;
    };
    UserAcceptedAQuery: {
        setHistoryQueriesQuery: Wire<string>;
        addQueryToHistoryQueries: Wire<string>;
    };
    UserSelectedAHistoryQuery: {
        setSearchSelectedFilters: AnyWire;
    };
    UserIsTypingAQuery: {
        setHistoryQueriesQueryDebounce: Wire<string>;
    };
    UserPressedClearHistoryQueries: {
        clearHistoryQueries: AnyWire;
    };
    UserPressedRemoveHistoryQuery: {
        removeHistoryQuery: Wire<HistoryQuery_2>;
    };
    UserClickedEnableHistoryQueries: {
        setHistoryQueriesEnabled: AnyWire;
    };
    UserClickedConfirmDisableHistoryQueries: {
        setHistoryQueriesDisabled: AnyWire;
    };
    UserClickedCloseX: {
        clearHistoryQueriesQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearHistoryQueriesQuery: AnyWire;
    };
    SearchResponseChanged: {
        updateHistoryQueriesWithSearchResponse: Wire<InternalSearchResponse>;
    };
    UserAcceptedAQueryPreview: {
        setHistoryQueriesQueryFromPreview: AnyWire;
        addQueryToHistoryQueriesFromPreview: AnyWire;
    };
};

// @public
export interface HistoryQueriesXEvents {
    HistoryQueriesDisplayed: HistoryQuery_2[];
    HistoryQueriesQueryChanged: string;
    HistoryQueriesStorageKeyChanged: string;
    SessionHistoryQueriesChanged: HistoryQuery_2[];
    UserClickedConfirmDisableHistoryQueries: void;
    UserClickedDisableHistoryQueries: void;
    UserClickedDismissDisableHistoryQueries: void;
    UserClickedEnableHistoryQueries: void;
    UserPressedClearHistoryQueries: void;
    UserPressedRemoveHistoryQuery: HistoryQuery_2;
    UserSelectedAHistoryQuery: HistoryQuery_2;
}

// @public
export type HistoryQueriesXModule = XModule<HistoryQueriesXStoreModule>;

// @public
export const historyQueriesXModule: HistoryQueriesXModule;

// @public
export type HistoryQueriesXStoreModule = XStoreModule<HistoryQueriesState, HistoryQueriesGetters, HistoryQueriesMutations, HistoryQueriesActions>;

// @internal
export const historyQueriesXStoreModule: HistoryQueriesXStoreModule;

// @public
export const HistoryQuery: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<HistoryQuery_2>;
required: true;
};
removeButtonClass: StringConstructor;
suggestionClass: StringConstructor;
}>, {
query: ComputedRef<string>;
suggestionSelectedEvents: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<HistoryQuery_2>;
required: true;
};
removeButtonClass: StringConstructor;
suggestionClass: StringConstructor;
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
RemoveHistoryQuery: DefineComponent<    {}, {}, any>;
BaseSuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export { HistoryTinyIcon }

// @public
export const identifierDetectionRegexp: IdentifierResultsXStoreModule['getters']['identifierDetectionRegexp'];

// @public
export const identifierHighlightRegexp: IdentifierResultsXStoreModule['getters']['identifierHighlightRegexp'];

// @public
export const IdentifierResult: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>, {
query: ComputedRef<string>;
highlightedQueryHTML: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const IdentifierResults: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
}>, {
identifierResults: ComputedRef<Result[]>;
identifierResultsToRender: ComputedRef<Result[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface IdentifierResultsActions {
    cancelFetchAndSaveIdentifierResults: () => void;
    fetchAndSaveIdentifierResults: (request: IdentifierResultsRequest | null) => void;
    fetchIdentifierResults: (request: IdentifierResultsRequest | null) => Result[];
    saveOrigin: (originInit: QueryOriginInit) => void;
    saveQuery: (query: string) => void;
}

// @public
export type IdentifierResultsActionsContext = XActionContext<IdentifierResultsState, IdentifierResultsGetters, IdentifierResultsMutations, IdentifierResultsActions>;

// @public
export interface IdentifierResultsConfig {
    debounceInMs: number;
    identifierDetectionRegexp: string;
    maxItemsToRequest: number;
    separatorChars: string;
}

// @internal
export const identifierResultsEmitters: {
    IdentifierResultsChanged: {
        selector: (state: IdentifierResultsState) => Result[];
        filter: (newCollection: Result[], oldCollection: Result[]) => boolean;
    };
    IdentifierResultsRequestUpdated: (_: IdentifierResultsState, getters: Returns<GettersTree<IdentifierResultsState, IdentifierResultsGetters>>) => IdentifierResultsRequest | null;
};

// @public
export interface IdentifierResultsGetters {
    identifierDetectionRegexp: RegExp;
    identifierHighlightRegexp: RegExp;
    identifierResultsRequest: IdentifierResultsRequest | null;
}

// @public
export interface IdentifierResultsMutations extends StatusMutations, QueryMutations, ConfigMutations<IdentifierResultsState> {
    setIdentifierResults: (identifierResults: Result[]) => void;
    setOrigin: (origin: QueryOrigin | undefined | null) => void;
    setParams: (params: Dictionary<unknown>) => void;
}

// @public
export const identifierResultsRequest: IdentifierResultsXStoreModule['getters']['identifierResultsRequest'];

// @public
export interface IdentifierResultsState extends StatusState, QueryState {
    config: IdentifierResultsConfig;
    identifierResults: Result[];
    origin: QueryOrigin | null;
    params: Dictionary<unknown>;
}

// @internal
export const identifierResultsWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: AnyWire;
        saveIdentifierResultsOriginWire: AnyWire;
    };
    UserIsTypingAQuery: {
        setIdentifierResultsQueryDebounce: Wire<string>;
    };
    UserAcceptedAQuery: {
        setIdentifierResultsQuery: Wire<string>;
        saveIdentifierResultsOriginWire: AnyWire;
    };
    UserClearedQuery: {
        clearIdentifierResultsQuery: AnyWire;
        cancelFetchAndSaveIdentifierResultsWire: AnyWire;
    };
    IdentifierResultsRequestUpdated: {
        fetchAndSaveIdentifierResultsWire: Wire<IdentifierResultsRequest | null>;
    };
    ExtraParamsChanged: {
        setIdentifierResultsExtraParams: Wire<Dictionary<unknown>>;
    };
    UserClickedCloseX: {
        clearIdentifierResultsQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearIdentifierResultsQuery: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setIdentifierResultsQueryFromPreview: AnyWire;
        saveIdentifierResultsOriginWire: AnyWire;
    };
};

// @public
export interface IdentifierResultsXEvents {
    IdentifierResultsChanged: Result[];
    IdentifierResultsRequestUpdated: IdentifierResultsRequest | null;
    UserClickedAIdentifierResult: Result;
}

// @public
export type IdentifierResultsXModule = XModule<IdentifierResultsXStoreModule>;

// @public
export const identifierResultsXModule: IdentifierResultsXModule;

// @public
export type IdentifierResultsXStoreModule = XStoreModule<IdentifierResultsState, IdentifierResultsGetters, IdentifierResultsMutations, IdentifierResultsActions>;

// @internal
export const identifierResultsXStoreModule: IdentifierResultsXStoreModule;

// @public
export const increasePageAppendingResults: SearchXStoreModule['actions']['increasePageAppendingResults'];

// @public
export const increasePageAppendingResultsWire: AnyWire;

// @public
export const infiniteScroll: Directive<HTMLElement, {
    margin: number;
}>;

// @public
export interface InitWrapper {
    api?: XAPI;
    app?: App;
    bus: XBus<XEventsTypes, WireMetadata>;
    plugin: Plugin_2<XPluginOptions>;
}

// @internal
export type InputStatus = 'initial' | 'typing' | 'filled' | 'focused' | 'empty';

// @public
export interface InstallXOptions<API extends XAPI = XAPI> extends XPluginOptions {
    api?: API | false;
    bus?: XBus<XEventsTypes, WireMetadata>;
    domElement?: Element | ShadowRoot | string | ((snippetConfig: NormalisedSnippetConfig) => Element | ShadowRoot | string);
    installExtraPlugins?: (options: ExtraPluginsOptions) => void | Promise<void>;
    onCreateApp?: (app: App) => void;
    plugin?: Plugin_2<XPluginOptions>;
    rootComponent?: Component;
}

// @public
export interface InternalSearchRequest extends SearchRequest {
    page: number;
}

// Warning: (ae-forgotten-export) The symbol "SearchResponse" needs to be exported by the entry point index.d.ts
//
// @public
export interface InternalSearchResponse extends SearchResponse {
    request: InternalSearchRequest;
    status: RequestStatus;
}

// @internal
export interface Intersection {
    // (undocumented)
    area: number;
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public
export function isArrayEmpty(array: unknown[] | undefined | null): array is undefined | null | [];

// @public
export function isElementEqualOrContained(a: Element, b: Element): boolean;

// @public
export function isInRange(number: number, input: [number, number]): boolean;

// @public
export const isIOS: () => boolean;

// @public
export function isNewQuery(newQuery: string, previousQuery: string): boolean;

// @internal
export function isSimpleSelector(stateSelector: AnySimpleStateSelector | AnyStateSelector): stateSelector is AnySimpleStateSelector;

// @public
export function isStringEmpty(str?: string | null): boolean;

// @public
export function isXComponent(component: ComponentPublicInstance): boolean;

// @public
export const ItemsList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
items: {
type: PropType<ListItem[]>;
required: true;
};
itemClass: StringConstructor;
}>, {
computedItems: ComputedRef<    {
dataTest: string;
class: (string | undefined)[];
slotName: string;
id: string | number;
modelName: string;
}[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
items: {
type: PropType<ListItem[]>;
required: true;
};
itemClass: StringConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { LightBulbOff }

export { LightBulbOn }

// @internal
export const LIST_ITEMS_KEY: XInjectKey<ListItem[] | undefined>;

// Warning: (ae-forgotten-export) The symbol "Identifiable" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "NamedModel" needs to be exported by the entry point index.d.ts
//
// @public
export type ListItem = Identifiable & NamedModel;

// @public
export const loadHistoryQueriesFromBrowserStorage: HistoryQueriesXStoreModule['actions']['loadHistoryQueriesFromBrowserStorage'];

// @public
export const loadHistoryQueriesFromBrowserStorageWire: AnyWire;

// @internal
export const localStorageService: StorageService;

// @public
export const LocationProvider: DefineComponent<ExtractPropTypes<    {
location: {
type: PropType<FeatureLocation>;
required: true;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
location: {
type: PropType<FeatureLocation>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export interface Machine<SomeStatus extends string, SomeEvent extends string> {
    // (undocumented)
    initial: SomeStatus;
    // (undocumented)
    states: TransitionStates<SomeStatus, SomeEvent>;
}

// @public
export const MainModal: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
};
closeEvents: {
type: PropType<XEvent[]>;
default: () => string[];
};
focusOnOpen: {
type: BooleanConstructor;
default: boolean;
};
openEvents: {
type: PropType<XEvent[]>;
default: () => string[];
};
outOfModalClickEvent: {
type: PropType<keyof XEventsTypes>;
default: string;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
};
closeEvents: {
type: PropType<XEvent[]>;
default: () => string[];
};
focusOnOpen: {
type: BooleanConstructor;
default: boolean;
};
openEvents: {
type: PropType<XEvent[]>;
default: () => string[];
};
outOfModalClickEvent: {
type: PropType<keyof XEventsTypes>;
default: string;
};
}>> & Readonly<{}>, {
closeEvents: (keyof XEventsTypes)[];
focusOnOpen: boolean;
openEvents: (keyof XEventsTypes)[];
outOfModalClickEvent: keyof XEventsTypes;
}, {}, {
BaseEventsModal: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const MainScroll: DefineComponent<ExtractPropTypes<    {
useWindow: {
type: BooleanConstructor;
default: boolean;
};
restoreScrollTimeoutMs: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
margin: {
type: StringConstructor;
default: string;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
useWindow: {
type: BooleanConstructor;
default: boolean;
};
restoreScrollTimeoutMs: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
margin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
useWindow: boolean;
restoreScrollTimeoutMs: number;
threshold: number;
margin: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export const MainScrollId = "main-scroll";

// @public
export const MainScrollItem: DefineComponent<ExtractPropTypes<    {
item: {
type: PropType<Identifiable>;
required: true;
};
tag: {
type: PropType<string | Component>;
default: string;
};
}>, {
rootRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
item: {
type: PropType<Identifiable>;
required: true;
};
tag: {
type: PropType<string | Component>;
default: string;
};
}>> & Readonly<{}>, {
tag: string | Component;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export function mapWire<FromPayload, ToPayload>(toWire: Wire<ToPayload>, mapFn: (payload: FromPayload) => ToPayload): Wire<FromPayload>;

// @public
export type MaybeArray<Something> = Something | Array<Something>;

export { MenuIcon }

// @public
export function mergeConfig<T extends {
    config: T['config'];
}>(state: T, config: Partial<T['config']>): void;

// @public
export const Message: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
}>, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { MinusIcon }

export { MinusTinyIcon }

// @public
export type MonadicFunction = (someParam: any) => any;

// @public
export interface MutateFilterPayload {
    filter: Filter;
    newFilterState: Partial<Filter>;
}

// @public
export type MutationNamesFor<ModuleName extends XModuleName> = keyof ExtractMutations<XModulesTree[ModuleName]>;

// @public
export type MutationsDictionary<Mutations> = Record<keyof Mutations, (payload?: any) => void>;

// @public
export type MutationsTree<State extends Dictionary, Mutations extends MutationsDictionary<Mutations>> = {
    [Key in keyof Mutations]: (state: State, payload: ExtractPayload<Mutations[Key]>) => void;
};

// @public
export const MyHistory: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
queriesListClass: StringConstructor;
}>, {
hasHistoryQueries: ComputedRef<boolean>;
groupByDate: ComputedRef<Dictionary<HistoryQuery_2[]>>;
historyQueries: ComputedRef<HistoryQuery_2[]>;
formatTime: (timestamp: number) => string;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
queriesListClass: StringConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
locale: string;
}, {}, {
HistoryQuery: DefineComponent<    {}, {}, any>;
BaseSuggestions: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export function namespacedDebounce<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedTimeWireOperator<ModuleName>;

// @public
export function namespacedThrottle<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedTimeWireOperator<ModuleName>;

// @public
export type NamespacedTimeSelector<ModuleName extends XModuleName> = (storeModule: StoreModuleStateAndGetters<ModuleName>) => number;

// @public
export type NamespacedTimeWireOperator<ModuleName extends XModuleName> = <Payload>(wire: Wire<Payload>, timeInMs: NamespacedTimeSelector<ModuleName>, options?: TimedWireOperatorOptions) => Wire<Payload>;

// @public
export interface NamespacedWireCommit<ModuleName extends XModuleName> {
    // (undocumented)
    <MutationName extends MutationNamesFor<ModuleName>>(mutation: MutationName): Wire<ExtractMutationPayload<ModuleName, MutationName>>;
    // (undocumented)
    <MutationName extends MutationNamesFor<ModuleName>>(mutation: MutationName, payload: NamespacedWireCommitPayload<ModuleName, MutationName>): AnyWire;
}

// @public
export function namespacedWireCommit<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedWireCommit<ModuleName>;

// @public
export type NamespacedWireCommitPayload<ModuleName extends XModuleName, MutationName extends MutationNamesFor<ModuleName>> = ExtractMutationPayload<ModuleName, MutationName> | ((wiringData: NamespacedWiringData<ModuleName>) => ExtractMutationPayload<ModuleName, MutationName>);

// @public
export type NamespacedWireCommitWithoutPayload<ModuleName extends XModuleName> = <MutationName extends PropsWithType<ExtractMutations<XModulesTree[ModuleName]>, () => any>>(mutation: MutationName) => AnyWire;

// @public
export function namespacedWireCommitWithoutPayload<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedWireCommitWithoutPayload<ModuleName>;

// @public
export interface NamespacedWireDispatch<ModuleName extends XModuleName> {
    // (undocumented)
    <ActionName extends ActionNamesFor<ModuleName>>(action: ActionName): Wire<ExtractActionPayload<ModuleName, ActionName>>;
    // (undocumented)
    <ActionName extends ActionNamesFor<ModuleName>>(action: ActionName, payload: NamespacedWireDispatchPayload<ModuleName, ActionName>): AnyWire;
}

// @public
export function namespacedWireDispatch<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedWireDispatch<ModuleName>;

// @public
export type NamespacedWireDispatchPayload<ModuleName extends XModuleName, ActionName extends ActionNamesFor<ModuleName>> = ExtractActionPayload<ModuleName, ActionName> | ((wiringData: NamespacedWiringData<ModuleName>) => ExtractActionPayload<ModuleName, ActionName>);

// @public
export type NamespacedWireDispatchWithoutPayload<ModuleName extends XModuleName> = <ActionName extends PropsWithType<ExtractActions<XModulesTree[ModuleName]>, () => any>>(action: ActionName) => AnyWire;

// @public
export function namespacedWireDispatchWithoutPayload<ModuleName extends XModuleName>(moduleName: ModuleName): NamespacedWireDispatchWithoutPayload<ModuleName>;

// @public
export type NamespacedWiringData<ModuleName extends XModuleName> = StoreModuleStateAndGetters<ModuleName> & {
    eventPayload: ExtractPayload<ModuleName>;
    metadata: WireMetadata;
};

// @public
export const NextQueries: DefineComponent<ExtractPropTypes<    {
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
suggestions: PropType<NextQuery_2[]>;
}>, {
renderedNextQueries: ComputedRef<NextQuery_2[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
suggestions: PropType<NextQuery_2[]>;
}>> & Readonly<{}>, {
highlightCurated: boolean;
}, {}, {
NextQuery: DefineComponent<    {}, {}, any>;
BaseSuggestions: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const nextQueries: NextQueriesXStoreModule['getters']['nextQueries'];

// @public
export type NextQueriesActionContext = XActionContext<NextQueriesState, NextQueriesGetters, NextQueriesMutations, NextQueriesActions>;

// @public
export interface NextQueriesActions {
    cancelFetchAndSaveNextQueries: () => void;
    fetchAndSaveNextQueries: (request: NextQueriesRequest | null) => void;
    fetchAndSaveNextQueryPreview: (payload: {
        query: string;
        location: FeatureLocation | undefined;
    }) => void;
    fetchNextQueries: (request: NextQueriesRequest | null) => NextQuery_2[] | null;
    fetchNextQueryPreview: (payload: {
        query: string;
        location: FeatureLocation | undefined;
    }) => SearchResponse | null;
    setQueryFromLastHistoryQuery: (historyQueries: HistoryQuery_2[]) => void;
    setUrlParams: (urlParams: UrlParams) => void;
}

// @public
export interface NextQueriesConfig {
    hideSessionQueries: boolean;
    loadOnInit: boolean;
    maxItemsToRequest: number;
    maxPreviewItemsToRequest: number;
}

// @internal
export const nextQueriesEmitters: {
    NextQueriesChanged: {
        selector: (_: NextQueriesState, getters: Returns<GettersTree<NextQueriesState, NextQueriesGetters>>) => NextQuery_2[];
        filter: (newCollection: NextQuery_2[], oldCollection: NextQuery_2[]) => boolean;
    };
    NextQueriesRequestUpdated: (_: NextQueriesState, getters: Returns<GettersTree<NextQueriesState, NextQueriesGetters>>) => NextQueriesRequest | null;
};

// @public
export interface NextQueriesGetters {
    nextQueries: NextQuery_2[];
    query: string;
    request: NextQueriesRequest | null;
}

// @public
export interface NextQueriesGroup extends ListItem {
    // (undocumented)
    modelName: 'NextQueriesGroup';
    // (undocumented)
    nextQueries: NextQuery_2[];
}

// @public
export const NextQueriesList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
offset: {
type: NumberConstructor;
default: number;
};
frequency: {
type: NumberConstructor;
default: number;
};
maxNextQueriesPerGroup: {
type: NumberConstructor;
default: number;
};
maxGroups: NumberConstructor;
showOnlyAfterOffset: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
offset: {
type: NumberConstructor;
default: number;
};
frequency: {
type: NumberConstructor;
default: number;
};
maxNextQueriesPerGroup: {
type: NumberConstructor;
default: number;
};
maxGroups: NumberConstructor;
showOnlyAfterOffset: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
offset: number;
frequency: number;
maxNextQueriesPerGroup: number;
showOnlyAfterOffset: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface NextQueriesMutations extends StatusMutations, QueryMutations, ConfigMutations<NextQueriesState> {
    resetResultsPreview: () => void;
    setNextQueries: (nextQueries: NextQuery_2[]) => void;
    setParams: (params: Dictionary<unknown>) => void;
    setRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    // Warning: (ae-forgotten-export) The symbol "PreviewResults" needs to be exported by the entry point index.d.ts
    setResultsPreview: (resultsPreview: Dictionary<PreviewResults>) => void;
    setSearchedQueries: (searchedQueries: HistoryQuery_2[]) => void;
}

// @public
export const nextQueriesRequest: NextQueriesXStoreModule['getters']['request'];

// @public
export interface NextQueriesState extends StatusState, QueryState {
    config: NextQueriesConfig;
    nextQueries: NextQuery_2[];
    params: Dictionary<unknown>;
    relatedTags: RelatedTag_2[];
    resultsPreview: Dictionary<PreviewResults>;
    searchedQueries: HistoryQuery_2[];
}

// @internal
export const nextQueriesWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
    };
    NextQueriesChanged: {
        resetResultsPreviewWire: AnyWire;
    };
    UserAcceptedAQuery: {
        setNextQueriesQuery: Wire<string>;
    };
    SelectedRelatedTagsChanged: {
        setNextQueriesRelatedTags: Wire<RelatedTag_2[]>;
    };
    SessionHistoryQueriesChanged: {
        setSearchedQueries: Wire<HistoryQuery_2[]>;
        setQueryFromLastHistoryQueryWire: Wire<HistoryQuery_2[]>;
    };
    NextQueriesRequestUpdated: {
        fetchAndSaveNextQueriesWire: Wire<NextQueriesRequest | null>;
    };
    ExtraParamsChanged: {
        setNextQueriesExtraParams: Wire<Dictionary<unknown>>;
    };
    NextQueryPreviewMountedHook: {
        fetchAndSaveNextQueryPreviewWire: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setNextQueriesQueryFromPreview: AnyWire;
        setNextQueriesExtraParamsFromPreview: AnyWire;
    };
};

// @public
export interface NextQueriesXEvents {
    NextQueriesChanged: NextQuery_2[];
    NextQueriesDisplayed: NextQuery_2[];
    NextQueriesRequestUpdated: NextQueriesRequest | null;
    NextQueryPreviewMountedHook: string;
    UserSelectedANextQuery: NextQuery_2;
}

// @public
export type NextQueriesXModule = XModule<NextQueriesXStoreModule>;

// @public
export const nextQueriesXModule: NextQueriesXModule;

// @public
export type NextQueriesXStoreModule = XStoreModule<NextQueriesState, NextQueriesGetters, NextQueriesMutations, NextQueriesActions>;

// @internal
export const nextQueriesXStoreModule: NextQueriesXStoreModule;

// @public
export const NextQuery: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<NextQuery_2>;
required: true;
};
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
shouldHighlightCurated: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<NextQuery_2>;
required: true;
};
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
highlightCurated: boolean;
}, {}, {
BaseSuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const NextQueryPreview: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<NextQuery_2>;
required: true;
};
maxItemsToRender: NumberConstructor;
}>, {
suggestionResults: ComputedRef<PreviewResults | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<NextQuery_2>;
required: true;
};
maxItemsToRender: NumberConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type NiladicFunction = () => any;

// @public
export const NoAnimation: DefineComponent<    {}, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export function noOp(): any;

// @public
export type NormalisedSnippetConfig = RequiredProperties<SnippetConfig, 'uiLang'>;

// @public
export const normalizedQuery: QuerySuggestionsXStoreModule['getters']['normalizedQuery'];

// @public
export function normalizeString(string: string | undefined): string;

// @public
export type NumberComparatorFn = (a: number, b: number) => boolean;

// @public
export const NumberRangeFilter: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<NumberRangeFilter_2>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>, {
innerClickEvents: ComputedRef<any>;
innerCssClasses: ComputedRef<any[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<NumberRangeFilter_2>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>> & Readonly<{}>, {
cssClasses: (string | Dictionary<boolean>)[];
}, {}, {
RenderlessFilter: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export class NumberRangeFilterEntity implements FilterEntity {
    constructor(store: Store<RootXStoreState>);
    // Warning: (ae-forgotten-export) The symbol "isNumberRangeFilter" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static accepts: typeof isNumberRangeFilter;
    deselect(filterParam: Filter): void;
    select(filterParam: Filter): void;
    // (undocumented)
    protected store: Store<RootXStoreState>;
}

// @public
export const OpenMainModal: DefineComponent<    {}, {
openingEvent: "UserClickedOpenX";
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseEventsModalOpen: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const PageLoaderButton: DefineComponent<ExtractPropTypes<    {
buttonClasses: {
type: PropType<VueCSSClasses>;
default: string;
};
buttonEvents: {
type: PropType<Partial<XEventsTypes>>;
};
}>, {
resultsLength: ComputedRef<number>;
totalResults: ComputedRef<number>;
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
buttonClasses: {
type: PropType<VueCSSClasses>;
default: string;
};
buttonEvents: {
type: PropType<Partial<XEventsTypes>>;
};
}>> & Readonly<{}>, {
buttonClasses: VueCSSClasses;
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type PageMode = 'infinite_scroll' | 'pagination';

// @public
export const PageSelector: DefineComponent<ExtractPropTypes<    {
buttonClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
currentPage: {
type: NumberConstructor;
required: true;
};
hiddenPage: {
type: StringConstructor;
default: string;
};
itemClasses: {
type: PropType<(isSelected: boolean) => string | Dictionary<boolean> | (string | Dictionary<boolean>)[]>;
default: () => never[];
};
range: {
type: NumberConstructor;
default: number;
};
scrollTarget: {
type: StringConstructor;
default: string;
};
totalPages: {
type: NumberConstructor;
required: true;
};
}>, {
visiblePages: ComputedRef<PageItem[]>;
selectPage: (page: number | string) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
buttonClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
currentPage: {
type: NumberConstructor;
required: true;
};
hiddenPage: {
type: StringConstructor;
default: string;
};
itemClasses: {
type: PropType<(isSelected: boolean) => string | Dictionary<boolean> | (string | Dictionary<boolean>)[]>;
default: () => never[];
};
range: {
type: NumberConstructor;
default: number;
};
scrollTarget: {
type: StringConstructor;
default: string;
};
totalPages: {
type: NumberConstructor;
required: true;
};
}>> & Readonly<{}>, {
buttonClasses: (string | Dictionary<boolean>)[];
hiddenPage: string;
itemClasses: (isSelected: boolean) => string | Dictionary<boolean> | (string | Dictionary<boolean>)[];
range: number;
scrollTarget: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type Pair<Type> = [Type, Type];

// @public
export const PartialQueryButton: DefineComponent<ExtractPropTypes<    {
query: {
type: StringConstructor;
required: true;
};
}>, {
partialButtonEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
emitEvents: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
query: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const PartialResultsList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: {
type: NumberConstructor;
default: number;
};
}>, {
partialResults: ComputedRef<PartialResult[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
maxItemsToRender: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type PayloadFactoryData<Payload> = RootStoreStateAndGetters & {
    eventPayload: Payload;
    metadata: WireMetadata;
};

export { PlusIcon }

export { PlusTinyIcon }

// @internal
export interface Point {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @internal
export type Points = [Point, Point];

// @public
export const PopularSearch: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<Suggestion>;
required: true;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<Suggestion>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseSuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const PopularSearches: DefineComponent<    {}, {
popularSearches: ComputedRef<Suggestion[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
PopularSearch: DefineComponent<    {}, {}, any>;
BaseSuggestions: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const popularSearches: PopularSearchesXStoreModule['getters']['popularSearches'];

// @public
export type PopularSearchesActionContext = XActionContext<PopularSearchesState, PopularSearchesGetters, PopularSearchesMutations, PopularSearchesActions>;

// @public
export interface PopularSearchesActions {
    cancelFetchAndSaveSuggestions: () => void;
    fetchAndSaveSuggestions: (request: PopularSearchesRequest) => void;
    fetchSuggestions: (request: PopularSearchesRequest) => Suggestion[];
}

// @public
export interface PopularSearchesConfig {
    hideSessionQueries: boolean;
    maxItemsToRequest: number;
}

// @internal
export const popularSearchesEmitters: {
    PopularSearchesRequestUpdated: {
        selector: (_: PopularSearchesState, getters: Returns<GettersTree<PopularSearchesState, PopularSearchesGetters>>) => PopularSearchesRequest;
    };
};

// @public
export interface PopularSearchesGetters {
    popularSearches: Suggestion[];
    request: PopularSearchesRequest;
}

// @public
export interface PopularSearchesMutations extends StatusMutations, ConfigMutations<PopularSearchesState> {
    setParams: (params: Dictionary<unknown>) => void;
    setSearchedQueries: (searchedQueries: HistoryQuery_2[]) => void;
    setSuggestions: (suggestions: Suggestion[]) => void;
}

// @public
export const popularSearchesRequest: PopularSearchesXStoreModule['getters']['request'];

// @public
export interface PopularSearchesState extends StatusState {
    config: PopularSearchesConfig;
    params: Dictionary<unknown>;
    popularSearches: Suggestion[];
    searchedQueries: HistoryQuery_2[];
}

// @internal
export const popularSearchesWiring: {
    PopularSearchesRequestUpdated: {
        retrievePopularSuggestions: Wire<PopularSearchesRequest>;
    };
    SessionHistoryQueriesChanged: {
        setSearchedQueriesInPopularSearches: Wire<HistoryQuery_2[]>;
    };
    ExtraParamsChanged: {
        setPopularSearchesExtraParams: Wire<Dictionary<unknown>>;
    };
};

// @public
export interface PopularSearchesXEvents {
    PopularSearchDisplayed: Suggestion[];
    PopularSearchesRequestUpdated: PopularSearchesRequest;
    UserSelectedAPopularSearch: Suggestion;
}

// @public
export type PopularSearchesXModule = XModule<PopularSearchesXStoreModule>;

// @public
export const popularSearchesXModule: PopularSearchesXModule;

// @public
export type PopularSearchesXStoreModule = XStoreModule<PopularSearchesState, PopularSearchesGetters, PopularSearchesMutations, PopularSearchesActions>;

// @internal
export const popularSearchesXStoreModule: PopularSearchesXStoreModule;

// @public
export const PreselectedFilters: DefineComponent<ExtractPropTypes<    {
filters: {
type: PropType<string[]>;
default: () => never[];
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filters: {
type: PropType<string[]>;
default: () => never[];
};
}>> & Readonly<{}>, {
filters: string[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export type Priority = number;

// @public
export interface PrivateXModuleOptions<Module extends AnyXModule> {
    storeEmitters?: Partial<StoreEmitters<Module['storeModule']>>;
    storeModule?: XStoreModuleOptions<Module['storeModule']>;
}

// @public
export type PrivateXModulesOptions = {
    [ModuleName in XModuleName]?: PrivateXModuleOptions<XModulesTree[ModuleName]>;
};

// @public
export const Promoted: DefineComponent<ExtractPropTypes<    {
promoted: {
type: PropType<Promoted_2>;
required: true;
};
titleClass: StringConstructor;
}>, {
emitUserClickedAPromoted: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
promoted: {
type: PropType<Promoted_2>;
required: true;
};
titleClass: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const PromotedsList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type PropsWithType<SomeObject, TargetItem> = keyof SomeObject & keyof SubObject<SomeObject, TargetItem>;

// @public
export type QueriesPreviewActionContext = XActionContext<QueriesPreviewState, QueriesPreviewGetters, QueriesPreviewMutations, QueriesPreviewActions>;

// @public
export interface QueriesPreviewActions {
    fetchAndSaveQueryPreview: (request: SearchRequest) => void;
    fetchAndSaveQueryPreviewResultsEnrichment: (queryPreviewItem: QueryPreviewItem) => void;
    fetchQueryPreview: (request: SearchRequest) => SearchResponse | null;
}

// @public
export interface QueriesPreviewConfig {
    maxItemsToRequest: number;
}

// @internal
export const queriesPreviewEmitters: {
    QueryPreviewUnselected: {
        selector: (state: QueriesPreviewState) => Dictionary<unknown>;
        filter: (_newValue: Dictionary<unknown>, _oldValue: Dictionary<unknown>, state: QueriesPreviewState) => boolean;
    };
    QueriesPreviewChanged: (_state: QueriesPreviewState, getters: Returns<GettersTree<QueriesPreviewState, QueriesPreviewGetters>>) => Dictionary<QueryPreviewItem>;
};

// @public
export interface QueriesPreviewGetters {
    loadedQueriesPreview: Dictionary<QueryPreviewItem>;
}

// @public
export interface QueriesPreviewMutations extends ConfigMutations<QueriesPreviewState> {
    addQueryPreviewInstance: (queryPreviewHash: string) => void;
    clearQueryPreview: (queryPreviewHash: string) => void;
    removeQueryPreviewInstance: (input: {
        queryPreviewHash: string;
        cache: boolean;
    }) => void;
    setParams: (params: Dictionary<unknown>) => void;
    setQueryPreviewCached: (queryPreview: QueryPreviewItem) => void;
    setSelectedQueryPreview: (selectedQueryPreview: QueryPreviewInfo | null) => void;
    setStatus: (payload: QueryPreviewStatusPayload) => void;
    updateAQueryPreviewResult: (input: {
        result: Result;
        queryPreviewHash: string;
    }) => void;
    updateQueryPreviewResultsFromEnrichment: (enrichmentPayload: {
        queryPreviewItem: QueryPreviewItem;
        enrichmentResults: any[];
    }) => void;
}

// @public
export interface QueriesPreviewState {
    config: QueriesPreviewConfig;
    params: Dictionary<unknown>;
    queriesPreview: Dictionary<QueryPreviewItem>;
    selectedQueryPreview: QueryPreviewInfo | null;
}

// @internal
export const queriesPreviewWiring: {
    QueryPreviewRequestUpdated: {
        fetchAndSaveQueryPreviewWire: Wire<SearchRequest>;
    };
    NonCacheableQueryPreviewUnmounted: {
        clearQueryPreviewWire: Wire<string>;
    };
    UserAcceptedAQueryPreview: {
        setSelectedQueryPreviewWire: Wire<QueryPreviewInfo | null>;
    };
    ExtraParamsChanged: {
        setQueriesPreviewExtraParamsWire: Wire<Dictionary<unknown>>;
    };
    UserClearedQuery: {
        clearSelectedQueryPreviewWire: AnyWire;
    };
    UserClickedCloseX: {
        clearSelectedQueryPreviewWire: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearSelectedQueryPreviewWire: AnyWire;
    };
    UserSelectedAHistoryQuery: {
        clearSelectedQueryPreviewWire: AnyWire;
    };
    QueryPreviewMounted: {
        addQueryPreviewInstanceWire: Wire<string>;
    };
    QueryPreviewUnmounted: {
        removeQueryPreviewInstanceWire: Wire<    {
        queryPreviewHash: string;
        cache: boolean;
        }>;
    };
    QueryPreviewResultReceived: {
        fetchAndSaveQueryPreviewResultsEnrichmentWire: Wire<QueryPreviewItem>;
    };
};

// @public
export interface QueriesPreviewXEvents {
    QueriesPreviewChanged: Dictionary<QueryPreviewItem>;
    QueryPreviewMounted: string;
    QueryPreviewRequestUpdated: SearchRequest;
    QueryPreviewResultReceived: QueryPreviewItem;
    QueryPreviewUnmounted: {
        queryPreviewHash: string;
        cache: boolean;
    };
    QueryPreviewUnselected: Dictionary<unknown>;
    UserAcceptedAQueryPreview: QueryPreviewInfo;
}

// @public
export type QueriesPreviewXModule = XModule<QueriesPreviewXStoreModule>;

// @public
export const queriesPreviewXModule: QueriesPreviewXModule;

// @public
export type QueriesPreviewXStoreModule = XStoreModule<QueriesPreviewState, QueriesPreviewGetters, QueriesPreviewMutations, QueriesPreviewActions>;

// @internal
export const queriesPreviewXStoreModule: QueriesPreviewXStoreModule;

// @public
export const query: NextQueriesXStoreModule['getters']['query'];

// @internal
export const QUERY_KEY: XInjectKey<string | undefined>;

// @public
export type QueryFeature = 'search_box' | 'url' | 'query_suggestion' | 'next_query' | 'popular_search' | 'history_query' | 'partial_result' | 'related_tag' | 'spellcheck' | 'customer' | 'semantics' | 'related_prompts' | 'overview';

// @public
export interface QueryMutations {
    setQuery: (query: string) => void;
}

// @public
export type QueryOrigin = `${QueryFeature}:${FeatureLocation}`;

// @public
export type QueryOriginInit = Partial<Pick<WireMetadata, 'feature' | 'location'>>;

// @public
export const QueryPreview: DefineComponent<ExtractPropTypes<    {
queryPreviewInfo: {
type: PropType<QueryPreviewInfo>;
required: true;
};
queryFeature: {
type: PropType<QueryFeature>;
};
maxItemsToRender: {
type: NumberConstructor;
};
loadWhenVisible: {
type: BooleanConstructor;
default: boolean;
};
debounceTimeMs: {
type: NumberConstructor;
default: number;
};
persistInCache: {
type: BooleanConstructor;
default: boolean;
};
}>, {
hasResults: ComputedRef<boolean>;
queryPreviewResults: ComputedRef<    {
results: Result[];
request: SearchRequest;
displayTagging?: TaggingRequest;
queryTagging?: TaggingRequest;
totalResults: number;
instances: number;
status: RequestStatus;
} | undefined>;
queryPreviewElement: Ref<HTMLElement | null, HTMLElement | null>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("load" | "error")[], "load" | "error", PublicProps, Readonly<ExtractPropTypes<    {
queryPreviewInfo: {
type: PropType<QueryPreviewInfo>;
required: true;
};
queryFeature: {
type: PropType<QueryFeature>;
};
maxItemsToRender: {
type: NumberConstructor;
};
loadWhenVisible: {
type: BooleanConstructor;
default: boolean;
};
debounceTimeMs: {
type: NumberConstructor;
default: number;
};
persistInCache: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onLoad?: ((...args: any[]) => any) | undefined;
onError?: ((...args: any[]) => any) | undefined;
}>, {
loadWhenVisible: boolean;
debounceTimeMs: number;
persistInCache: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const QueryPreviewButton: DefineComponent<ExtractPropTypes<    {
queryPreviewInfo: {
type: PropType<QueryPreviewInfo>;
required: true;
};
metadata: {
type: PropType<Omit<WireMetadata, "moduleName">>;
};
}>, {
fullQueryPreviewInfo: ComputedRef<QueryPreviewInfo>;
events: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
queryPreviewInfo: {
type: PropType<QueryPreviewInfo>;
required: true;
};
metadata: {
type: PropType<Omit<WireMetadata, "moduleName">>;
};
}>> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface QueryPreviewInfo {
    [extra: string]: unknown;
    extraParams?: Dictionary<unknown>;
    filters?: string[];
    query: string;
    title?: string;
}

// @public
export interface QueryPreviewItem extends StatusState {
    displayTagging?: TaggingRequest;
    instances: number;
    queryTagging?: TaggingRequest;
    request: SearchRequest;
    results: Result[];
    totalResults: number;
}

// @public
export const QueryPreviewList: DefineComponent<ExtractPropTypes<    {
queriesPreviewInfo: {
type: PropType<QueryPreviewInfo[]>;
required: true;
};
queryFeature: {
type: PropType<QueryFeature>;
};
maxItemsToRender: {
type: NumberConstructor;
};
loadWhenVisible: {
type: BooleanConstructor;
default: boolean;
};
debounceTimeMs: {
type: NumberConstructor;
default: number;
};
persistInCache: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, {
renderedQueryPreviews: ComputedRef<QueryPreviewInfo[]>;
flagAsFailed: (failedQuery: string) => void;
flagAsLoaded: (loadedQuery: string) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
queriesPreviewInfo: {
type: PropType<QueryPreviewInfo[]>;
required: true;
};
queryFeature: {
type: PropType<QueryFeature>;
};
maxItemsToRender: {
type: NumberConstructor;
};
loadWhenVisible: {
type: BooleanConstructor;
default: boolean;
};
debounceTimeMs: {
type: NumberConstructor;
default: number;
};
persistInCache: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
persistInCache: boolean;
loadWhenVisible: boolean;
debounceTimeMs: number;
animation: string | Function | Record<string, any>;
}, {}, {
QueryPreview: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface QueryPreviewStatusPayload {
    queryPreviewHash: string;
    status: RequestStatus;
}

// @public
export interface QueryState {
    query: string;
}

// @public
export const QuerySuggestion: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<Suggestion>;
required: true;
};
}>, {
query: ComputedRef<string>;
suggestionSelectedEvents: {
UserSelectedAQuerySuggestion: Suggestion;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<Suggestion>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseSuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const QuerySuggestions: DefineComponent<    {}, {
suggestions: ComputedRef<Suggestion[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseSuggestions: DefineComponent<    {}, {}, any>;
QuerySuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const querySuggestions: (input: QuerySuggestionsState) => Suggestion[];

// @public
export type QuerySuggestionsActionContext = XActionContext<QuerySuggestionsState, QuerySuggestionsGetters, QuerySuggestionsMutations, QuerySuggestionsActions>;

// @public
export interface QuerySuggestionsActions {
    cancelFetchAndSaveSuggestions: () => void;
    fetchAndSaveSuggestions: (request: QuerySuggestionsRequest | null) => void;
    fetchSuggestions: (request: QuerySuggestionsRequest | null) => Suggestion[];
    setUrlParams: (urlParams: UrlParams) => void;
}

// @public
export interface QuerySuggestionsConfig {
    debounceInMs: number;
    hideIfEqualsQuery: boolean;
    hideSessionQueries: boolean;
    maxItemsToRequest: number;
}

// @internal
export const querySuggestionsEmitters: {
    QuerySuggestionsChanged: (state: QuerySuggestionsState) => Suggestion[];
    QuerySuggestionsRequestUpdated: (_: QuerySuggestionsState, getters: Returns<GettersTree<QuerySuggestionsState, QuerySuggestionsGetters>>) => QuerySuggestionsRequest | null;
};

// @public
export class QuerySuggestionsGetter implements GettersClass<QuerySuggestionsXStoreModule> {
    // @internal
    protected isInQuerySuggestions(normalizedQuery: string): (suggestion: Suggestion) => boolean;
    querySuggestions(input: QuerySuggestionsState): Suggestion[];
}

// @public
export interface QuerySuggestionsGetters {
    normalizedQuery: string;
    querySuggestions: Suggestion[];
    request: QuerySuggestionsRequest | null;
}

// @public
export interface QuerySuggestionsMutations extends StatusMutations, QueryMutations, ConfigMutations<QuerySuggestionsState> {
    setParams: (params: Dictionary<unknown>) => void;
    setSearchedQueries: (searchedQueries: HistoryQuery_2[]) => void;
    setSuggestions: (suggestions: Suggestion[]) => void;
}

// @public
export const querySuggestionsRequest: QuerySuggestionsXStoreModule['getters']['request'];

// @public
export interface QuerySuggestionsState extends StatusState, QueryState {
    config: QuerySuggestionsConfig;
    params: Dictionary<unknown>;
    searchedQueries: HistoryQuery_2[];
    suggestions: Suggestion[];
}

// @internal
export const querySuggestionsWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
    };
    UserIsTypingAQuery: {
        setQuerySuggestionsQueryDebounce: Wire<string>;
    };
    UserAcceptedAQuery: {
        setQuerySuggestionsQuery: Wire<string>;
    };
    UserClearedQuery: {
        clearQuerySuggestionsQuery: AnyWire;
        cancelFetchAndSaveSuggestionsWire: AnyWire;
    };
    QuerySuggestionsRequestUpdated: {
        fetchAndSaveSuggestionsWire: Wire<QuerySuggestionsRequest | null>;
    };
    ExtraParamsChanged: {
        setQuerySuggestionsExtraParams: Wire<Dictionary<unknown>>;
    };
    UserClickedCloseX: {
        clearQuerySuggestionsQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearQuerySuggestionsQuery: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setQuerySuggestionsQueryFromPreview: AnyWire;
        setQuerySuggestionsExtraParamsFromPreview: AnyWire;
    };
    QueryPreviewUnselected: {
        setQuerySuggestionsExtraParams: Wire<Dictionary<unknown>>;
    };
    SessionHistoryQueriesChanged: {
        setSearchedQueriesInSuggestions: Wire<HistoryQuery_2[]>;
    };
};

// @public
export interface QuerySuggestionsXEvents {
    QuerySuggestionsChanged: Suggestion[];
    QuerySuggestionsRequestUpdated: QuerySuggestionsRequest | null;
    UserSelectedAQuerySuggestion: Suggestion;
}

// @public
export type QuerySuggestionsXModule = XModule<QuerySuggestionsXStoreModule>;

// @public
export const querySuggestionsXModule: QuerySuggestionsXModule;

// @public
export type QuerySuggestionsXStoreModule = XStoreModule<QuerySuggestionsState, QuerySuggestionsGetters, QuerySuggestionsMutations, QuerySuggestionsActions>;

// @internal
export const querySuggestionsXStoreModule: QuerySuggestionsXStoreModule;

export { RadioButtonSelectedIcon }

export { RadioButtonUnselectedIcon }

// @internal
export class RawFilterEntity implements FilterEntity {
    constructor(store: Store<unknown>);
    // Warning: (ae-forgotten-export) The symbol "isRawFilter" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static accepts: typeof isRawFilter;
    deselect(filterParam: Filter): void;
    select(filterParam: Filter): void;
    // (undocumented)
    protected store: Store<unknown>;
}

// @public
export const Recommendations: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
}>, {
recommendations: ComputedRef<Result[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const RECOMMENDATIONS_ORIGIN = "default";

// @public
export type RecommendationsActionContext = XActionContext<RecommendationsState, RecommendationsGetters, RecommendationsMutations, RecommendationsActions>;

// @public
export interface RecommendationsActions {
    cancelFetchAndSaveRecommendations: () => void;
    cancelFetchAndSaveRecommendationsEnrichment: () => void;
    fetchAndSaveRecommendations: (request: RecommendationsRequest | null) => void;
    fetchAndSaveRecommendationsEnrichment: (results: Result[]) => void;
    fetchRecommendations: (request: RecommendationsRequest | null) => Result[];
}

// @public
export interface RecommendationsConfig {
    maxItemsToRequest: number;
}

// @internal
export const recommendationsEmitters: {
    RecommendationsChanged: (state: RecommendationsState) => Result[];
    RecommendationsRequestUpdated: {
        selector: (_: RecommendationsState, getters: Returns<GettersTree<RecommendationsState, RecommendationsGetters>>) => RecommendationsRequest;
    };
};

// @public
export interface RecommendationsGetters {
    request: RecommendationsRequest;
}

// @public
export interface RecommendationsMutations extends StatusMutations, ConfigMutations<RecommendationsState> {
    setParams: (params: Dictionary<unknown>) => void;
    setRecommendations: (recommendations: Result[]) => void;
    updateRecommendation: (recommendation: Partial<Result> & Pick<Result, 'id'>) => void;
    updateRecommendationsFromEnrichment: (enrichmentResults: any[]) => void;
}

// @public
export const recommendationsRequest: RecommendationsXStoreModule['getters']['request'];

// @public
export interface RecommendationsState extends StatusState {
    config: RecommendationsConfig;
    origin: string;
    params: Dictionary<unknown>;
    recommendations: Result[];
}

// @internal
export const recommendationsWiring: {
    RecommendationsChanged: {
        fetchAndSaveRecommendationsEnrichmentWire: Wire<Result[]>;
    };
    RecommendationsRequestUpdated: {
        fetchAndSaveRecommendations: Wire<RecommendationsRequest | null>;
    };
    UserClickedColumnPicker: {};
    ExtraParamsChanged: {
        setRecommendationsExtraParams: Wire<Dictionary<unknown>>;
    };
};

// @public
export interface RecommendationsXEvents {
    RecommendationsChanged: Result[];
    RecommendationsRequestUpdated: RecommendationsRequest;
    UserClickedARecommendation: Result;
}

// @public
export type RecommendationsXModule = XModule<RecommendationsXStoreModule>;

// @public
export const recommendationsXModule: RecommendationsXModule;

// @public
export type RecommendationsXStoreModule = XStoreModule<RecommendationsState, RecommendationsGetters, RecommendationsMutations, RecommendationsActions>;

// @internal
export const recommendationsXStoreModule: RecommendationsXStoreModule;

// @public
export const Redirection: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"auto" | "manual">;
default: string;
};
delayInSeconds: {
type: NumberConstructor;
default: number;
};
}>, {
redirection: ComputedRef<Redirection_2 | null>;
redirect: () => void;
abortRedirect: () => void;
isRedirecting: Ref<boolean, boolean>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"auto" | "manual">;
default: string;
};
delayInSeconds: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
mode: "auto" | "manual";
delayInSeconds: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const refreshHistoryQueriesSession: AnyWire;

// @public
export const refreshSession: HistoryQueriesXStoreModule['actions']['refreshSession'];

// @internal
export function registerStoreEmitters(input: AnyXModule, bus: XBus<XEventsTypes, WireMetadata>, store: Store<any>): void;

// @public
export const RelatedPrompt: DefineComponent<ExtractPropTypes<    {
relatedPrompt: {
type: PropType<RelatedPrompt_2>;
required: true;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
relatedPrompt: {
type: PropType<RelatedPrompt_2>;
required: true;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
selected: boolean;
}, {}, {
CrossTinyIcon: DefineComponent<    {}, {}, any>;
PlusIcon: DefineComponent<    {}, {}, any>;
}, {
typing: Directive<TypingHTMLElement, TypingOptions>;
}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type RelatedPromptsActionContext = XActionContext<RelatedPromptsState, RelatedPromptsGetters, RelatedPromptsMutations, RelatedPromptsActions>;

// @public
export interface RelatedPromptsActions {
    cancelFetchAndSaveRelatedPrompts: () => void;
    fetchAndSaveRelatedPrompts: (request: RelatedPromptsRequest | null) => void;
    fetchRelatedPrompts: (request: RelatedPromptsRequest | null) => RelatedPrompt_2[] | null;
    setUrlParams: (urlParams: UrlParams) => void;
}

// @public
export interface RelatedPromptsGetters {
    query: string;
    request: RelatedPromptsRequest | null;
}

// @public
export const RelatedPromptsList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
offset: {
type: NumberConstructor;
default: number;
};
frequency: {
type: NumberConstructor;
default: number;
};
maxRelatedPromptsPerGroup: {
type: NumberConstructor;
default: number;
};
maxGroups: {
type: NumberConstructor;
default: undefined;
};
showOnlyAfterOffset: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
offset: {
type: NumberConstructor;
default: number;
};
frequency: {
type: NumberConstructor;
default: number;
};
maxRelatedPromptsPerGroup: {
type: NumberConstructor;
default: number;
};
maxGroups: {
type: NumberConstructor;
default: undefined;
};
showOnlyAfterOffset: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
offset: number;
frequency: number;
maxRelatedPromptsPerGroup: number;
maxGroups: number;
showOnlyAfterOffset: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface RelatedPromptsMutations extends StatusMutations, QueryMutations {
    resetRelatedPromptsState: () => void;
    resetSelectedPrompt: () => void;
    setParams: (params: Dictionary<unknown>) => void;
    setRelatedPromptsProducts: (products: RelatedPrompt_2[]) => void;
    setRelatedPromptsRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setSelectedPrompt: (index: number) => void;
    setSelectedQuery: (index: number) => void;
}

// @public
export interface RelatedPromptsState extends StatusState, QueryState {
    params: Dictionary<unknown>;
    relatedPrompts: RelatedPrompt_2[];
    relatedTags: RelatedTag_2[];
    selectedPrompt: number;
    selectedQuery: number;
}

// @internal
export const relatedPromptsStoreEmitters: {
    RelatedPromptsRequestUpdated: (_: RelatedPromptsState, getters: Returns<GettersTree<RelatedPromptsState, RelatedPromptsGetters>>) => RelatedPromptsRequest | null;
    SelectedRelatedPromptChanged: (state: RelatedPromptsState) => number;
    RelatedPromptsResponseChanged: (state: RelatedPromptsState) => RelatedPrompt_2[];
};

// @public
export const RelatedPromptsTagList: DefineComponent<ExtractPropTypes<    {
buttonClass: StringConstructor;
showButtons: {
type: BooleanConstructor;
default: boolean;
};
scrollContainerClass: StringConstructor;
tagClass: StringConstructor;
tagColors: PropType<string[]>;
animationDurationInMs: {
type: NumberConstructor;
default: number;
};
}>, {
onSelect: (selectedIndex: number) => void;
onBeforeEnter: (el: Element) => void;
onEnter: (el: Element, done: () => void) => void;
onLeave: (el: Element, done: () => void) => void;
selectedPromptIndex: ComputedRef<number>;
visibleRelatedPrompts: ComputedRef<    {
index: number;
relatedPromptNextQueries?: RelatedPromptNextQuery[];
nextQueries: string[];
suggestionText: string;
suggestionImageUrl?: string;
type: string;
toolingDisplayTagging?: TaggingRequest;
tagging?: {
toolingDisplayTagging?: TaggingRequest;
toolingDisplayClickTagging?: TaggingRequest;
nextQueriesTagging?: RelatedPromptNextQuery[];
};
modelName: "RelatedPrompt";
}[]>;
listItems: Ref<HTMLElement[], HTMLElement[]>;
isAnimating: Ref<boolean, boolean>;
x: UseAliasAPI & {
on: <Event extends XEvent, Metadata extends boolean>(event: Event, withMetadata: Metadata) => {
subscribe: (callback: (payload: Metadata extends true ? SubjectPayload<EventPayload<XEventsTypes, Event>, WireMetadata> : EventPayload<XEventsTypes, Event>) => void) => void;
};
emit: <Event extends XEvent>(event: Event, payload?: XEventPayload<Event>, metadata?: Omit<WireMetadata, "moduleName">) => Promise<EmittedData<XEventsTypes, Event, WireMetadata>>;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
buttonClass: StringConstructor;
showButtons: {
type: BooleanConstructor;
default: boolean;
};
scrollContainerClass: StringConstructor;
tagClass: StringConstructor;
tagColors: PropType<string[]>;
animationDurationInMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
showButtons: boolean;
animationDurationInMs: number;
}, {}, {
DisplayEmitter: DefineComponent<    {}, {}, any>;
RelatedPrompt: DefineComponent<    {}, {}, any>;
SlidingPanel: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export const relatedPromptsWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
    };
    ExtraParamsChanged: {
        setExtraParams: Wire<Dictionary<unknown>>;
    };
    UserAcceptedAQuery: {
        setRelatedPromptsQuery: Wire<string>;
        resetRelatedPrompt: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setRelatedPromptsQueryFromPreview: AnyWire;
        resetRelatedPrompt: AnyWire;
    };
    UserClearedQuery: {
        cancelFetchAndSaveRelatedPrompts: AnyWire;
        resetRelatedPromptsState: AnyWire;
        setRelatedPromptsQuery: Wire<string>;
    };
    RelatedPromptsRequestUpdated: {
        fetchAndSaveRelatedPrompts: Wire<RelatedPromptsRequest | null>;
    };
    UserSelectedARelatedPrompt: {
        setRelatedPrompt: Wire<number>;
    };
    UserSelectedARelatedPromptQuery: {
        setRelatedPromptQuery: Wire<number>;
    };
    SearchRequestChanged: {
        resetRelatedPrompt: Wire<any>;
    };
    SelectedRelatedTagsChanged: {
        setRelatedPromptsRelatedTags: Wire<RelatedTag_2[]>;
    };
    ReloadRelatedPromptsRequested: {
        resetRelatedPromptsState: AnyWire;
        reloadRelatedPromptsRequestWire: AnyWire;
    };
};

// @public
export interface RelatedPromptsXEvents {
    RelatedPromptsRequestUpdated: RelatedPromptsRequest | null;
    RelatedPromptsResponseChanged: RelatedPrompt_2[];
    RelatedPromptsUnmounted: void;
    ReloadRelatedPromptsRequested: void;
    SelectedRelatedPromptChanged: number;
    UserClickedARelatedPromptAdd2Cart: Result;
    UserClickedARelatedPromptResult: Result;
    UserSelectedARelatedPrompt: number;
    UserSelectedARelatedPromptQuery: number;
}

// @public
export type RelatedPromptsXModule = XModule<RelatedPromptsXStoreModule>;

// @public
export const relatedPromptsXModule: RelatedPromptsXModule;

// @public
export type RelatedPromptsXStoreModule = XStoreModule<RelatedPromptsState, RelatedPromptsGetters, RelatedPromptsMutations, RelatedPromptsActions>;

// @internal
export const relatedPromptsXStoreModule: RelatedPromptsXStoreModule;

// @public
export const RelatedTag: DefineComponent<ExtractPropTypes<    {
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
relatedTag: {
type: PropType<RelatedTag_2>;
required: true;
};
}>, {
buttonEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
dynamicClasses: ComputedRef<VueCSSClasses>;
isSelected: ComputedRef<boolean>;
clickRelatedTag: () => void;
shouldHighlightCurated: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
relatedTag: {
type: PropType<RelatedTag_2>;
required: true;
};
}>> & Readonly<{}>, {
highlightCurated: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const RelatedTags: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
itemClass: StringConstructor;
}>, {
relatedTags: ComputedRef<RelatedTag_2[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
maxItemsToRender: NumberConstructor;
highlightCurated: {
type: BooleanConstructor;
default: boolean;
};
itemClass: StringConstructor;
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
highlightCurated: boolean;
}, {}, {
RelatedTag: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const relatedTags: RelatedTagsXStoreModule['getters']['relatedTags'];

// @public
export type RelatedTagsActionContext = XActionContext<RelatedTagsState, RelatedTagsGetters, RelatedTagsMutations, RelatedTagsActions>;

// @public
export interface RelatedTagsActions {
    cancelFetchAndSaveRelatedTags: () => void;
    fetchAndSaveRelatedTags: (request: RelatedTagsRequest | null) => void;
    fetchRelatedTags: (request: RelatedTagsRequest | null) => RelatedTag_2[];
    setUrlParams: (urlParams: UrlParams) => void;
    toggleRelatedTag: (relatedTag: RelatedTag_2) => void;
}

// @public
export interface RelatedTagsConfig {
    maxItemsToRequest: number;
}

// @internal
export const relatedTagsEmitters: {
    RelatedTagsChanged: (state: RelatedTagsState) => RelatedTag_2[];
    RelatedTagsRequestUpdated: (_: RelatedTagsState, getters: Returns<GettersTree<RelatedTagsState, RelatedTagsGetters>>) => RelatedTagsRequest | null;
    SelectedRelatedTagsChanged: {
        selector: (state: RelatedTagsState) => RelatedTag_2[];
        filter: (newCollection: RelatedTag_2[], oldCollection: RelatedTag_2[]) => boolean;
    };
};

// @public
export interface RelatedTagsGetters {
    query: string;
    relatedTags: RelatedTag_2[];
    request: RelatedTagsRequest | null;
}

// @public
export interface RelatedTagsMutations extends StatusMutations, QueryMutations, ConfigMutations<RelatedTagsState> {
    setParams: (params: Dictionary<unknown>) => void;
    setRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setSelectedRelatedTags: (selectedRelatedTags: RelatedTag_2[]) => void;
}

// @public
export const relatedTagsQuery: RelatedTagsXStoreModule['getters']['query'];

// @public
export const relatedTagsRequest: RelatedTagsXStoreModule['getters']['request'];

// @public
export interface RelatedTagsState extends StatusState, QueryState {
    config: RelatedTagsConfig;
    params: Dictionary<unknown>;
    relatedTags: RelatedTag_2[];
    selectedRelatedTags: RelatedTag_2[];
}

// @internal
export const relatedTagsWiring: {
    ParamsLoadedFromUrl: {
        setUrlParamsWire: Wire<UrlParams>;
    };
    UserAcceptedAQuery: {
        setRelatedTagsQuery: Wire<string>;
        clearSelectedRelatedTags: AnyWire;
    };
    UserPickedARelatedTag: {
        toggleRelatedTagWire: Wire<RelatedTag_2>;
    };
    UserChangedExtraParams: {
        clearSelectedRelatedTags: AnyWire;
    };
    RelatedTagsRequestUpdated: {
        fetchAndSaveRelatedTagsWire: Wire<RelatedTagsRequest | null>;
    };
    UserClearedQuery: {
        cancelFetchAndSaveRelatedTagsWire: AnyWire;
        clearRelatedTagsQuery: AnyWire;
        clearSelectedRelatedTags: AnyWire;
    };
    ExtraParamsChanged: {
        setRelatedTagsExtraParams: Wire<Dictionary<unknown>>;
    };
    UserClickedCloseX: {
        clearRelatedTagsQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearRelatedTagsQuery: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setRelatedTagsQueryFromPreview: AnyWire;
        clearSelectedRelatedTags: AnyWire;
        setRelatedTagsExtraParamsFromPreview: AnyWire;
    };
    QueryPreviewUnselected: {
        setRelatedTagsExtraParams: Wire<Dictionary<unknown>>;
    };
};

// @public
export interface RelatedTagsXEvents {
    RelatedTagsChanged: RelatedTag_2[];
    RelatedTagsRequestUpdated: RelatedTagsRequest | null;
    SelectedRelatedTagsChanged: RelatedTag_2[];
    UserDeselectedARelatedTag: RelatedTag_2;
    UserPickedARelatedTag: RelatedTag_2;
    UserSelectedARelatedTag: RelatedTag_2;
}

// @public
export type RelatedTagsXModule = XModule<RelatedTagsXStoreModule>;

// @public
export const relatedTagsXModule: RelatedTagsXModule;

// @public
export type RelatedTagsXStoreModule = XStoreModule<RelatedTagsState, RelatedTagsGetters, RelatedTagsMutations, RelatedTagsActions>;

// @internal
export const relatedTagsXStoreModule: RelatedTagsXStoreModule;

// @public
export const removeFromHistory: HistoryQueriesXStoreModule['actions']['removeFromHistory'];

// @public
export const RemoveHistoryQuery: DefineComponent<ExtractPropTypes<    {
historyQuery: {
type: PropType<HistoryQuery_2>;
required: true;
};
}>, {
removeHistoryQueryEvent: ComputedRef<Partial<XEventsTypes>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
historyQuery: {
type: PropType<HistoryQuery_2>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const removeHistoryQuery: Wire<HistoryQuery_2>;

// @public
export const removeQueryPreviewInstanceWire: Wire<    {
queryPreviewHash: string;
cache: boolean;
}>;

// @public
export const removeSearchInputFocus: () => void;

// @public
export const RenderlessExtraParams: DefineComponent<ExtractPropTypes<    {
name: {
type: StringConstructor;
required: true;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const RenderlessFilter: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<BooleanFilter>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<BooleanFilter>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>> & Readonly<{}>, {
cssClasses: (string | Dictionary<boolean>)[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export const replaceableParams: UrlParamKey[];

// @public
export type RequestStatus = 'success' | 'loading' | 'error' | 'initial';

// @public
export const resetAppending: AnyWire;

// @public
export const resetFromNoResultsWithFilters: AnyWire;

// @public
export const resetIsNoResults: AnyWire;

// @public
export const resetRequestOnRefinement: SearchXStoreModule['actions']['resetRequestOnRefinement'];

// @public
export const resetRequestOnRefinementWire: AnyWire;

// @public
export const resetResultsPreviewWire: AnyWire;

// @public
export const resetSpellcheckQuery: AnyWire;

// @public
export const resetStateForReloadWire: AnyWire;

// @public
export const resetStateIfNoRequestWire: Wire<InternalSearchRequest | null>;

// @internal
export function resettableState(): {
    query: string;
    results: never[];
    partialResults: never[];
    facets: never[];
    relatedTags: never[];
    banners: never[];
    promoteds: never[];
    totalResults: number;
    spellcheckedQuery: string;
    sort: string;
    page: number;
    origin: null;
    isAppendResults: boolean;
    redirections: never[];
    queryTagging: {
        url: string;
        params: {};
    };
    displayTagging: {
        url: string;
        params: {};
    };
    stats: Stats;
};

// @internal
export const RESULT_WITH_VARIANTS_KEY: XInjectKey<Result>;

// @public
export type ResultFeature = 'search' | 'topclicked_recommendations' | 'brand_recommendations' | 'next_query_recommendations' | 'semantic_recommendations' | 'partial_results' | 'identifier_result' | 'related_prompts' | 'overview' | 'ai_carousel';

// @public
export type ResultOrigin = `${ResultFeature}:${FeatureLocation}`;

// @public
export interface ResultsEnrichmentService {
    fetchResults: (results: Result[]) => Promise<any[]>;
    updateResults: (results: Result[], enrichmentResults: any[]) => void;
}

// @public
export const ResultsList: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "UserReachedResultsListEnd"[], "UserReachedResultsListEnd", PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{
onUserReachedResultsListEnd?: ((...args: any[]) => any) | undefined;
}>, {
animation: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const ResultVariantSelector: DefineComponent<ExtractPropTypes<    {
level: {
type: NumberConstructor;
default: number;
};
}>, {
result: Ref<Result, Result> | undefined;
variants: ComputedRef<ResultVariant[] | undefined>;
variantIsSelected: (variant: ResultVariant) => boolean;
selectVariant: (variant: ResultVariant) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
level: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
level: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const ResultVariantsProvider: DefineComponent<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
autoSelectDepth: {
type: NumberConstructor;
default: number;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
result: {
type: PropType<Result>;
required: true;
};
autoSelectDepth: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
autoSelectDepth: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type Returns<T extends Dictionary<AnyFunction>> = {
    [K in keyof T]: ReturnType<T[K]>;
};

// @public
export type RootStoreStateAndGetters = Pick<Store<RootXStoreState>, 'state'> & {
    getters: Dictionary;
};

// @internal
export const RootXStoreModule: Module<any, any>;

// @public
export interface RootXStoreState {
    // (undocumented)
    x: {
        [Module in XModuleName]: ExtractState<Module>;
    };
}

// @public
export const sanitize: (str: string) => string;

// @public
export const saveAiOrigin: AiXStoreModule['actions']['saveOrigin'];

// @public
export const saveIdentifierResultsOrigin: IdentifierResultsXStoreModule['actions']['saveOrigin'];

// @public
export const saveIdentifierResultsOriginWire: AnyWire;

// @public
export const saveOriginWire: AnyWire;

// @public
export const saveQuery: IdentifierResultsXStoreModule['actions']['saveQuery'];

// @public
export const saveSearchOrigin: SearchXStoreModule['actions']['saveOrigin'];

// @public
export const saveSearchResponse: SearchXStoreModule['actions']['saveSearchResponse'];

// @public
export const Scroll: DefineComponent<ExtractPropTypes<    {
id: {
type: StringConstructor;
default: string;
};
}>, {
scrollRef: Ref<ComponentPublicInstance | undefined, ComponentPublicInstance | undefined>;
emitScrollAtEnd: (isAtEnd: boolean) => void;
emitScrollAlmostAtEnd: (isAlmostAtEnd: boolean) => void;
emitScrollAtStart: (isAtStart: boolean) => void;
emitScrollDirectionChange: (direction: ScrollDirection) => void;
emitScroll: (position: number) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
id: string;
}, {}, {
BaseScroll: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface ScrollActions {
}

// @public
export interface ScrollComponentState {
    direction: ScrollDirection;
    hasAlmostReachedEnd: boolean;
    hasReachedEnd: boolean;
    hasReachedStart: boolean;
    position: number;
}

// @public
export type ScrollDirection = 'UP' | 'DOWN';

// @internal
export const scrollEmitters: {};

// @public
export interface ScrollGetters {
}

// @public
export interface ScrollMutations {
    setPendingScrollTo: (pendingScrollTo: string) => void;
    setScrollComponentState: (partialState: ScrollStatePayload) => void;
}

// @internal
export const ScrollObserverKey: XInjectKey<ScrollVisibilityObserver | null>;

// @public
export interface ScrollState {
    data: Dictionary<ScrollComponentState>;
    pendingScrollTo: string;
}

// @public
export interface ScrollStatePayload extends Identifiable<string> {
    newState: Partial<ScrollComponentState>;
}

// @public
export const ScrollToTop: DefineComponent<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
thresholdPx: NumberConstructor;
scrollId: {
type: StringConstructor;
default: string;
};
}>, {
events: ComputedRef<Partial<XEventsTypes>>;
isVisible: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, any>;
};
thresholdPx: NumberConstructor;
scrollId: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
animation: string | Function | Record<string, any>;
scrollId: string;
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface ScrollVisibilityObserver {
    observe: (element: HTMLElement) => void;
    unobserve: (element: HTMLElement) => void;
}

// @internal
export const scrollWiring: {
    UserScrolled: {
        setScrollPositionWire: AnyWire;
    };
    UserChangedScrollDirection: {
        setScrollDirectionWire: AnyWire;
    };
    UserReachedScrollStart: {
        setScrollHasReachedStartWire: AnyWire;
    };
    UserAlmostReachedScrollEnd: {
        setScrollHasAlmostReachedEndWire: AnyWire;
    };
    UserReachedScrollEnd: {
        setScrollHasReachedEndWire: AnyWire;
    };
    ParamsLoadedFromUrl: {
        setPendingScrollToWire: AnyWire;
    };
    ScrollRestoreSucceeded: {
        clearPendingScrollToWire: AnyWire;
    };
    ScrollRestoreFailed: {
        clearPendingScrollToWire: AnyWire;
    };
};

// @public
export interface ScrollXEvents {
    ScrollRestoreFailed: void;
    ScrollRestoreSucceeded: void;
    UserAlmostReachedScrollEnd: boolean;
    UserChangedScrollDirection: ScrollDirection;
    UserReachedScrollEnd: boolean;
    UserReachedScrollStart: boolean;
    UserScrolled: number;
    UserScrolledToElement: string;
}

// @public
export type ScrollXModule = XModule<ScrollXStoreModule>;

// @public
export const scrollXModule: ScrollXModule;

// @public
export type ScrollXStoreModule = XStoreModule<ScrollState, ScrollGetters, ScrollMutations, ScrollActions>;

// @internal
export const scrollXStoreModule: ScrollXStoreModule;

// @public
export type SearchActionContext = XActionContext<SearchState, SearchGetters, SearchMutations, SearchActions>;

// @public
export interface SearchActions {
    cancelFetchAndSaveSearchResponse: () => void;
    fetchAndSavePartialResultsEnrichment: (partialResults: PartialResult[]) => void;
    fetchAndSaveResultsEnrichment: (results: Result[]) => void;
    fetchAndSaveSearchResponse: (request: InternalSearchRequest | null) => void;
    fetchSearchResponse: (request: SearchRequest) => SearchResponse;
    increasePageAppendingResults: () => void;
    resetRequestOnRefinement: (watchedRequest: WatchedInternalSearchRequest) => void;
    saveOrigin: (originInit: QueryOriginInit) => void;
    saveSearchResponse: (response: SearchResponse) => void;
    setUrlParams: (urlParams: UrlParams) => void;
}

// @public
export interface SearchBoxActions {
    setInputStatus: (event: XEvent) => void;
    setUrlParams: (urlParams: UrlParams) => void;
}

// @internal
export const searchBoxEmitters: {
    SearchBoxQueryChanged: (_: SearchBoxState, getters: Returns<GettersTree<SearchBoxState, SearchBoxGetters>>) => string;
    UserClearedQuery: {
        selector: (state: SearchBoxState) => string;
        filter: typeof isStringEmpty;
    };
};

// @public
export interface SearchBoxGetters {
    trimmedQuery: string;
}

// @public
export interface SearchBoxMutations extends QueryMutations {
    // Warning: (ae-incompatible-release-tags) The symbol "setInputStatus" is marked as @public, but its signature references "InputStatus" which is marked as @internal
    setInputStatus: (inputStatus: InputStatus) => void;
}

// @public
export interface SearchBoxState extends QueryState {
    inputStatus: string;
}

// @internal
export const searchBoxWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
        transitionState: Wire<any>;
    };
    UserIsTypingAQuery: {
        setSearchBoxQuery: Wire<string>;
        transitionState: AnyWire;
    };
    UserAcceptedAQuery: {
        setSearchBoxQuery: Wire<string>;
        transitionState: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setSearchBoxQueryFromPreview: AnyWire;
        transitionState: AnyWire;
    };
    UserPressedClearSearchBoxButton: {
        clearSearchBoxQuery: AnyWire;
    };
    UserClickedCloseX: {
        clearSearchBoxQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearSearchBoxQuery: AnyWire;
    };
    UserClearedQuery: {
        transitionState: AnyWire;
    };
    UserFocusedSearchBox: {
        transitionState: AnyWire;
    };
    UserBlurredSearchBox: {
        transitionState: AnyWire;
    };
};

// @public
export interface SearchBoxXEvents {
    SearchBoxQueryChanged: string;
    UserBlurredSearchBox: void;
    UserClearedQuery: string;
    UserClickedSearchBox: void;
    UserFocusedSearchBox: void;
    UserHoveredInSearchBox: void;
    UserHoveredOutSearchBox: void;
    UserIsTypingAQuery: string;
    UserPressedClearSearchBoxButton: void;
    UserPressedEnterKey: string;
    UserPressedSearchButton: string;
    UserTalked: string;
}

// @public
export type SearchBoxXModule = XModule<SearchBoxXStoreModule>;

// @public
export const searchBoxXModule: SearchBoxXModule;

// @public
export type SearchBoxXStoreModule = XStoreModule<SearchBoxState, SearchBoxGetters, SearchBoxMutations, SearchBoxActions>;

// @internal
export const searchBoxXStoreModule: SearchBoxXStoreModule;

// @public
export const SearchButton: DefineComponent<    {}, {
dynamicClasses: ComputedRef<VueCSSClasses>;
buttonRef: Ref<HTMLElement | null, HTMLElement | null>;
emitEvents: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface SearchConfig {
    // (undocumented)
    pageMode: PageMode;
    pageSize: number;
}

// @internal
export const searchEmitters: {
    FacetsChanged: {
        selector: (state: SearchState) => Facet[];
        filter(newValue: Facet[], oldValue: Facet[]): boolean;
    };
    PageChanged: (state: SearchState) => number;
    PartialResultsChanged: (state: SearchState) => PartialResult[];
    ResultsChanged: (state: SearchState) => Result[];
    SearchRequestChanged: (_: SearchState, getters: Returns<GettersTree<SearchState, SearchGetters>>) => InternalSearchRequest | null;
    SearchRequestUpdated: (_: SearchState, getters: Returns<GettersTree<SearchState, SearchGetters>>) => InternalSearchRequest | null;
    SearchResponseChanged: {
        selector: (state: SearchState, getters: Returns<GettersTree<SearchState, SearchGetters>>) => {
            request: InternalSearchRequest;
            status: RequestStatus;
            banners: Banner_2[];
            facets: Facet[];
            partialResults: PartialResult[];
            promoteds: Promoted_2[];
            queryTagging: TaggingRequest;
            displayTagging: TaggingRequest;
            redirections: Redirection_2[];
            results: Result[];
            spellcheck: string;
            totalResults: number;
        };
        filter: (newValue: InternalSearchResponse, oldValue: InternalSearchResponse) => boolean;
    };
    SearchTaggingChanged: {
        selector: (state: SearchState) => TaggingRequest;
        filter: (input: TaggingRequest) => boolean;
    };
    SpellcheckChanged: (state: SearchState) => string;
    SortChanged: (state: SearchState) => string;
};

// @public
export interface SearchGetters {
    query: string;
    request: InternalSearchRequest | null;
}

export { SearchIcon }

// @public
export const SearchInput: DefineComponent<ExtractPropTypes<    {
maxLength: {
type: NumberConstructor;
default: number;
};
autofocus: {
type: BooleanConstructor;
default: boolean;
};
instant: {
type: BooleanConstructor;
default: boolean;
};
instantDebounceInMs: {
type: NumberConstructor;
default: number;
};
}>, {
query: ComputedRef<string>;
inputElement: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
emitUserHoveredInSearchBox: () => void;
emitUserHoveredOutSearchBox: () => void;
emitUserBlurredSearchBox: () => void;
emitUserClickedSearchBox: () => void;
emitUserFocusedSearchBox: () => void;
emitUserIsTypingAQueryEvents: () => void;
emitUserPressedEnterKey: () => void;
emitUserPressedArrowKey: (event: KeyboardEvent) => void;
preventSpecialKey: (event: InputEvent) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
maxLength: {
type: NumberConstructor;
default: number;
};
autofocus: {
type: BooleanConstructor;
default: boolean;
};
instant: {
type: BooleanConstructor;
default: boolean;
};
instantDebounceInMs: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
maxLength: number;
autofocus: boolean;
instant: boolean;
instantDebounceInMs: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SearchInputPlaceholder: DefineComponent<ExtractPropTypes<    {
messages: {
type: PropType<string[]>;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>;
};
animationIntervalMs: {
type: NumberConstructor;
default: number;
};
animateOnlyOnHover: BooleanConstructor;
}>, {
isVisible: ComputedRef<boolean>;
message: ComputedRef<string | undefined>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
messages: {
type: PropType<string[]>;
required: true;
};
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>;
};
animationIntervalMs: {
type: NumberConstructor;
default: number;
};
animateOnlyOnHover: BooleanConstructor;
}>> & Readonly<{}>, {
animateOnlyOnHover: boolean;
animation: string | Function | Record<string, any>;
animationIntervalMs: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface SearchMutations extends StatusMutations, QueryMutations, ConfigMutations<SearchState> {
    appendResults: (results: Result[]) => void;
    resetState: () => void;
    resetStateForReload: () => void;
    setBanners: (banners: Banner_2[]) => void;
    setDisplayTagging: (DisplayTagging: TaggingRequest) => void;
    setFacets: (facets: Facet[]) => void;
    setFromNoResultsWithFilters: (fromNoResultsWithFilters: boolean) => void;
    setIsAppendResults: (isAppendResults: boolean) => void;
    setIsNoResults: (isNoResults: boolean) => void;
    setOrigin: (origin: QueryOrigin | undefined | null) => void;
    setPage: (page: number) => void;
    setParams: (params: Dictionary<unknown>) => void;
    setPartialResults: (partialResults: PartialResult[]) => void;
    setPromoteds: (promoteds: Promoted_2[]) => void;
    setQueryTagging: (queryTagging: TaggingRequest) => void;
    setRedirections: (redirections: Redirection_2[]) => void;
    setRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setResults: (results: Result[]) => void;
    setSelectedFilters: (selectedFilters: Filter[]) => void;
    // Warning: (ae-forgotten-export) The symbol "Sort" needs to be exported by the entry point index.d.ts
    setSort: (sort: Sort) => void;
    setSpellcheck: (spellcheckedQuery: string) => void;
    setStats: (stats: Stats) => void;
    setTotalResults: (totalResults: number) => void;
    updatePartialResultsFromEnrichment: (enrichmentResults: any[]) => void;
    updateResult: (result: Partial<Result> & Pick<Result, 'id'>) => void;
    updateResultsFromEnrichment: (enrichmentResults: any[]) => void;
}

// @public
export const searchQuery: SearchXStoreModule['getters']['query'];

// @public
export const searchRequest: SearchXStoreModule['getters']['request'];

// @public
export interface SearchState extends StatusState, QueryState {
    banners: Banner_2[];
    config: SearchConfig;
    displayTagging: TaggingRequest;
    facets: Facet[];
    fromNoResultsWithFilters: boolean;
    isAppendResults: boolean;
    isNoResults: boolean;
    origin: QueryOrigin | null;
    page: number;
    params: Dictionary<unknown>;
    partialResults: PartialResult[];
    promoteds: Promoted_2[];
    queryTagging: TaggingRequest;
    redirections: Redirection_2[];
    relatedTags: RelatedTag_2[];
    results: Result[];
    selectedFilters: Dictionary<Filter[]>;
    sort: Sort;
    spellcheckedQuery: string;
    stats: Stats;
    totalResults: number;
}

export { SearchTinyIcon }

// @internal
export const searchWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
        saveOriginWire: AnyWire;
    };
    PartialResultsChanged: {
        fetchAndSavePartialResultsEnrichmentWire: Wire<PartialResult[]>;
    };
    UserAcceptedAQuery: {
        setSearchQuery: Wire<string>;
        saveOriginWire: AnyWire;
    };
    UserAcceptedSpellcheckQuery: {
        resetSpellcheckQuery: AnyWire;
    };
    UserClearedQuery: {
        setSearchQuery: Wire<string>;
        cancelFetchAndSaveSearchResponseWire: AnyWire;
        resetFromNoResultsWithFilters: AnyWire;
        resetIsNoResults: AnyWire;
    };
    UserClickedASort: {
        setSort: Wire<string>;
    };
    UserPickedARelatedTag: {
        saveOriginWire: AnyWire;
    };
    UserReachedResultsListEnd: {
        increasePageAppendingResultsWire: AnyWire;
    };
    SearchRequestUpdated: {
        resetStateIfNoRequestWire: Wire<InternalSearchRequest | null>;
        fetchAndSaveSearchResponseWire: Wire<InternalSearchRequest | null>;
    };
    SearchRequestChanged: {
        resetRequestOnRefinementWire: AnyWire;
    };
    SelectedRelatedTagsChanged: {
        setRelatedTags: Wire<RelatedTag_2[]>;
    };
    SelectedFiltersForRequestChanged: {
        setSelectedFilters: Wire<Filter[]>;
    };
    ResultsChanged: {
        resetAppending: AnyWire;
        fetchAndSaveResultsEnrichmentWire: Wire<Result[]>;
    };
    ReloadSearchRequested: {
        resetStateForReloadWire: AnyWire;
    };
    SelectedSortProvided: {
        setSort: Wire<string>;
    };
    ExtraParamsChanged: {
        setSearchExtraParams: Wire<Dictionary<unknown>>;
    };
    UserClickedCloseX: {
        clearSearchQuery: AnyWire;
    };
    UserClickedOutOfMainModal: {
        clearSearchQuery: AnyWire;
    };
    UserAcceptedAQueryPreview: {
        setSearchQueryFromPreview: AnyWire;
        setSearchExtraParamsFromPreview: AnyWire;
        setSearchSelectedFiltersFromPreview: AnyWire;
        saveOriginWire: AnyWire;
    };
    QueryPreviewUnselected: {
        setSearchExtraParams: Wire<Dictionary<unknown>>;
    };
    UserSelectedAHistoryQuery: {
        setSearchSelectedFiltersFromHistoryQuery: AnyWire;
    };
    UserSelectedAPage: {
        setSearchPage: Wire<number>;
        resetAppending: AnyWire;
    };
};

// @public
export interface SearchXEvents {
    FacetsChanged: Facet[];
    PageChanged: number;
    PartialResultsChanged: PartialResult[];
    ReloadSearchRequested: void;
    ResultsChanged: Result[];
    SearchRequestChanged: InternalSearchRequest | null;
    SearchRequestUpdated: InternalSearchRequest | null;
    SearchResponseChanged: InternalSearchResponse;
    SearchTaggingChanged: TaggingRequest;
    SelectedSortProvided: Sort;
    SortChanged: string;
    SpellcheckChanged: string;
    UserClickedABanner: Banner_2;
    UserClickedAbortARedirection: void;
    UserClickedAPromoted: Promoted_2;
    UserClickedARedirection: Redirection_2;
    UserClickedASort: Sort;
    UserClickedPartialQuery: string;
    UserReachedResultsListEnd: void;
    UserSelectedAPage: number;
}

// @public
export type SearchXModule = XModule<SearchXStoreModule>;

// @public
export const searchXModule: SearchXModule;

// @public
export type SearchXStoreModule = XStoreModule<SearchState, SearchGetters, SearchMutations, SearchActions>;

// @internal
export const searchXStoreModule: SearchXStoreModule;

// @internal
export const SELECT_RESULT_VARIANT_KEY: XInjectKey<(variant: ResultVariant, level?: number) => void>;

// @internal
export const SELECTED_VARIANTS_KEY: XInjectKey<ResultVariant[]>;

// @public
export const SelectedFilters: DefineComponent<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
}>> & Readonly<{}>, {
alwaysVisible: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const selectedFilters: FacetsXStoreModule['getters']['selectedFilters'];

// @public
export const selectedFiltersByFacet: FacetsXStoreModule['getters']['selectedFiltersByFacet'];

// @public
export const SelectedFiltersList: DefineComponent<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>, {
selectedFilters: ComputedRef<Filter[]>;
mapSlot: (selectedFilters: Filter[]) => RenderFilter[];
hasSlot: (name: string) => boolean;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facetsIds: PropType<Array<Facet["id"]>>;
alwaysVisible: BooleanConstructor;
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
alwaysVisible: boolean;
animation: string | Function | Record<string, any>;
}, {}, {
SelectedFilters: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SemanticQueries: DefineComponent<    {}, {
suggestions: ComputedRef<SemanticQuery_2[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
BaseSuggestions: DefineComponent<    {}, {}, any>;
SemanticQuery: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export type SemanticQueriesActionContext = XActionContext<SemanticQueriesState, SemanticQueriesGetters, SemanticQueriesMutations, SemanticQueriesActions>;

// @public
export interface SemanticQueriesActions {
    fetchAndSaveSemanticQuery: (request: SemanticQueriesRequest | null) => void;
    // Warning: (ae-forgotten-export) The symbol "SemanticQueriesResponse" needs to be exported by the entry point index.d.ts
    fetchSemanticQuery: (request: SemanticQueriesRequest | null) => SemanticQueriesResponse | null;
}

// @public
export interface SemanticQueriesConfig {
    maxItemsToRequest: number;
    threshold: number;
}

// @internal
export const semanticQueriesEmitters: {
    SemanticQueryRequestUpdated: (_: SemanticQueriesState, getters: Returns<GettersTree<SemanticQueriesState, SemanticQueriesGetters>>) => SemanticQueriesRequest | null;
    SemanticQueriesResponseChanged: (state: SemanticQueriesState) => SemanticQuery_2[];
};

// @public
export interface SemanticQueriesGetters {
    normalizedQuery: string;
    query: string;
    request: SemanticQueriesRequest | null;
}

// @public
export interface SemanticQueriesMutations extends QueryMutations, ConfigMutations<SemanticQueriesState> {
    setParams: (params: Dictionary<unknown>) => void;
    setSemanticQueries: (semanticQueries: SemanticQuery_2[]) => void;
    setSemanticQueriesRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setTotalResults: (totalResults: number) => void;
}

// @public
export interface SemanticQueriesState extends QueryState {
    config: SemanticQueriesConfig;
    params: Dictionary<unknown>;
    relatedTags: RelatedTag_2[];
    semanticQueries: SemanticQuery_2[];
    totalResults: number;
}

// @internal
export const semanticQueriesWiring: {
    UserClearedQuery: {
        clearQueryWire: AnyWire;
    };
    SemanticQueryRequestUpdated: {
        fetchAndSaveSemanticQueryWire: Wire<SemanticQueriesRequest | null>;
    };
    ExtraParamsChanged: {
        setSemanticQueriesExtraParamsWire: Wire<Dictionary<unknown>>;
    };
    SearchResponseChanged: {
        setQueryFromSearchResponseChangedWire: Wire<InternalSearchResponse>;
        setTotalResultsFromSearchResponseChangedWire: Wire<InternalSearchResponse>;
    };
    SelectedRelatedTagsChanged: {
        setSemanticQueriesRelatedTags: Wire<RelatedTag_2[]>;
    };
};

// @public
export interface SemanticQueriesXEvents {
    SemanticQueriesResponseChanged: SemanticQuery_2[];
    SemanticQueryRequestUpdated: SemanticQueriesRequest | null;
    UserSelectedASemanticQuery: SemanticQuery_2;
}

// @public
export type SemanticQueriesXModule = XModule<SemanticQueriesXStoreModule>;

// @public
export const semanticQueriesXModule: SemanticQueriesXModule;

// @public
export type SemanticQueriesXStoreModule = XStoreModule<SemanticQueriesState, SemanticQueriesGetters, SemanticQueriesMutations, SemanticQueriesActions>;

// @internal
export const semanticQueriesXStoreModule: SemanticQueriesXStoreModule;

// @public
export const SemanticQuery: DefineComponent<ExtractPropTypes<    {
suggestion: {
type: PropType<SemanticQuery_2>;
required: true;
};
}>, {
query: ComputedRef<string>;
suggestionSelectedEvents: {
UserSelectedASemanticQuery: SemanticQuery_2;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
suggestion: {
type: PropType<SemanticQuery_2>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
BaseSuggestion: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const sessionHistoryQueries: HistoryQueriesXStoreModule['getters']['sessionHistoryQueries'];

// @public
export const setAiUrlParams: AiXStoreModule['actions']['setUrlParams'];

// @public
export function setConfig<T extends {
    config: T['config'];
}>(state: T, config: T['config']): void;

// @public
export const setConsent: Wire<boolean>;

// @public
export const setExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setFiltersFromHistoryQueries: AnyWire;

// @public
export const setHistoryQueries: HistoryQueriesXStoreModule['actions']['setHistoryQueries'];

// @public
export const setHistoryQueriesDisabled: AnyWire;

// @public
export const setHistoryQueriesEnabled: AnyWire;

// @public
export const setHistoryQueriesQuery: Wire<string>;

// @public
export const setHistoryQueriesQueryFromPreview: AnyWire;

// @public
export const setIdentifierResultsExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setIdentifierResultsQuery: Wire<string>;

// @public
export const setIdentifierResultsQueryFromPreview: AnyWire;

// @public
export const setInitialExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setName: Wire<string | null>;

// @public
export const setNextQueriesExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setNextQueriesExtraParamsFromPreview: AnyWire;

// @public
export const setNextQueriesQuery: Wire<string>;

// @public
export const setNextQueriesQueryFromPreview: AnyWire;

// @public
export const setNextQueriesRelatedTags: Wire<RelatedTag_2[]>;

// @public
export const setNoResultsTaggingEnabledWire: Wire<keyof XModulesTree>;

// @public
export const setParams: Wire<Partial<UrlParams>>;

// @internal
export const setParamsWire: Wire<Dictionary<unknown>>;

// @public
export const setPendingScrollToWire: AnyWire;

// @public
export const setPopularSearchesExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setQueriesPreviewExtraParamsWire: Wire<Dictionary<unknown>>;

// @public
export function setQuery(state: QueryState, query: string): void;

// @public
export const setQueryFromLastHistoryQuery: NextQueriesXStoreModule['actions']['setQueryFromLastHistoryQuery'];

// @public
export const setQueryFromLastHistoryQueryWire: Wire<HistoryQuery_2[]>;

// @public
export const setQueryFromPreview: AnyWire;

// @public
export const setQueryFromSearchResponseChangedWire: Wire<InternalSearchResponse>;

// @public
export const setQuerySuggestionsExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setQuerySuggestionsExtraParamsFromPreview: AnyWire;

// @public
export const setQuerySuggestionsQuery: Wire<string>;

// @public
export const setQuerySuggestionsQueryFromPreview: AnyWire;

// @public
export const setQueryTaggingFromQueryPreview: Wire<Taggable>;

// @public
export const setQueryTaggingInfo: Wire<TaggingRequest>;

// @public
export const setQueryWire: Wire<string>;

// @public
export const setRecommendationsExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setRelatedTags: Wire<RelatedTag_2[]>;

// @public
export const setRelatedTagsExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setRelatedTagsExtraParamsFromPreview: AnyWire;

// @public
export const setRelatedTagsQuery: Wire<string>;

// @public
export const setRelatedTagsQueryFromPreview: AnyWire;

// @public
export const setScrollDirectionWire: AnyWire;

// @public
export const setScrollHasAlmostReachedEndWire: AnyWire;

// @public
export const setScrollHasReachedEndWire: AnyWire;

// @public
export const setScrollHasReachedStartWire: AnyWire;

// @public
export const setScrollPositionWire: AnyWire;

// @public
export const setSearchedQueries: Wire<HistoryQuery_2[]>;

// @public
export const setSearchedQueriesInPopularSearches: Wire<HistoryQuery_2[]>;

// @public
export const setSearchedQueriesInSuggestions: Wire<HistoryQuery_2[]>;

// @public
export const setSearchExtraParams: Wire<Dictionary<unknown>>;

// @public
export const setSearchExtraParamsFromPreview: AnyWire;

// @public
export const setSearchPage: Wire<number>;

// @public
export const setSearchQuery: Wire<string>;

// @public
export const setSearchQueryFromPreview: AnyWire;

// @public
export const setSearchSelectedFilters: AnyWire;

// @public
export const setSearchSelectedFiltersFromHistoryQuery: AnyWire;

// @public
export const setSearchSelectedFiltersFromPreview: AnyWire;

// @public
export const setSearchUrlParams: SearchXStoreModule['actions']['setUrlParams'];

// @public
export const setSelectedFilters: Wire<Filter[]>;

// @public
export const setSelectedFiltersFromPreview: AnyWire;

// @public
export const setSelectedQueryPreviewWire: Wire<QueryPreviewInfo | null>;

// @public
export const setSemanticQueriesExtraParamsWire: Wire<Dictionary<unknown>>;

// @public
export const setSort: Wire<string>;

// @public
export function setStatus(state: StatusState, status: RequestStatus): void;

// @public
export const setTaggingConfig: Wire<TaggingConfig>;

export { SettingsIcon }

// @public
export const setTotalResultsFromSearchResponseChangedWire: Wire<InternalSearchResponse>;

// @public
export const setTotalResultsWire: Wire<number>;

// @public
export const setUrlFilters: Wire<Filter[]>;

// @public
export const setUrlPage: Wire<number>;

// @public
export const setUrlParams: Wire<UrlParams>;

// @public
export const setUrlParamsFromPreview: AnyWire;

// @public
export const setUrlParamsWire: Wire<UrlParams>;

// @public
export const setUrlPrompt: Wire<number>;

// @public
export const setUrlQuery: Wire<string>;

// @public
export const setUrlQueryFromPreview: AnyWire;

// @public
export const setUrlRelatedTags: Wire<RelatedTag_2[]>;

// @public
export const setUrlScroll: Wire<string>;

// @public
export const setUrlSelectedFiltersFromPreview: AnyWire;

// @public
export const setUrlSort: Wire<string>;

export { ShowIcon }

// @public
export const SimpleFilter: DefineComponent<ExtractPropTypes<    {
filter: {
type: PropType<SimpleFilter_2>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>, {
innerClickEvents: ComputedRef<    {
ColumnsNumberProvided?: number | undefined;
RenderedColumnsNumberChanged?: number | undefined;
SuggestionsDisplayed?: Suggestion[] | undefined;
TogglePanelStateChanged?: boolean | undefined;
UserAcceptedAQuery?: string | undefined;
UserAcceptedSpellcheckQuery?: string | undefined;
UserClickedAResult?: Result | undefined;
UserClickedADisplayResult?: Result | undefined;
UserClickedCloseEventsModal?: void | undefined;
UserClickedCloseModal?: string | undefined;
UserClickedCloseX?: void | undefined;
UserClickedOutOfMainModal?: void | undefined;
UserClickedColumnPicker?: number | undefined;
UserClickedOpenEventsModal?: void | undefined;
UserClickedOpenModal?: string | undefined;
UserClickedOpenX?: void | undefined;
UserClickedOutOfEventsModal?: void | undefined;
UserClickedOutOfModal?: string | undefined;
UserClickedPanelToggleButton?: string | undefined;
UserClickedResultAddToCart?: Result | undefined;
UserClickedAResultRating?: Result | undefined;
UserClickedScrollToTop?: string | undefined;
UserOpenXProgrammatically?: void | undefined;
UserPressedArrowKey?: ArrowKey | undefined;
UserReachedEmpathizeTop?: void | undefined;
UserSelectedAResultVariant?: {
result: Result;
variant: ResultVariant;
level: number;
queryPreviewHash: ComputedRef<string> | null;
} | undefined;
UserSelectedASuggestion?: Suggestion | undefined;
SnippetCallbackExecuted?: {
event: XEvent;
callbackReturn: unknown;
payload: ExtractPayload<XEvent>;
metadata: WireMetadata;
} | undefined;
ModuleRegistered?: keyof XModulesTree | undefined;
DeviceProvided?: string | null | undefined;
EmpathizeClosed?: void | undefined;
EmpathizeOpened?: void | undefined;
UserClosedEmpathize?: void | undefined;
UserChangedExtraParams?: Dictionary<unknown> | undefined;
ExtraParamsChanged?: Dictionary<unknown> | undefined;
ExtraParamsProvided?: Dictionary<unknown> | undefined;
ExtraParamsInitialized?: Dictionary<unknown> | undefined;
FacetsGroupChanged?: FacetsGroup | undefined;
FacetsGroupProvided?: FacetsGroup | undefined;
PreselectedFiltersProvided?: RawFilter[] | undefined;
SelectedFiltersChanged?: Filter[] | undefined;
SelectedFiltersForRequestChanged?: Filter[] | undefined;
UserChangedSelectedFilters?: Filter[] | undefined;
UserClickedAFilter?: Filter | undefined;
UserClickedAHierarchicalFilter?: HierarchicalFilter_2 | undefined;
UserClickedANumberRangeFilter?: NumberRangeFilter_2 | undefined;
UserClickedASimpleFilter: SimpleFilter_2;
UserClickedAllFilter?: [string | number] | undefined;
UserModifiedEditableNumberRangeFilter?: EditableNumberRangeFilter_2 | undefined;
UserClickedClearAllFilters?: Array<Facet["id"]> | undefined;
FacetsQueryChanged?: string | undefined;
HistoryQueriesDisplayed?: HistoryQuery_2[] | undefined;
HistoryQueriesQueryChanged?: string | undefined;
HistoryQueriesStorageKeyChanged?: string | undefined;
SessionHistoryQueriesChanged?: HistoryQuery_2[] | undefined;
UserPressedClearHistoryQueries?: void | undefined;
UserPressedRemoveHistoryQuery?: HistoryQuery_2 | undefined;
UserSelectedAHistoryQuery?: HistoryQuery_2 | undefined;
UserClickedEnableHistoryQueries?: void | undefined;
UserClickedDisableHistoryQueries?: void | undefined;
UserClickedConfirmDisableHistoryQueries?: void | undefined;
UserClickedDismissDisableHistoryQueries?: void | undefined;
IdentifierResultsChanged?: Result[] | undefined;
IdentifierResultsRequestUpdated?: IdentifierResultsRequest | null | undefined;
UserClickedAIdentifierResult?: Result | undefined;
NextQueriesChanged?: NextQuery_2[] | undefined;
NextQueriesDisplayed?: NextQuery_2[] | undefined;
NextQueriesRequestUpdated?: NextQueriesRequest | null | undefined;
UserSelectedANextQuery?: NextQuery_2 | undefined;
NextQueryPreviewMountedHook?: string | undefined;
PopularSearchesRequestUpdated?: PopularSearchesRequest | undefined;
PopularSearchDisplayed?: Suggestion[] | undefined;
UserSelectedAPopularSearch?: Suggestion | undefined;
QueryPreviewRequestUpdated?: SearchRequest | undefined;
UserAcceptedAQueryPreview?: QueryPreviewInfo | undefined;
QueryPreviewUnselected?: Dictionary<unknown> | undefined;
QueryPreviewMounted?: string | undefined;
QueryPreviewUnmounted?: {
queryPreviewHash: string;
cache: boolean;
} | undefined;
QueriesPreviewChanged?: Dictionary<QueryPreviewItem> | undefined;
QueryPreviewResultReceived?: QueryPreviewItem | undefined;
QuerySuggestionsChanged?: Suggestion[] | undefined;
QuerySuggestionsRequestUpdated?: QuerySuggestionsRequest | null | undefined;
UserSelectedAQuerySuggestion?: Suggestion | undefined;
RecommendationsChanged?: Result[] | undefined;
RecommendationsRequestUpdated?: RecommendationsRequest | undefined;
UserClickedARecommendation?: Result | undefined;
RelatedTagsChanged?: RelatedTag_2[] | undefined;
RelatedTagsRequestUpdated?: RelatedTagsRequest | null | undefined;
SelectedRelatedTagsChanged?: RelatedTag_2[] | undefined;
UserDeselectedARelatedTag?: RelatedTag_2 | undefined;
UserPickedARelatedTag?: RelatedTag_2 | undefined;
UserSelectedARelatedTag?: RelatedTag_2 | undefined;
ScrollRestoreSucceeded?: void | undefined;
ScrollRestoreFailed?: void | undefined;
UserAlmostReachedScrollEnd?: boolean | undefined;
UserChangedScrollDirection?: ScrollDirection | undefined;
UserReachedScrollEnd?: boolean | undefined;
UserReachedScrollStart?: boolean | undefined;
UserScrolled?: number | undefined;
UserScrolledToElement?: string | undefined;
SearchBoxQueryChanged?: string | undefined;
UserHoveredInSearchBox?: void | undefined;
UserHoveredOutSearchBox?: void | undefined;
UserBlurredSearchBox?: void | undefined;
UserClearedQuery?: string | undefined;
UserClickedSearchBox?: void | undefined;
UserFocusedSearchBox?: void | undefined;
UserIsTypingAQuery?: string | undefined;
UserPressedClearSearchBoxButton?: void | undefined;
UserPressedEnterKey?: string | undefined;
UserPressedSearchButton?: string | undefined;
UserTalked?: string | undefined;
FacetsChanged?: Facet[] | undefined;
PageChanged?: number | undefined;
PartialResultsChanged?: PartialResult[] | undefined;
ReloadSearchRequested?: void | undefined;
ResultsChanged?: Result[] | undefined;
SearchRequestChanged?: InternalSearchRequest | null | undefined;
SearchRequestUpdated?: InternalSearchRequest | null | undefined;
SearchResponseChanged?: InternalSearchResponse | undefined;
SearchTaggingChanged?: TaggingRequest | undefined;
SortChanged?: string | undefined;
SpellcheckChanged?: string | undefined;
UserClickedASort?: string | undefined;
SelectedSortProvided?: string | undefined;
UserClickedPartialQuery?: string | undefined;
UserReachedResultsListEnd?: void | undefined;
UserClickedARedirection?: Redirection_2 | undefined;
UserClickedAPromoted?: Promoted_2 | undefined;
UserClickedABanner?: Banner_2 | undefined;
UserClickedAbortARedirection?: void | undefined;
UserSelectedAPage?: number | undefined;
SemanticQueryRequestUpdated?: SemanticQueriesRequest | null | undefined;
SemanticQueriesResponseChanged?: SemanticQuery_2[] | undefined;
UserSelectedASemanticQuery?: SemanticQuery_2 | undefined;
ConsentChanged?: boolean | undefined;
ConsentProvided?: boolean | undefined;
PDPIsLoaded?: string | undefined;
ResultURLTrackingEnabled?: string | undefined;
SearchTaggingReceived?: TaggingRequest | undefined;
TrackableElementDisplayed?: Taggable | undefined;
UserClickedPDPAddToCart?: string | undefined;
TaggingConfigProvided?: TaggingConfig | undefined;
ExperienceControlsEventsChanged?: Partial<XEventsTypes> | undefined;
ExperienceControlsRequestUpdated?: ExperienceControlsRequest | null | undefined;
ParamsLoadedFromUrl?: UrlParams | undefined;
ExtraParamsLoadedFromUrl?: Dictionary<unknown> | undefined;
PushableUrlStateUpdated?: UrlParams | undefined;
ReplaceableUrlStateUpdated?: UrlParams | undefined;
RelatedPromptsRequestUpdated?: RelatedPromptsRequest | null | undefined;
SelectedRelatedPromptChanged?: number | undefined;
UserSelectedARelatedPrompt?: number | undefined;
UserSelectedARelatedPromptQuery?: number | undefined;
UserClickedARelatedPromptResult?: Result | undefined;
UserClickedARelatedPromptAdd2Cart?: Result | undefined;
RelatedPromptsResponseChanged?: RelatedPrompt_2[] | undefined;
RelatedPromptsUnmounted?: void | undefined;
ReloadRelatedPromptsRequested?: void | undefined;
AiSuggestionsRequestUpdated?: AiSuggestionsRequest | null | undefined;
AiSuggestionsSearchRequestUpdated?: AiSuggestionsSearchRequest | null | undefined;
AiSuggestionsSearchChanged?: AiSuggestionSearch[] | undefined;
UserClickedAiOverviewExpandButton?: boolean | undefined;
UserClickedAnAiOverviewResult?: Result | undefined;
AiComponentMounted?: void | undefined;
}>;
innerCssClasses: ComputedRef<(string | Dictionary<boolean>)[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filter: {
type: PropType<SimpleFilter_2>;
required: true;
};
clickEvents: PropType<Partial<XEventsTypes>>;
cssClasses: {
type: PropType<(string | Dictionary<boolean>)[]>;
default: () => never[];
};
}>> & Readonly<{}>, {
cssClasses: (string | Dictionary<boolean>)[];
}, {}, {
RenderlessFilter: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @internal
export class SimpleFilterEntity implements FilterEntity {
    constructor(store: Store<RootXStoreState>);
    // Warning: (ae-forgotten-export) The symbol "isSimpleFilter" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static accepts: typeof isSimpleFilter;
    deselect(filterParam: Filter): void;
    select(filterParam: Filter): void;
    // (undocumented)
    protected store: Store<RootXStoreState>;
}

// @public
export type SimpleStateSelector<ReturnType, State extends Dictionary, Getters extends Dictionary> = (state: State, getters: Getters) => ReturnType;

// @internal
export class SingleSelectModifier extends BaseFilterEntityModifier {
    protected getAncestorsIds(filter: HierarchicalFilter_2, ids?: Array<Filter['id']>): Array<Filter['id']>;
    protected getDescendantsIds(filter: HierarchicalFilter_2, ids?: Array<Filter['id']>): Array<Filter['id']>;
    protected getFacetFilters(facetId: Facet['id']): FacetFilter[];
    protected getOtherFilters(filter: FacetFilter): FacetFilter[];
    // Warning: (ae-forgotten-export) The symbol "FacetFilter" needs to be exported by the entry point index.d.ts
    select(filter: FacetFilter): void;
}

// @public
export const SlicedFilters: DefineComponent<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
max: {
type: NumberConstructor;
required: true;
};
buttonClass: StringConstructor;
}>, {
cssClasses: ComputedRef<VueCSSClasses>;
toggleShowMoreFilters: (event: MouseEvent) => void;
showButton: ComputedRef<boolean>;
difference: ComputedRef<number>;
slicedFilters: ComputedRef<Filter[]>;
showMoreFilters: Ref<boolean, boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("click:show-less" | "click:show-more")[], "click:show-less" | "click:show-more", PublicProps, Readonly<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
max: {
type: NumberConstructor;
required: true;
};
buttonClass: StringConstructor;
}>> & Readonly<{
"onClick:show-less"?: ((...args: any[]) => any) | undefined;
"onClick:show-more"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SlidingPanel: DefineComponent<ExtractPropTypes<    {
scrollFactor: {
type: NumberConstructor;
default: number;
};
showButtons: {
type: BooleanConstructor;
default: boolean;
};
resetOnContentChange: {
type: BooleanConstructor;
default: boolean;
};
buttonClass: {
type: PropType<VueCSSClasses>;
};
scrollContainerClass: {
type: PropType<VueCSSClasses>;
};
}>, {
arrivedState: {
left: boolean;
right: boolean;
top: boolean;
bottom: boolean;
};
cssClasses: ComputedRef<    {
'xds:sliding-panel-at-start': boolean;
'xds:sliding-panel-at-end': boolean;
}>;
scrollContainerRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
slotContainerWidth: ShallowRef<number, number>;
xScroll: WritableComputedRef<number, number>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
scrollFactor: {
type: NumberConstructor;
default: number;
};
showButtons: {
type: BooleanConstructor;
default: boolean;
};
resetOnContentChange: {
type: BooleanConstructor;
default: boolean;
};
buttonClass: {
type: PropType<VueCSSClasses>;
};
scrollContainerClass: {
type: PropType<VueCSSClasses>;
};
}>> & Readonly<{}>, {
scrollFactor: number;
showButtons: boolean;
resetOnContentChange: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SnippetCallbacks: DefineComponent<    {}, {
eventListeners: ComputedRef<Partial<{
ColumnsNumberProvided: (payload: number, metadata: WireMetadata) => unknown;
RenderedColumnsNumberChanged: (payload: number, metadata: WireMetadata) => unknown;
SuggestionsDisplayed: (payload: Suggestion[], metadata: WireMetadata) => unknown;
TogglePanelStateChanged: (payload: boolean, metadata: WireMetadata) => unknown;
UserAcceptedAQuery: (payload: string, metadata: WireMetadata) => unknown;
UserAcceptedSpellcheckQuery: (payload: string, metadata: WireMetadata) => unknown;
UserClickedAResult: (payload: Result, metadata: WireMetadata) => unknown;
UserClickedADisplayResult: (payload: Result, metadata: WireMetadata) => unknown;
UserClickedCloseEventsModal: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedCloseModal: (payload: string, metadata: WireMetadata) => unknown;
UserClickedCloseX: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedOutOfMainModal: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedColumnPicker: (payload: number, metadata: WireMetadata) => unknown;
UserClickedOpenEventsModal: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedOpenModal: (payload: string, metadata: WireMetadata) => unknown;
UserClickedOpenX: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedOutOfEventsModal: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedOutOfModal: (payload: string, metadata: WireMetadata) => unknown;
UserClickedPanelToggleButton: (payload: string, metadata: WireMetadata) => unknown;
UserClickedResultAddToCart: (payload: Result, metadata: WireMetadata) => unknown;
UserClickedAResultRating: (payload: Result, metadata: WireMetadata) => unknown;
UserClickedScrollToTop: (payload: string, metadata: WireMetadata) => unknown;
UserOpenXProgrammatically: (payload: undefined, metadata: WireMetadata) => unknown;
UserPressedArrowKey: (payload: ArrowKey, metadata: WireMetadata) => unknown;
UserReachedEmpathizeTop: (payload: undefined, metadata: WireMetadata) => unknown;
UserSelectedAResultVariant: (payload: {
result: Result;
variant: ResultVariant;
level: number;
queryPreviewHash: ComputedRef<string> | null;
}, metadata: WireMetadata) => unknown;
UserSelectedASuggestion: (payload: Suggestion, metadata: WireMetadata) => unknown;
SnippetCallbackExecuted: (payload: {
event: XEvent;
callbackReturn: unknown;
payload: ExtractPayload<XEvent>;
metadata: WireMetadata;
}, metadata: WireMetadata) => unknown;
ModuleRegistered: (payload: keyof XModulesTree, metadata: WireMetadata) => unknown;
DeviceProvided: (payload: string | null, metadata: WireMetadata) => unknown;
EmpathizeClosed: (payload: undefined, metadata: WireMetadata) => unknown;
EmpathizeOpened: (payload: undefined, metadata: WireMetadata) => unknown;
UserClosedEmpathize: (payload: undefined, metadata: WireMetadata) => unknown;
UserChangedExtraParams: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
ExtraParamsChanged: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
ExtraParamsProvided: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
ExtraParamsInitialized: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
FacetsGroupChanged: (payload: FacetsGroup, metadata: WireMetadata) => unknown;
FacetsGroupProvided: (payload: FacetsGroup, metadata: WireMetadata) => unknown;
PreselectedFiltersProvided: (payload: RawFilter[], metadata: WireMetadata) => unknown;
SelectedFiltersChanged: (payload: Filter[], metadata: WireMetadata) => unknown;
SelectedFiltersForRequestChanged: (payload: Filter[], metadata: WireMetadata) => unknown;
UserChangedSelectedFilters: (payload: Filter[], metadata: WireMetadata) => unknown;
UserClickedAFilter: (payload: Filter, metadata: WireMetadata) => unknown;
UserClickedAHierarchicalFilter: (payload: HierarchicalFilter_2, metadata: WireMetadata) => unknown;
UserClickedANumberRangeFilter: (payload: NumberRangeFilter_2, metadata: WireMetadata) => unknown;
UserClickedASimpleFilter: (payload: SimpleFilter_2, metadata: WireMetadata) => unknown;
UserClickedAllFilter: (payload: [string | number], metadata: WireMetadata) => unknown;
UserModifiedEditableNumberRangeFilter: (payload: EditableNumberRangeFilter_2, metadata: WireMetadata) => unknown;
UserClickedClearAllFilters: (payload: (string | number)[] | undefined, metadata: WireMetadata) => unknown;
FacetsQueryChanged: (payload: string, metadata: WireMetadata) => unknown;
HistoryQueriesDisplayed: (payload: HistoryQuery_2[], metadata: WireMetadata) => unknown;
HistoryQueriesQueryChanged: (payload: string, metadata: WireMetadata) => unknown;
HistoryQueriesStorageKeyChanged: (payload: string, metadata: WireMetadata) => unknown;
SessionHistoryQueriesChanged: (payload: HistoryQuery_2[], metadata: WireMetadata) => unknown;
UserPressedClearHistoryQueries: (payload: undefined, metadata: WireMetadata) => unknown;
UserPressedRemoveHistoryQuery: (payload: HistoryQuery_2, metadata: WireMetadata) => unknown;
UserSelectedAHistoryQuery: (payload: HistoryQuery_2, metadata: WireMetadata) => unknown;
UserClickedEnableHistoryQueries: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedDisableHistoryQueries: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedConfirmDisableHistoryQueries: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedDismissDisableHistoryQueries: (payload: undefined, metadata: WireMetadata) => unknown;
IdentifierResultsChanged: (payload: Result[], metadata: WireMetadata) => unknown;
IdentifierResultsRequestUpdated: (payload: IdentifierResultsRequest | null, metadata: WireMetadata) => unknown;
UserClickedAIdentifierResult: (payload: Result, metadata: WireMetadata) => unknown;
NextQueriesChanged: (payload: NextQuery_2[], metadata: WireMetadata) => unknown;
NextQueriesDisplayed: (payload: NextQuery_2[], metadata: WireMetadata) => unknown;
NextQueriesRequestUpdated: (payload: NextQueriesRequest | null, metadata: WireMetadata) => unknown;
UserSelectedANextQuery: (payload: NextQuery_2, metadata: WireMetadata) => unknown;
NextQueryPreviewMountedHook: (payload: string, metadata: WireMetadata) => unknown;
PopularSearchesRequestUpdated: (payload: PopularSearchesRequest, metadata: WireMetadata) => unknown;
PopularSearchDisplayed: (payload: Suggestion[], metadata: WireMetadata) => unknown;
UserSelectedAPopularSearch: (payload: Suggestion, metadata: WireMetadata) => unknown;
QueryPreviewRequestUpdated: (payload: SearchRequest, metadata: WireMetadata) => unknown;
UserAcceptedAQueryPreview: (payload: QueryPreviewInfo, metadata: WireMetadata) => unknown;
QueryPreviewUnselected: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
QueryPreviewMounted: (payload: string, metadata: WireMetadata) => unknown;
QueryPreviewUnmounted: (payload: {
queryPreviewHash: string;
cache: boolean;
}, metadata: WireMetadata) => unknown;
QueriesPreviewChanged: (payload: Dictionary<QueryPreviewItem>, metadata: WireMetadata) => unknown;
QueryPreviewResultReceived: (payload: QueryPreviewItem, metadata: WireMetadata) => unknown;
QuerySuggestionsChanged: (payload: Suggestion[], metadata: WireMetadata) => unknown;
QuerySuggestionsRequestUpdated: (payload: QuerySuggestionsRequest | null, metadata: WireMetadata) => unknown;
UserSelectedAQuerySuggestion: (payload: Suggestion, metadata: WireMetadata) => unknown;
RecommendationsChanged: (payload: Result[], metadata: WireMetadata) => unknown;
RecommendationsRequestUpdated: (payload: RecommendationsRequest, metadata: WireMetadata) => unknown;
UserClickedARecommendation: (payload: Result, metadata: WireMetadata) => unknown;
RelatedTagsChanged: (payload: RelatedTag_2[], metadata: WireMetadata) => unknown;
RelatedTagsRequestUpdated: (payload: RelatedTagsRequest | null, metadata: WireMetadata) => unknown;
SelectedRelatedTagsChanged: (payload: RelatedTag_2[], metadata: WireMetadata) => unknown;
UserDeselectedARelatedTag: (payload: RelatedTag_2, metadata: WireMetadata) => unknown;
UserPickedARelatedTag: (payload: RelatedTag_2, metadata: WireMetadata) => unknown;
UserSelectedARelatedTag: (payload: RelatedTag_2, metadata: WireMetadata) => unknown;
ScrollRestoreSucceeded: (payload: undefined, metadata: WireMetadata) => unknown;
ScrollRestoreFailed: (payload: undefined, metadata: WireMetadata) => unknown;
UserAlmostReachedScrollEnd: (payload: boolean, metadata: WireMetadata) => unknown;
UserChangedScrollDirection: (payload: ScrollDirection, metadata: WireMetadata) => unknown;
UserReachedScrollEnd: (payload: boolean, metadata: WireMetadata) => unknown;
UserReachedScrollStart: (payload: boolean, metadata: WireMetadata) => unknown;
UserScrolled: (payload: number, metadata: WireMetadata) => unknown;
UserScrolledToElement: (payload: string, metadata: WireMetadata) => unknown;
SearchBoxQueryChanged: (payload: string, metadata: WireMetadata) => unknown;
UserHoveredInSearchBox: (payload: undefined, metadata: WireMetadata) => unknown;
UserHoveredOutSearchBox: (payload: undefined, metadata: WireMetadata) => unknown;
UserBlurredSearchBox: (payload: undefined, metadata: WireMetadata) => unknown;
UserClearedQuery: (payload: string, metadata: WireMetadata) => unknown;
UserClickedSearchBox: (payload: undefined, metadata: WireMetadata) => unknown;
UserFocusedSearchBox: (payload: undefined, metadata: WireMetadata) => unknown;
UserIsTypingAQuery: (payload: string, metadata: WireMetadata) => unknown;
UserPressedClearSearchBoxButton: (payload: undefined, metadata: WireMetadata) => unknown;
UserPressedEnterKey: (payload: string, metadata: WireMetadata) => unknown;
UserPressedSearchButton: (payload: string, metadata: WireMetadata) => unknown;
UserTalked: (payload: string, metadata: WireMetadata) => unknown;
FacetsChanged: (payload: Facet[], metadata: WireMetadata) => unknown;
PageChanged: (payload: number, metadata: WireMetadata) => unknown;
PartialResultsChanged: (payload: PartialResult[], metadata: WireMetadata) => unknown;
ReloadSearchRequested: (payload: undefined, metadata: WireMetadata) => unknown;
ResultsChanged: (payload: Result[], metadata: WireMetadata) => unknown;
SearchRequestChanged: (payload: InternalSearchRequest | null, metadata: WireMetadata) => unknown;
SearchRequestUpdated: (payload: InternalSearchRequest | null, metadata: WireMetadata) => unknown;
SearchResponseChanged: (payload: InternalSearchResponse, metadata: WireMetadata) => unknown;
SearchTaggingChanged: (payload: TaggingRequest, metadata: WireMetadata) => unknown;
SortChanged: (payload: string, metadata: WireMetadata) => unknown;
SpellcheckChanged: (payload: string, metadata: WireMetadata) => unknown;
UserClickedASort: (payload: string, metadata: WireMetadata) => unknown;
SelectedSortProvided: (payload: string, metadata: WireMetadata) => unknown;
UserClickedPartialQuery: (payload: string, metadata: WireMetadata) => unknown;
UserReachedResultsListEnd: (payload: undefined, metadata: WireMetadata) => unknown;
UserClickedARedirection: (payload: Redirection_2, metadata: WireMetadata) => unknown;
UserClickedAPromoted: (payload: Promoted_2, metadata: WireMetadata) => unknown;
UserClickedABanner: (payload: Banner_2, metadata: WireMetadata) => unknown;
UserClickedAbortARedirection: (payload: undefined, metadata: WireMetadata) => unknown;
UserSelectedAPage: (payload: number, metadata: WireMetadata) => unknown;
SemanticQueryRequestUpdated: (payload: SemanticQueriesRequest | null, metadata: WireMetadata) => unknown;
SemanticQueriesResponseChanged: (payload: SemanticQuery_2[], metadata: WireMetadata) => unknown;
UserSelectedASemanticQuery: (payload: SemanticQuery_2, metadata: WireMetadata) => unknown;
ConsentChanged: (payload: boolean, metadata: WireMetadata) => unknown;
ConsentProvided: (payload: boolean, metadata: WireMetadata) => unknown;
PDPIsLoaded: (payload: string, metadata: WireMetadata) => unknown;
ResultURLTrackingEnabled: (payload: string, metadata: WireMetadata) => unknown;
SearchTaggingReceived: (payload: TaggingRequest, metadata: WireMetadata) => unknown;
TrackableElementDisplayed: (payload: Taggable, metadata: WireMetadata) => unknown;
UserClickedPDPAddToCart: (payload: string | undefined, metadata: WireMetadata) => unknown;
TaggingConfigProvided: (payload: TaggingConfig, metadata: WireMetadata) => unknown;
ExperienceControlsEventsChanged: (payload: Partial<XEventsTypes>, metadata: WireMetadata) => unknown;
ExperienceControlsRequestUpdated: (payload: ExperienceControlsRequest | null, metadata: WireMetadata) => unknown;
ParamsLoadedFromUrl: (payload: UrlParams, metadata: WireMetadata) => unknown;
ExtraParamsLoadedFromUrl: (payload: Dictionary<unknown>, metadata: WireMetadata) => unknown;
PushableUrlStateUpdated: (payload: UrlParams, metadata: WireMetadata) => unknown;
ReplaceableUrlStateUpdated: (payload: UrlParams, metadata: WireMetadata) => unknown;
RelatedPromptsRequestUpdated: (payload: RelatedPromptsRequest | null, metadata: WireMetadata) => unknown;
SelectedRelatedPromptChanged: (payload: number, metadata: WireMetadata) => unknown;
UserSelectedARelatedPrompt: (payload: number, metadata: WireMetadata) => unknown;
UserSelectedARelatedPromptQuery: (payload: number, metadata: WireMetadata) => unknown;
UserClickedARelatedPromptResult: (payload: Result, metadata: WireMetadata) => unknown;
UserClickedARelatedPromptAdd2Cart: (payload: Result, metadata: WireMetadata) => unknown;
RelatedPromptsResponseChanged: (payload: RelatedPrompt_2[], metadata: WireMetadata) => unknown;
RelatedPromptsUnmounted: (payload: undefined, metadata: WireMetadata) => unknown;
ReloadRelatedPromptsRequested: (payload: undefined, metadata: WireMetadata) => unknown;
AiSuggestionsRequestUpdated: (payload: AiSuggestionsRequest | null, metadata: WireMetadata) => unknown;
AiSuggestionsSearchRequestUpdated: (payload: AiSuggestionsSearchRequest | null, metadata: WireMetadata) => unknown;
AiSuggestionsSearchChanged: (payload: AiSuggestionSearch[], metadata: WireMetadata) => unknown;
UserClickedAiOverviewExpandButton: (payload: boolean, metadata: WireMetadata) => unknown;
UserClickedAnAiOverviewResult: (payload: Result, metadata: WireMetadata) => unknown;
AiComponentMounted: (payload: undefined, metadata: WireMetadata) => unknown;
}>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
GlobalXBus: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface SnippetConfig {
    [extra: string]: unknown;
    callbacks?: XEventListeners;
    consent?: boolean;
    currency?: string;
    documentDirection?: DocumentDirection;
    env?: 'staging';
    filters?: string[];
    instance: string;
    isSpa?: boolean;
    lang: string;
    productId?: string;
    queriesPreview?: QueryPreviewInfo[];
    scope: string;
    uiLang?: string;
}

// @public (undocumented)
export const SnippetConfigExtraParams: DefineComponent<ExtractPropTypes<    {
values: {
type: PropType<Dictionary<unknown>>;
};
excludedExtraParams: {
type: PropType<Array<keyof SnippetConfig>>;
default: () => Array<keyof SnippetConfig>;
};
}>, {
extraParams: Ref<Record<string, any>, Record<string, any>>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
values: {
type: PropType<Dictionary<unknown>>;
};
excludedExtraParams: {
type: PropType<Array<keyof SnippetConfig>>;
default: () => Array<keyof SnippetConfig>;
};
}>> & Readonly<{}>, {
excludedExtraParams: (keyof SnippetConfig)[];
}, {}, {
ExtraParams: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export { SortAZIcon }

// @public
export const SortDropdown: DefineComponent<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: PropType<string | Component>;
}>, {
emitUserClickedASort: (sort: Sort) => void;
rootRef: Ref<DefineComponent<    {}, {}, any> | undefined, DefineComponent<    {}, {}, any> | undefined>;
selectedSort: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: PropType<string | Component>;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
BaseDropdown: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SortedFilters: DefineComponent<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
}>, () => "" | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
filters: PropType<Filter[]>;
parentId: {
type: PropType<Filter["id"]>;
required: false;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SortList: DefineComponent<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: {
type: PropType<string | Component>;
default: () => string;
};
}>, {
listItems: ComputedRef<SortListItem[]>;
selectedSort: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: {
type: PropType<string | Component>;
default: () => string;
};
}>> & Readonly<{}>, {
animation: string | Component;
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SortPickerList: DefineComponent<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: {
type: PropType<string | Component>;
default: () => string;
};
buttonClass: StringConstructor;
}>, {
listItems: ComputedRef<SortPickerItem[]>;
selectedSort: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: PropType<Sort[]>;
required: true;
};
animation: {
type: PropType<string | Component>;
default: () => string;
};
buttonClass: StringConstructor;
}>> & Readonly<{}>, {
animation: string | Component;
}, {}, {
BaseEventButton: DefineComponent<    {}, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export { SortPriceDownIcon }

export { SortPriceUpIcon }

export { SortRelevancyIcon }

export { SortZAIcon }

// @public
export interface SpatialNavigation {
    navigateTo: (direction: ArrowKey) => HTMLElement;
}

// @public
export const Spellcheck: DefineComponent<    {}, {
query: ComputedRef<string>;
spellcheckedQuery: ComputedRef<string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export const SpellcheckButton: DefineComponent<    {}, {
el: Ref<HTMLElement | undefined, HTMLElement | undefined>;
spellcheckedQuery: ComputedRef<string>;
emitEvents: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { SpinnerIcon }

// @public
export const SPLIT_WORDS_REGEX: RegExp;

// @public
export const StaggeredFadeAndSlide: DefineComponent<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
tag: {
type: StringConstructor;
default: string;
};
stagger: {
type: NumberConstructor;
default: number;
};
}>, {
name: ComputedRef<string>;
onEnter: (el: Element, done: () => void) => void;
onAfterEnter: (el: Element) => void;
transitionDurationInMs: string;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
appear: {
type: BooleanConstructor;
default: boolean;
};
tag: {
type: StringConstructor;
default: string;
};
stagger: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
appear: boolean;
tag: string;
stagger: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { StarFilledIcon }

export { StarIcon }

// @public
export interface StateSelector<ReturnType, State extends Dictionary, Getters extends Dictionary> extends WatchOptions {
    filter?: (newValue: ReturnType, oldValue: ReturnType, state: State) => boolean;
    // (undocumented)
    metadata?: Partial<WireMetadata>;
    // (undocumented)
    selector: SimpleStateSelector<ReturnType, State, Getters>;
}

// @public
export interface StatusMutations {
    setStatus: (status: RequestStatus) => void;
}

// @public
export interface StatusState {
    status: RequestStatus;
}

// Warning: (ae-forgotten-export) The symbol "Metadata" needs to be exported by the entry point index.d.ts
//
// @internal
export class StickyModifier extends BaseFilterEntityModifier<Metadata> {
    deselect(filter: Filter, metadata?: Metadata): void;
    select(filter: Filter): void;
}

// @public
export const storageKey: HistoryQueriesXStoreModule['getters']['storageKey'];

// @public
export type StoreEmitters<StoreModule extends AnyXStoreModule> = {
    [Event in XEvent]?: SimpleStateSelector<XEventPayload<Event>, ReturnType<StoreModule['state']>, Returns<StoreModule['getters']>> | StateSelector<XEventPayload<Event>, ReturnType<StoreModule['state']>, Returns<StoreModule['getters']>>;
};

// @public
export interface StoreModuleStateAndGetters<ModuleName extends XModuleName> {
    // (undocumented)
    getters: ExtractGetters<ModuleName>;
    // (undocumented)
    state: ExtractState<ModuleName>;
}

// @public
export interface SubjectPayload<SomePayload, SomeEventMetadata extends Dictionary> {
    eventPayload: SomePayload;
    metadata: SomeEventMetadata;
}

// @public
export type SubObject<SomeObject, TargetPropertyType> = {
    [Key in keyof SomeObject as SomeObject[Key] extends TargetPropertyType ? Key : never]: TargetPropertyType & SomeObject[Key];
};

export { TagFilledIcon }

// @public
export const Tagging: DefineComponent<ExtractPropTypes<    {
storageTTLMs: {
type: NumberConstructor;
default: number;
};
storageKey: {
type: StringConstructor;
default: string;
};
sessionTTLMs: NumberConstructor;
queryTaggingDebounceMs: {
type: NumberConstructor;
default: number;
};
consent: {
type: BooleanConstructor;
default: null;
};
}>, () => void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
storageTTLMs: {
type: NumberConstructor;
default: number;
};
storageKey: {
type: StringConstructor;
default: string;
};
sessionTTLMs: NumberConstructor;
queryTaggingDebounceMs: {
type: NumberConstructor;
default: number;
};
consent: {
type: BooleanConstructor;
default: null;
};
}>> & Readonly<{}>, {
storageTTLMs: number;
storageKey: string;
queryTaggingDebounceMs: number;
consent: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface TaggingActions {
    track: (tagging: TaggingRequest | TaggingRequest[]) => void;
}

// @public
export interface TaggingConfig {
    queryTaggingDebounceMs: number;
    sessionTTLMs: number;
    storageKey: string | null;
    storageTTLMs: number | null;
}

// @internal
export const taggingEmitters: {
    ConsentChanged: (state: TaggingState) => boolean;
    SearchTaggingReceived: (state: TaggingState) => TaggingRequest;
    ResultURLTrackingEnabled: {
        selector: (state: TaggingState) => string;
        filter: (newValue: string) => newValue is "url";
    };
};

// @public
export interface TaggingGetters {
}

// @public
export interface TaggingMutations extends ConfigMutations<TaggingState> {
    setConsent: (consent: boolean) => void;
    setNoResultsTaggingEnabled: (module: XModuleName) => void;
    setQueryTaggingInfo: (queryTaggingInfo: TaggingRequest) => void;
}

// @public
export interface TaggingState {
    config: TaggingConfig;
    consent: boolean | null;
    noResultsTaggingEnabled: boolean;
    queryTaggingInfo: TaggingRequest | null;
}

// @internal
export const taggingWiring: {
    ConsentProvided: {
        setConsent: Wire<boolean>;
    };
    ConsentChanged: {
        clearSessionWire: Wire<any>;
    };
    PDPIsLoaded: {
        moveClickedResultToSessionWire: Wire<string>;
    };
    ResultURLTrackingEnabled: {
        moveClickedResultToSessionWire: Wire<string>;
    };
    SearchTaggingChanged: {
        setQueryTaggingInfo: Wire<TaggingRequest>;
    };
    SearchTaggingReceived: {
        trackQueryWire: Wire<TaggingRequest | TaggingRequest[]>;
    };
    TrackableElementDisplayed: {
        trackElementDisplayedWire: Wire<Taggable>;
    };
    TaggingConfigProvided: {
        setTaggingConfig: Wire<TaggingConfig>;
    };
    UserClickedAResult: {
        trackResultClickedWire: Wire<Taggable>;
        storeClickedResultWire: Wire<Result>;
    };
    UserClickedResultAddToCart: {
        trackAddToCartWire: Wire<Taggable>;
        trackResultClickedWire: Wire<Taggable>;
        storeAddToCartWire: Wire<Result>;
    };
    UserClickedPDPAddToCart: {
        trackAddToCartFromSessionStorage: Wire<string | undefined>;
    };
    UserClickedABanner: {
        trackBannerClickedWire: Wire<Taggable>;
    };
    UserClickedAPromoted: {
        trackPromotedClickedWire: Wire<Taggable>;
    };
    UserClickedADisplayResult: {
        trackDisplayClickedWire: Wire<Taggable>;
        setQueryTaggingFromQueryPreview: Wire<Taggable>;
    };
    SemanticQueriesResponseChanged: {
        trackNoResultsQueryWithFallbackWireDebounced: Wire<any>;
    };
    RelatedPromptsResponseChanged: {
        trackNoResultsQueryWithFallbackWireDebounced: Wire<any>;
    };
    ModuleRegistered: {
        setNoResultsTaggingEnabledWire: Wire<keyof XModulesTree>;
    };
    UserClickedARelatedPromptResult: {
        trackToolingDisplayClickedWire: Wire<Taggable>;
    };
    UserClickedARelatedPromptAdd2Cart: {
        trackToolingAdd2CartWire: Wire<Taggable>;
    };
    UserSelectedARelatedPrompt: {
        trackRelatedPromptToolingDisplayClickWire: Wire<any>;
    };
    AiSuggestionsSearchChanged: {
        trackAiSuggestionsSearchWire: AnyWire;
    };
    UserClickedAnAiOverviewResult: {
        trackToolingDisplayClickedWire: Wire<Taggable>;
    };
    UserClickedAnAiOverviewAdd2Cart: {
        trackToolingAdd2CartWire: Wire<Taggable>;
    };
};

// @public
export interface TaggingXEvents {
    ConsentChanged: boolean;
    ConsentProvided: boolean;
    PDPIsLoaded: string;
    ResultURLTrackingEnabled: string;
    SearchTaggingReceived: TaggingRequest;
    TaggingConfigProvided: TaggingConfig;
    TrackableElementDisplayed: Taggable;
    UserClickedPDPAddToCart: string | undefined;
}

// @public
export type TaggingXModule = XModule<TaggingXStoreModule>;

// @public
export const taggingXModule: TaggingXModule;

// @public
export type TaggingXStoreModule = XStoreModule<TaggingState, TaggingGetters, TaggingMutations, TaggingActions>;

// @internal
export const taggingXStoreModule: TaggingXStoreModule;

export { TagIcon }

// @public
export interface TakeNavigationControl {
    // (undocumented)
    direction: ArrowKey;
    // (undocumented)
    moduleName: XModuleName;
    // (undocumented)
    xEvent: PropsWithType<XEventsTypes, ArrowKey>;
}

// @public
export function throttle<Payload>(wire: Wire<Payload>, timeInMs: TimeSelector | number, options?: TimedWireOperatorOptions): Wire<Payload>;

// @public
export interface ThrottleFunction<Params extends any[]> {
    // (undocumented)
    (...args: Params): void;
}

// @public
export const throttleFunction: <Params extends any[]>(fn: (...args: Params) => void, throttleTimeMs: number) => ThrottleFunction<Params>;

// @public
export interface TimedWireOperatorOptions {
    cancelOn?: MaybeArray<XEvent>;
    forceOn?: MaybeArray<XEvent>;
}

// @public
export type TimeSelector = (storeModule: Store<RootXStoreState>) => number;

// @public
export const toggleRelatedTag: RelatedTagsXStoreModule['actions']['toggleRelatedTag'];

// @public
export const toggleRelatedTagWire: Wire<RelatedTag_2>;

// @public
export function toKebabCase(str: string): string;

// @public
export const track: TaggingXStoreModule['actions']['track'];

// @public
export const trackAddToCartWire: Wire<Taggable>;

// @public
export const trackAiSuggestionsSearchWire: AnyWire;

// @public
export const trackBannerClickedWire: Wire<Taggable>;

// @public
export const trackDisplayClickedWire: Wire<Taggable>;

// @public
export const trackElementDisplayedWire: Wire<Taggable>;

// @public
export const trackNoResultsQueryWithFallbackWire: Wire<any>;

// @public
export const trackNoResultsQueryWithFallbackWireDebounced: Wire<any>;

// @public @deprecated
export const trackNoResultsQueryWithSemanticsWire: Wire<any>;

// @public @deprecated
export const trackNoResultsQueryWithSemanticsWireDebounced: Wire<any>;

// @public
export const trackPromotedClickedWire: Wire<Taggable>;

// @public
export const trackQueryWire: Wire<TaggingRequest | TaggingRequest[]>;

// @public
export const trackRelatedPromptToolingDisplayClickWire: Wire<any>;

// @public
export const trackResultClickedWire: Wire<Taggable>;

// @public
export const trackToolingAdd2CartWire: Wire<Taggable>;

// @public
export const trackToolingDisplayClickedWire: Wire<Taggable>;

// @internal
export type TransitionStates<SomeStatus extends string, SomeEvent extends string> = {
    [Key in SomeStatus]: Partial<Record<SomeEvent, SomeStatus>>;
};

export { TrashIcon }

export { TrashOpenIcon }

export { TrendingIcon }

export { TrendingTinyIcon }

// @public
export const typing: Directive<TypingHTMLElement, TypingOptions>;

// @public
export interface TypingHTMLElement extends HTMLElement {
    // (undocumented)
    __timeoutId?: number;
}

// @public
export interface TypingOptions {
    speed?: number;
    targetAttr?: string;
    text: string;
}

// @public
export const updateHistoryQueriesWithSearchResponse: Wire<InternalSearchResponse>;

// @public
export type UrlActionContext = XActionContext<UrlState, UrlGetters, UrlMutations, UrlActions>;

// @public
export interface UrlActions {
}

// @internal
export const urlEmitters: {
    PushableUrlStateUpdated: {
        selector: (_: UrlState, getters: Returns<GettersTree<UrlState, UrlGetters>>) => UrlParams;
        filter: typeof shouldPushUrl;
        metadata: {
            replaceable: false;
        };
    };
    ReplaceableUrlStateUpdated: {
        selector: (_: UrlState, getters: Returns<GettersTree<UrlState, UrlGetters>>) => UrlParams;
        filter: typeof shouldReplaceUrl;
        metadata: {
            replaceable: false;
        };
    };
};

// @public
export interface UrlGetters {
    urlParams: UrlParams;
}

// @public
export const UrlHandler: DefineComponent<    {}, {
onPageShow: (event: PageTransitionEvent) => void;
emitEvents: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
GlobalEvents: new () => {
$props: VNodeProps & GlobalEventsProps;
};
}, {}, string, ComponentProvideOptions, true, {}, any>;

// @public
export interface UrlMutations extends QueryMutations {
    setFilters: (filters: Filter[]) => void;
    setInitialExtraParams: (extraParams: Dictionary<unknown>) => void;
    setPage: (page: number) => void;
    setParams: (params: Partial<UrlParams>) => void;
    setPrompt: (prompt: number) => void;
    setRelatedTags: (relatedTags: RelatedTag_2[]) => void;
    setScroll: (scroll: string) => void;
    setSort: (sort: string) => void;
}

// @public
export type UrlParamKey = Extract<keyof UrlParams, string>;

// @public
export interface UrlParams {
    // (undocumented)
    [extraParamKey: string]: unknown;
    // (undocumented)
    filter: string[];
    // (undocumented)
    page: number;
    // (undocumented)
    prompt: number;
    // (undocumented)
    query: string;
    // (undocumented)
    scroll: string;
    // (undocumented)
    sort: string;
    // (undocumented)
    tag: string[];
}

// @public
export type UrlParamValue = string | number | boolean | Array<string | number | boolean>;

// @public
export interface UrlState extends QueryState, UrlParams {
    // (undocumented)
    initialExtraParams: Dictionary<unknown>;
}

// @internal
export const urlWiring: {
    ParamsLoadedFromUrl: {
        setParams: Wire<Partial<UrlParams>>;
    };
    UserAcceptedAQuery: {
        setUrlQuery: Wire<string>;
    };
    UserAcceptedAQueryPreview: {
        setUrlQueryFromPreview: AnyWire;
        setUrlParamsFromPreview: AnyWire;
        setUrlSelectedFiltersFromPreview: AnyWire;
    };
    UserClearedQuery: {
        setUrlQuery: Wire<string>;
    };
    SelectedRelatedTagsChanged: {
        setUrlRelatedTags: Wire<RelatedTag_2[]>;
    };
    SelectedRelatedPromptChanged: {
        setUrlPrompt: Wire<number>;
    };
    SelectedFiltersForRequestChanged: {
        setUrlFilters: Wire<Filter[]>;
    };
    PageChanged: {
        setUrlPage: Wire<number>;
    };
    SortChanged: {
        setUrlSort: Wire<string>;
    };
    ExtraParamsChanged: {
        setParams: Wire<Partial<UrlParams>>;
    };
    ExtraParamsInitialized: {
        setInitialExtraParams: Wire<Dictionary<unknown>>;
    };
    UserScrolledToElement: {
        setUrlScroll: Wire<string>;
    };
};

// @public
export interface UrlXEvents {
    ExtraParamsLoadedFromUrl: Dictionary<unknown>;
    ParamsLoadedFromUrl: UrlParams;
    PushableUrlStateUpdated: UrlParams;
    ReplaceableUrlStateUpdated: UrlParams;
}

// @public
export type UrlXModule = XModule<UrlXStoreModule>;

// @public
export const urlXModule: UrlXModule;

// @public
export type UrlXStoreModule = XStoreModule<UrlState, UrlGetters, UrlMutations, UrlActions>;

// @internal
export const urlXStoreModule: UrlXStoreModule;

// @public
export function use$x(): UseAliasAPI & {
    on: <Event extends XEvent, Metadata extends boolean>(event: Event, withMetadata: Metadata) => {
        subscribe: (callback: (payload: Metadata extends true ? SubjectPayload<EventPayload<XEventsTypes, Event>, WireMetadata> : EventPayload<XEventsTypes, Event>) => void) => void;
    };
    emit: <Event extends XEvent>(event: Event, payload?: XEventPayload<Event>, metadata?: Omit<WireMetadata, "moduleName">) => Promise<EmittedData<XEventsTypes, Event, WireMetadata>>;
};

// @public
export interface UseAliasAPI {
    readonly device: string | null;
    readonly facets: Record<Facet['id'], Facet>;
    readonly fromNoResultsWithFilters: Readonly<boolean>;
    readonly fullHistoryQueries: ReadonlyArray<HistoryQuery_2>;
    readonly fullQuerySuggestions: ReadonlyArray<Suggestion>;
    readonly historyQueries: ReadonlyArray<HistoryQuery_2>;
    readonly historyQueriesWithResults: ReadonlyArray<HistoryQuery_2>;
    readonly identifierResults: ReadonlyArray<Result>;
    readonly isEmpathizeOpen: boolean;
    readonly isHistoryQueriesEnabled: Readonly<boolean>;
    readonly nextQueries: ReadonlyArray<NextQuery_2>;
    readonly noResults: boolean;
    readonly partialResults: ReadonlyArray<PartialResult>;
    readonly popularSearches: ReadonlyArray<Suggestion>;
    readonly priceStats: {
        min: number;
        max: number;
    };
    readonly query: UseAliasQueryAPI;
    readonly querySuggestions: ReadonlyArray<Suggestion>;
    readonly recommendations: ReadonlyArray<Result>;
    readonly redirections: ReadonlyArray<Redirection_2>;
    readonly relatedTags: ReadonlyArray<RelatedTag_2>;
    readonly results: ReadonlyArray<Result>;
    readonly scroll: Record<string, ScrollComponentState>;
    // Warning: (ae-incompatible-release-tags) The symbol "searchBoxStatus" is marked as @public, but its signature references "InputStatus" which is marked as @internal
    readonly searchBoxStatus: InputStatus | undefined;
    readonly selectedFilters: Filter[];
    readonly selectedRelatedTags: ReadonlyArray<RelatedTag_2>;
    readonly selectedSort: string;
    readonly semanticQueries: ReadonlyArray<SemanticQuery_2>;
    readonly spellcheckedQuery: string | null;
    readonly status: UseAliasStatusAPI;
    readonly totalResults: number;
}

// @internal
export function useAliasApi(): UseAliasAPI;

// @public
export interface UseAliasQueryAPI {
    readonly facets: string;
    readonly nextQueries: string;
    readonly querySuggestions: string;
    readonly relatedTags: string;
    readonly search: string;
    readonly searchBox: string;
}

// @public
export interface UseAliasStatusAPI {
    readonly identifierResults: RequestStatus | undefined;
    readonly nextQueries: RequestStatus | undefined;
    readonly popularSearches: RequestStatus | undefined;
    readonly querySuggestions: RequestStatus | undefined;
    readonly recommendations: RequestStatus | undefined;
    readonly relatedTags: RequestStatus | undefined;
    readonly search: RequestStatus | undefined;
}

// Warning: (ae-forgotten-export) The symbol "AnimatedProperty" needs to be exported by the entry point index.d.ts
//
// @public
export function useCollapseAnimation(property: AnimatedProperty): {
    expand: (element: Element) => void;
    cleanUpAnimationStyles: (element: Element) => void;
    collapse: (element: Element) => void;
};

// @public
export function useDebounce<Params extends any[]>(fn: (...args: Params) => void, debounceTimeInMs: number, debounceOptions?: DebounceOptions): DebouncedFunction<Params>;

// @public
export type UseDeviceFlags<Device extends string> = Record<`is${Capitalize<Device>}`, Ref<boolean>> & Record<`is${Capitalize<Device>}OrGreater`, Ref<boolean>> & Record<`is${Capitalize<Device>}OrLess`, Ref<boolean>>;

// @public
export type UseDeviceReturn<Device extends string = string> = {
    orientation: Ref<'landscape' | 'portrait' | undefined>;
    isTouchable: Ref<boolean>;
    deviceName: Ref<string>;
} & UseDeviceFlags<Device>;

// @public
export function useDisableAnimation(animationName: string): {
    name: ComputedRef<string>;
};

// Warning: (ae-forgotten-export) The symbol "UseEmitDisplayEventOptions" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "UseOnDisplayReturn" needs to be exported by the entry point index.d.ts
//
// @public
export function useEmitDisplayEvent(input: UseEmitDisplayEventOptions): UseOnDisplayReturn;

// @public
export function useFacets(props: {
    facetsIds?: Array<Facet['id']>;
    alwaysVisible?: boolean;
}): {
    selectedFiltersByFacet: ComputedRef<FiltersByFacet>;
    selectedFilters: ComputedRef<Filter[]>;
    hasSelectedFilters: ComputedRef<boolean>;
    isVisible: ComputedRef<boolean>;
};

// @public
export function useFiltersInjection(props: {
    filters?: Filter[];
    parentId?: Filter['id'];
}): ComputedRef<Filter[]>;

// Warning: (ae-forgotten-export) The symbol "UseGetter" needs to be exported by the entry point index.d.ts
//
// @public
export const useGetter: UseGetter;

// Warning: (ae-forgotten-export) The symbol "UseOnDisplayOptions" needs to be exported by the entry point index.d.ts
//
// @public
export function useOnDisplay(input: UseOnDisplayOptions): UseOnDisplayReturn;

// Warning: (ae-forgotten-export) The symbol "UseQueriesPreview" needs to be exported by the entry point index.d.ts
//
// @public
export const useQueriesPreview: () => UseQueriesPreview;

export { UserFilledIcon }

export { UserIcon }

// @public
export function useScroll(props: {
    distanceToBottom: number;
    firstElementThresholdPx: number;
    throttleMs: number;
    resetOnChange: boolean;
    resetOn: XEvent | XEvent[];
}, input: SetupContext<any>, scrollEl: Ref<HTMLElement | undefined>): {
    throttledStoreScrollData: ComputedRef<ThrottleFunction<[]>>;
};

// @public
export function useState<Module extends XModuleName, State = ExtractState<Module>>(module: Module): {
    [P in keyof State]: ComputedRef<State[P]>;
};

// @public
export function useXBus(): {
    on: <Event extends XEvent, Metadata extends boolean>(event: Event, withMetadata: Metadata) => {
        subscribe: (callback: (payload: Metadata extends true ? SubjectPayload<EventPayload<XEventsTypes, Event>, WireMetadata> : EventPayload<XEventsTypes, Event>) => void) => void;
    };
    emit: <Event extends XEvent>(event: Event, payload?: XEventPayload<Event>, metadata?: Omit<WireMetadata, "moduleName">) => Promise<EmittedData<XEventsTypes, Event, WireMetadata>>;
};

// @public
export type VueCSSClasses = string | Dictionary<boolean> | (string | Dictionary<boolean>)[];

// @public
export interface WatchedInternalSearchRequest {
    // (undocumented)
    newRequest: InternalSearchRequest;
    // (undocumented)
    oldRequest: InternalSearchRequest;
}

// @public
export type Wire<PayloadType> = (observable: Observable<WirePayload<PayloadType>>, store: Store<RootXStoreState>, on: XPriorityBus<XEventsTypes, WireMetadata>['on']) => Subscription;

// @public
export function wireCommit<Payload>(mutation: string, payloadFactory: (params: PayloadFactoryData<Payload>) => any): AnyWire;

// @public
export function wireCommit(mutation: string, staticPayload: any): AnyWire;

// @public
export function wireCommit<Payload>(mutation: string): Wire<Payload>;

// @public
export function wireCommitWithoutPayload(mutation: string): AnyWire;

// @public
export function wireDispatch<Payload>(action: string, payloadFactory: (params: PayloadFactoryData<Payload>) => any): AnyWire;

// @public
export function wireDispatch(action: string, staticPayload: any): AnyWire;

// @public
export function wireDispatch<Payload>(action: string): Wire<Payload>;

// @public
export function wireDispatchWithoutPayload(action: string): AnyWire;

// @public
export type WireForEvent<Event extends XEvent> = Wire<XEventPayload<Event>>;

// @public
export interface WireMetadata {
    // (undocumented)
    [key: string]: unknown;
    component?: Component;
    feature?: QueryFeature | ResultFeature;
    id?: string;
    ignoreInModules?: XModuleName[];
    location?: FeatureLocation;
    moduleName: XModuleName | null;
    oldValue?: unknown;
    // Warning: (ae-incompatible-release-tags) The symbol "priority" is marked as @public, but its signature references "Priority" which is marked as @internal
    priority?: Priority;
    replaceable?: boolean;
    target?: HTMLElement;
}

// @public
export interface WireParams<Payload> extends WirePayload<Payload> {
    // (undocumented)
    store: Store<RootXStoreState>;
}

// @public
export interface WirePayload<PayloadType> extends SubjectPayload<PayloadType, WireMetadata> {
}

// @public
export interface WireService<SomeService extends Record<string, MonadicFunction>> {
    <SomeMethod extends keyof SomeService>(method: SomeMethod): Wire<FirstParameter<SomeService[SomeMethod]>>;
    <SomeMethod extends keyof SomeService>(method: SomeMethod, payload: FirstParameter<SomeService[SomeMethod]>): AnyWire;
}

// @public
export function wireService<SomeService>(service: SomeService & SubObject<SomeService, MonadicFunction>): WireService<SubObject<SomeService, MonadicFunction>>;

// @public
export interface WireServiceWithoutPayload<SomeService extends Record<string, NiladicFunction>> {
    <SomeMethod extends keyof SomeService>(method: SomeMethod): AnyWire;
}

// @public
export function wireServiceWithoutPayload<SomeService>(service: SomeService & SubObject<SomeService, NiladicFunction>): WireServiceWithoutPayload<SubObject<SomeService, NiladicFunction>>;

// @public
export type Wiring = {
    [Event in XEvent]: Dictionary<WireForEvent<Event>>;
};

// @public
export interface XActionContext<State extends Dictionary, Getters extends Dictionary, Mutations extends MutationsDictionary<Mutations>, Actions extends ActionsDictionary<Actions>> extends ActionContext<State, RootXStoreState> {
    // (undocumented)
    commit: (<MutationName extends PropsWithType<Mutations, () => void>>(mutation: MutationName) => void) & (<MutationName extends keyof Mutations>(mutation: MutationName, payload: ExtractPayload<Mutations[MutationName]>) => void);
    // (undocumented)
    dispatch: (<ActionName extends PropsWithType<Actions, () => any>>(action: ActionName) => ExtractActionReturn<Actions[ActionName]>) & (<ActionName extends keyof Actions>(action: ActionName, payload: ExtractPayload<Actions[ActionName]>) => ExtractActionReturn<Actions[ActionName]>);
    // (undocumented)
    getters: Getters;
}

// @public
export interface XAPI {
    addProductToCart: (productId?: string) => void;
    getSnippetConfig: () => SnippetConfig;
    init: (config: SnippetConfig) => Promise<void>;
    search: (query?: string) => void;
    // @internal
    setBus: (bus: XBus<XEventsTypes, WireMetadata>) => void;
    // @internal
    setInitCallback: (initCallback: (config: SnippetConfig) => void) => void;
    setSnippetConfig: (config: Partial<SnippetConfig>) => void;
    // @internal
    setSnippetConfigCallback: (callback: (config: Partial<SnippetConfig>) => void) => void;
    // @internal
    setSnippetConfigGetter: (snippetConfigGetter: () => NormalisedSnippetConfig) => void;
}

// @public
export interface XBus<SomeEvents extends Dictionary, SomeEventMetadata extends Dictionary> {
    emit: (<SomeEvent extends keyof SomeEvents>(event: SomeEvent) => Promise<EmittedData<SomeEvents, SomeEvent, SomeEventMetadata>>) | (<SomeEvent extends keyof SomeEvents>(event: SomeEvent, payload: EventPayload<SomeEvents, SomeEvent>, metadata?: SomeEventMetadata) => Promise<EmittedData<SomeEvents, SomeEvent, SomeEventMetadata>>);
    on: <SomeEvent extends keyof SomeEvents>(event: SomeEvent, withMetadata?: boolean) => typeof withMetadata extends true ? Observable<SubjectPayload<EventPayload<SomeEvents, SomeEvent>, SomeEventMetadata>> : Observable<EventPayload<SomeEvents, SomeEvent>>;
}

// @public
export interface XComponentAliasAPI {
    readonly device: string | null;
    readonly facets: Record<Facet['id'], Facet>;
    readonly fromNoResultsWithFilters: Readonly<boolean>;
    readonly fullHistoryQueries: ReadonlyArray<HistoryQuery_2>;
    readonly fullQuerySuggestions: ReadonlyArray<Suggestion>;
    readonly historyQueries: ReadonlyArray<HistoryQuery_2>;
    readonly historyQueriesWithResults: ReadonlyArray<HistoryQuery_2>;
    readonly identifierResults: ReadonlyArray<Result>;
    readonly isEmpathizeOpen: boolean;
    readonly isHistoryQueriesEnabled: Readonly<boolean>;
    readonly nextQueries: ReadonlyArray<NextQuery_2>;
    readonly noResults: boolean;
    readonly partialResults: ReadonlyArray<PartialResult>;
    readonly popularSearches: ReadonlyArray<Suggestion>;
    readonly query: XComponentAliasQueryAPI;
    readonly querySuggestions: ReadonlyArray<Suggestion>;
    readonly recommendations: ReadonlyArray<Result>;
    readonly redirections: ReadonlyArray<Redirection_2>;
    readonly relatedTags: ReadonlyArray<RelatedTag_2>;
    readonly results: ReadonlyArray<Result>;
    readonly scroll: Record<string, ScrollComponentState>;
    // Warning: (ae-incompatible-release-tags) The symbol "searchBoxStatus" is marked as @public, but its signature references "InputStatus" which is marked as @internal
    readonly searchBoxStatus: InputStatus | undefined;
    readonly selectedFilters: Filter[];
    readonly selectedRelatedTags: ReadonlyArray<RelatedTag_2>;
    readonly selectedSort: string;
    readonly semanticQueries: ReadonlyArray<SemanticQuery_2>;
    readonly spellcheckedQuery: string | null;
    readonly status: XComponentAliasStatusAPI;
    readonly totalResults: number;
}

// @public
export interface XComponentAliasQueryAPI {
    readonly facets: string;
    readonly nextQueries: string;
    readonly querySuggestions: string;
    readonly relatedTags: string;
    readonly search: string;
    readonly searchBox: string;
}

// @public
export interface XComponentAliasStatusAPI {
    readonly identifierResults: RequestStatus | undefined;
    readonly nextQueries: RequestStatus | undefined;
    readonly popularSearches: RequestStatus | undefined;
    readonly querySuggestions: RequestStatus | undefined;
    readonly recommendations: RequestStatus | undefined;
    readonly relatedTags: RequestStatus | undefined;
    readonly search: RequestStatus | undefined;
}

// @public
export interface XComponentAPI extends XComponentBusAPI, XComponentAliasAPI {
}

// @public
export interface XComponentBusAPI {
    emit: ((event: PropsWithType<XEventsTypes, void>) => void) & (<Event extends XEvent>(event: Event, payload: XEventPayload<Event>, metadata?: Omit<WireMetadata, 'moduleName' | 'origin' | 'location'>) => void);
    on: XBus<XEventsTypes, WireMetadata>['on'];
}

// @public
export type XEvent = keyof XEventsTypes;

// @public
export type XEventListeners = Partial<{
    [Event in XEvent]: (payload: XEventPayload<Event>, metadata: WireMetadata) => unknown;
}>;

// @public
export type XEventPayload<Event extends XEvent> = XEventsTypes[Event] extends void ? undefined : XEventsTypes[Event];

// @public
export type XEventsOf<Type> = PropsWithType<XEventsTypes, Type>;

// @public
export interface XEventsTypes extends DeviceXEvents, EmpathizeXEvents, ExtraParamsXEvents, FacetsXEvents, HistoryQueriesXEvents, IdentifierResultsXEvents, NextQueriesXEvents, PopularSearchesXEvents, QueriesPreviewXEvents, QuerySuggestionsXEvents, RecommendationsXEvents, RelatedTagsXEvents, ScrollXEvents, SearchBoxXEvents, SearchXEvents, SemanticQueriesXEvents, TaggingXEvents, ExperienceControlsXEvents, UrlXEvents, RelatedPromptsXEvents, AiXEvents {
    ColumnsNumberProvided: number;
    ModuleRegistered: XModuleName;
    RenderedColumnsNumberChanged: number;
    SnippetCallbackExecuted: {
        event: XEvent;
        callbackReturn: unknown;
        payload: ExtractPayload<XEvent>;
        metadata: WireMetadata;
    };
    SuggestionsDisplayed: Suggestion[];
    TogglePanelStateChanged: boolean;
    UserAcceptedAQuery: string;
    UserAcceptedSpellcheckQuery: string;
    UserClickedADisplayResult: Result;
    UserClickedAResult: Result;
    UserClickedAResultRating: Result;
    UserClickedCloseEventsModal: void;
    UserClickedCloseModal: string;
    UserClickedCloseX: void;
    UserClickedColumnPicker: number;
    UserClickedOpenEventsModal: void;
    UserClickedOpenModal: string;
    UserClickedOpenX: void;
    UserClickedOutOfEventsModal: void;
    UserClickedOutOfMainModal: void;
    UserClickedOutOfModal: string;
    UserClickedPanelToggleButton: string;
    UserClickedResultAddToCart: Result;
    UserClickedScrollToTop: string;
    UserOpenXProgrammatically: void;
    UserPressedArrowKey: ArrowKey;
    UserReachedEmpathizeTop: void;
    UserSelectedAResultVariant: {
        result: Result;
        variant: ResultVariant;
        level: number;
        queryPreviewHash: ComputedRef<string> | null;
    };
    UserSelectedASuggestion: Suggestion;
}

// @public
export interface XInjectKey<Type> extends String {
}

// @public
export class XInstaller {
    constructor(options: InstallXOptions);
    // @internal
    protected createAPI(): void;
    // @internal
    protected createApp(): void;
    // @internal
    protected createBus(): XBus<XEventsTypes, WireMetadata>;
    // @internal
    protected getMountingTarget(domElement?: InstallXOptions['domElement']): Element | ShadowRoot;
    // @internal
    protected getPluginOptions(): XPluginOptions;
    protected getSnippetConfig(): NormalisedSnippetConfig;
    init(snippetConfig: SnippetConfig): Promise<InitWrapper>;
    // (undocumented)
    init(): Promise<InitWrapper | void>;
    // @internal
    protected installExtraPlugins(bus: XBus<XEventsTypes, WireMetadata>): Promise<void>;
    // @internal
    protected installPlugin(pluginOptions: XPluginOptions, bus: XBus<XEventsTypes, WireMetadata>): Plugin_2<XPluginOptions>;
    // (undocumented)
    protected normaliseSnippetConfig(snippetConfig: SnippetConfig): NormalisedSnippetConfig;
    // (undocumented)
    protected normaliseSnippetConfig(snippetConfig: Partial<SnippetConfig>): Partial<SnippetConfig>;
    // (undocumented)
    protected readonly options: InstallXOptions;
    // @internal
    protected snippetConfig?: NormalisedSnippetConfig;
    // @internal
    protected updateSnippetConfig(newSnippetConfig: Partial<SnippetConfig>): void;
}

// @public
export interface XModule<StoreModule extends AnyXStoreModule> {
    name: XModuleName;
    storeEmitters: StoreEmitters<StoreModule>;
    storeModule: StoreModule;
    wiring: Partial<Wiring>;
}

// @public
export type XModuleName = keyof XModulesTree;

// @public
export interface XModuleOptions<ModuleName extends XModuleName> {
    config?: DeepPartial<ExtractState<ModuleName> extends {
        config: infer Config;
    } ? Config : never>;
    wiring?: Partial<Wiring>;
}

// @public
export type XModulesOptions = {
    [ModuleName in XModuleName]?: XModuleOptions<ModuleName>;
};

// @internal
export type XModuleState = {
    [Key in keyof RootXStoreState['x']]: null;
};

// @public
export interface XModulesTree {
    // (undocumented)
    ai: AiXModule;
    // (undocumented)
    device: DeviceXModule;
    // (undocumented)
    empathize: EmpathizeXModule;
    // (undocumented)
    experienceControls: ExperienceControlsXModule;
    // (undocumented)
    extraParams: ExtraParamsXModule;
    // (undocumented)
    facets: FacetsXModule;
    // (undocumented)
    historyQueries: HistoryQueriesXModule;
    // (undocumented)
    identifierResults: IdentifierResultsXModule;
    // (undocumented)
    nextQueries: NextQueriesXModule;
    // (undocumented)
    popularSearches: PopularSearchesXModule;
    // (undocumented)
    queriesPreview: QueriesPreviewXModule;
    // (undocumented)
    querySuggestions: QuerySuggestionsXModule;
    // (undocumented)
    recommendations: RecommendationsXModule;
    // (undocumented)
    relatedPrompts: RelatedPromptsXModule;
    // (undocumented)
    relatedTags: RelatedTagsXModule;
    // (undocumented)
    scroll: ScrollXModule;
    // (undocumented)
    search: SearchXModule;
    // (undocumented)
    searchBox: SearchBoxXModule;
    // (undocumented)
    semanticQueries: SemanticQueriesXModule;
    // (undocumented)
    tagging: TaggingXModule;
    // (undocumented)
    url: UrlXModule;
}

// @public
export class XPlugin {
    constructor(bus: XBus<XEventsTypes, WireMetadata>);
    // Warning: (ae-forgotten-export) The symbol "XComponentsAdapter" needs to be exported by the entry point index.d.ts
    static get adapter(): XComponentsAdapter;
    // @internal
    protected adapter: XComponentsAdapter;
    // @internal
    protected app: App;
    static get bus(): XBus<XEventsTypes, WireMetadata>;
    // @internal
    protected bus: XBus<XEventsTypes, WireMetadata>;
    // @internal
    protected customizeStoreModule(input: AnyXStoreModule, input2: AnyXStoreModuleOption, configOptions: unknown): AnyXStoreModule;
    // @internal
    protected customizeXModule(input: AnyXModule): AnyXModule;
    // @internal
    protected static getInstance(): XPlugin;
    // @internal
    install(app: App, options?: XPluginOptions): void;
    // @internal
    protected installedXModules: Set<string>;
    // @internal
    protected static instance?: XPlugin;
    // @internal
    protected isInstalled: boolean;
    // @internal
    protected static lazyRegisterXModule(xModule: AnyXModule): void;
    // @internal
    protected options: XPluginOptions;
    // @internal
    protected static pendingXModules: Partial<Record<XModuleName, AnyXModule>>;
    // @internal
    protected registerInitialModules(): void;
    // @internal
    protected registerPendingXModules(): void;
    // @internal
    protected registerStore(): void;
    // @internal
    protected registerStoreEmitters(xModule: AnyXModule): void;
    // @internal
    protected registerStoreModule(input: AnyXModule): void;
    // @internal
    protected registerWiring(input: AnyXModule): void;
    static registerXModule(xModule: AnyXModule): void;
    // @internal
    protected registerXModule(xModule: AnyXModule): void;
    // @internal
    static resetInstance(): void;
    static get store(): Store<RootXStoreState>;
    // @internal
    protected store: Store<any>;
    // (undocumented)
    wiring: Partial<Record<XModuleName, Partial<Record<XEvent, string[]>>>>;
}

// @public
export const xPlugin: XPlugin;

// @public
export interface XPluginOptions {
    __PRIVATE__xModules?: PrivateXModulesOptions;
    adapter: XComponentsAdapter;
    initialXModules?: AnyXModule[];
    store?: Store<any>;
    xModules?: XModulesOptions;
}

// @public
export class XPriorityBus<SomeEvents extends Dictionary, SomeEventMetadata extends XPriorityBusEventMetadata> implements XBus<SomeEvents, SomeEventMetadata> {
    constructor(config?: {
        queue?: XPriorityQueue<SomeEvents, XPriorityQueueNodeData<SomeEvents, SomeEventMetadata>>;
        priorities?: Dictionary<number>;
        emitCallbacks?: AnyFunction[];
        defaultEventPriority?: number;
    });
    // @internal
    protected createEmitter<SomeEvent extends keyof SomeEvents>(event: SomeEvent): void;
    // @internal
    protected defaultEventPriority: number;
    emit<SomeEvent extends keyof SomeEvents>(event: SomeEvent, payload?: EventPayload<SomeEvents, SomeEvent>, metadata?: SomeEventMetadata): Promise<EmittedData<SomeEvents, SomeEvent, SomeEventMetadata>>;
    // @internal
    protected emitCallbacks: AnyFunction[];
    // @internal
    protected emitters: Emitters<SomeEvents, SomeEventMetadata>;
    // @internal
    protected flushQueue(): void;
    // @internal
    protected getEmitter<SomeEvent extends keyof SomeEvents>(event: SomeEvent): Emitter<SomeEvents, SomeEvent, SomeEventMetadata>;
    // @internal
    protected getEventPriority(event: keyof SomeEvents, metadata: SomeEventMetadata): Priority;
    on<SomeEvent extends keyof SomeEvents>(event: SomeEvent, withMetadata?: boolean): typeof withMetadata extends true ? Observable<SubjectPayload<EventPayload<SomeEvents, SomeEvent>, SomeEventMetadata>> : Observable<EventPayload<SomeEvents, SomeEvent>>;
    // @internal
    protected pendingFlushId?: number;
    // @internal
    protected pendingPopsIds: number[];
    // @internal
    protected priorities: Dictionary<Priority>;
    // @internal
    protected queue: XPriorityQueue<SomeEvents, XPriorityQueueNodeData<SomeEvents, SomeEventMetadata>>;
}

// @public
export interface XPriorityBusEventMetadata extends Dictionary {
    // (undocumented)
    priority?: number;
    // (undocumented)
    replaceable?: boolean;
}

// @public
export interface XPriorityQueue<SomeRecord extends Dictionary, SomeData extends Dictionary> {
    pop: () => XPriorityQueueNode<SomeRecord, SomeData> | undefined;
    push: (key: keyof SomeRecord, priority: number, data?: SomeData) => void;
    size: () => number;
}

// @public
export interface XPriorityQueueNode<SomeRecord extends Dictionary, SomeData extends Dictionary = Dictionary> {
    data: SomeData;
    key: keyof SomeRecord;
    priority: number;
}

// @public
export interface XPriorityQueueNodeData<SomeEvents extends Dictionary, SomeEventMetadata extends Dictionary, SomeEvent extends keyof SomeEvents = keyof SomeEvents> {
    eventMetadata: SomeEventMetadata;
    eventPayload: EventPayload<SomeEvents, SomeEvent>;
    replaceable: boolean;
    resolve: (value: EmittedData<SomeEvents, SomeEvent, SomeEventMetadata> | PromiseLike<EmittedData<SomeEvents, SomeEvent, SomeEventMetadata>>) => void;
}

// @public
export interface XStoreModule<State extends Record<keyof State, any>, Getters extends Record<keyof Getters, any>, Mutations extends MutationsDictionary<Mutations>, Actions extends ActionsDictionary<Actions>> {
    // (undocumented)
    actions: ActionsTree<State, Getters, Mutations, Actions>;
    // (undocumented)
    getters: GettersTree<State, Getters>;
    // (undocumented)
    mutations: MutationsTree<State, Mutations>;
    // (undocumented)
    state: () => State;
}

// @public
export type XStoreModuleOptions<StoreModule extends AnyXStoreModule> = StoreModule extends XStoreModule<infer State, infer Getters, infer Mutations, infer Actions> ? {
    state?: DeepPartial<State>;
    actions?: DeepPartial<ActionsTree<State, Getters, Mutations, Actions>>;
    getters?: DeepPartial<GettersTree<State, Getters>>;
    mutations?: DeepPartial<MutationsTree<State, Mutations>>;
} : never;

// Warnings were encountered during analysis:
//
// dist/types/src/components/animations/animate-clip-path.vue.d.ts:5:9 - (ae-forgotten-export) The symbol "AnimationOrigin" needs to be exported by the entry point index.d.ts
// dist/types/src/components/base-dropdown.vue.d.ts:11:9 - (ae-forgotten-export) The symbol "DropdownItem" needs to be exported by the entry point index.d.ts
// dist/types/src/components/base-grid.vue.d.ts:37:5 - (ae-forgotten-export) The symbol "GridItem" needs to be exported by the entry point index.d.ts
// dist/types/src/components/column-picker/base-column-picker-list.vue.d.ts:29:5 - (ae-forgotten-export) The symbol "ColumnPickerItem" needs to be exported by the entry point index.d.ts
// dist/types/src/components/filters/labels/base-price-filter-label.vue.d.ts:13:13 - (ae-forgotten-export) The symbol "RangeValue" needs to be exported by the entry point index.d.ts
// dist/types/src/components/filters/labels/base-rating-filter-label.vue.d.ts:16:9 - (ae-forgotten-export) The symbol "BooleanFilter" needs to be exported by the entry point index.d.ts
// dist/types/src/components/page-selector.vue.d.ts:65:5 - (ae-forgotten-export) The symbol "PageItem" needs to be exported by the entry point index.d.ts
// dist/types/src/components/suggestions/base-suggestion.vue.d.ts:31:9 - (ae-forgotten-export) The symbol "Suggestion" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/ai/components/ai-carousel.vue.d.ts:16:5 - (ae-forgotten-export) The symbol "TaggingRequest" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/ai/components/ai-carousel.vue.d.ts:19:5 - (ae-forgotten-export) The symbol "AiSuggestionQuery" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/ai/components/ai-carousel.vue.d.ts:21:5 - (ae-forgotten-export) The symbol "AiSuggestionSearch" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/ai/components/ai-carousel.vue.d.ts:22:5 - (ae-forgotten-export) The symbol "AiSuggestionTagging" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/device/components/device-detector.vue.d.ts:21:9 - (ae-forgotten-export) The symbol "Device" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/device/components/device-detector.vue.d.ts:21:9 - (ae-forgotten-export) The symbol "MaxWidth" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/facets/facets.vue.d.ts:47:5 - (ae-forgotten-export) The symbol "RenderFacet" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/all-filter.vue.d.ts:16:9 - (ae-forgotten-export) The symbol "Facet" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/editable-number-range-filter.vue.d.ts:25:9 - (ae-forgotten-export) The symbol "EditableNumberRangeFilter_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:62:13 - (ae-forgotten-export) The symbol "ResultVariant" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:110:9 - (ae-forgotten-export) The symbol "NextQuery_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:175:9 - (ae-forgotten-export) The symbol "Redirection_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:176:9 - (ae-forgotten-export) The symbol "Promoted_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:181:9 - (ae-forgotten-export) The symbol "SemanticQuery_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/filters/hierarchical-filter.vue.d.ts:203:9 - (ae-forgotten-export) The symbol "RelatedPrompt_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/facets/components/lists/selected-filters-list.vue.d.ts:27:5 - (ae-forgotten-export) The symbol "RenderFilter" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/related-prompts/components/related-prompts-tag-list.vue.d.ts:62:9 - (ae-forgotten-export) The symbol "RelatedPromptNextQuery" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/search/components/banner.vue.d.ts:23:9 - (ae-forgotten-export) The symbol "Banner_2" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/search/components/sort-list.vue.d.ts:29:5 - (ae-forgotten-export) The symbol "SortListItem" needs to be exported by the entry point index.d.ts
// dist/types/src/x-modules/search/components/sort-picker-list.vue.d.ts:22:5 - (ae-forgotten-export) The symbol "SortPickerItem" needs to be exported by the entry point index.d.ts
// src/x-modules/ai/store/emitters.ts:9:24 - (ae-forgotten-export) The symbol "AiSuggestionsSearchRequest" needs to be exported by the entry point index.d.ts
// src/x-modules/search/store/module.ts:166:32 - (ae-forgotten-export) The symbol "Stats" needs to be exported by the entry point index.d.ts
// src/x-modules/url/store/emitters.ts:57:1 - (ae-forgotten-export) The symbol "shouldPushUrl" needs to be exported by the entry point index.d.ts
// src/x-modules/url/store/emitters.ts:64:1 - (ae-forgotten-export) The symbol "shouldReplaceUrl" needs to be exported by the entry point index.d.ts

```