@empathyco/x-components/report/x-components.api.md

Empathy X Components

## 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 AIStarIcon } from './ai-star.vue';
import type { AnyFunction } from '@empathyco/x-utils';
import type { App } from '@vue/devtools-api';
import type { App as App_2 } 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 { 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 type { 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-storage-service';
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 Vue 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: ({ state, dispatch }: HistoryQueriesActionContext, query: string) => void | Promise<void>;

// @public
export class AddQueryToHistoryAction implements ActionsClass<HistoryQueriesXStoreModule> {
    addQueryToHistory({ state, dispatch }: 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([lastWords, newWords]: Pair<string[]>, [lastQuery, newQuery]: Pair<string>): boolean;
    // @internal
    protected isQueryBeingRefined(lastWords: string[], newWords: string[]): boolean;
    // @internal
    protected isReplaceAction([lastWords, newWords]: Pair<string[]>, [lastQuery, newQuery]: 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
export interface AiConfig {
}

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

// @public
export interface AiGetters {
    query: string;
    suggestionsRequest: AiSuggestionsRequest;
    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;
    // Warning: (ae-forgotten-export) The symbol "AiSuggestionQuery" needs to be exported by the entry point index.d.ts
    setQueries: (queries: AiSuggestionQuery[]) => void;
    setResponseText: (responseText: string) => void;
    // Warning: (ae-forgotten-export) The symbol "Filter" needs to be exported by the entry point index.d.ts
    setSelectedFilters: (selectedFilters: Filter[]) => void;
    setSuggestionsLoading: (value: boolean) => void;
    setSuggestionsSearch: (suggestionsSearch: AiSuggestionSearch[]) => void;
    setSuggestionsSearchLoading: (value: boolean) => void;
    setSuggestionText: (suggestionText: string) => void;
    // Warning: (ae-forgotten-export) The symbol "AiSuggestionTagging" needs to be exported by the entry point index.d.ts
    setTagging: (tagging: AiSuggestionTagging) => void;
}

// @public (undocumented)
export const AiOverview: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
titleLoading: {
type: StringConstructor;
default: string;
};
expandText: {
type: StringConstructor;
default: string;
};
collapseText: {
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>;
buttonText: ComputedRef<string>;
emptyTaggingRequest: TaggingRequest;
expanded: Ref<boolean, boolean>;
parsedResponseText: ComputedRef<string | Promise<string>>;
suggestionsLoading: ComputedRef<boolean>;
suggestionsSearch: ComputedRef<AiSuggestionSearch[]>;
suggestionText: ComputedRef<string>;
emitAndSetExpand: (isExpanded: boolean) => void;
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;
};
expandText: {
type: StringConstructor;
default: string;
};
collapseText: {
type: StringConstructor;
default: string;
};
autoExpandInSearchNoResults: {
type: BooleanConstructor;
default: boolean;
};
contentClasses: {
type: StringConstructor;
};
slidingPanelsClasses: {
type: StringConstructor;
};
slidingPanelContainersClasses: {
type: StringConstructor;
};
slidingPanelButtonsClasses: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
titleLoading: string;
expandText: string;
collapseText: string;
autoExpandInSearchNoResults: boolean;
}, {}, {
AIStarIcon: DefineComponent<    {}, {}, any>;
ArrowRightIcon: DefineComponent<    {}, {}, any>;
BaseEventButton: DefineComponent<    {}, {}, any>;
ChevronDownIcon: 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 { 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;
    selectedFilters: Dictionary<Filter[]>;
    suggestionsLoading: boolean;
    suggestionsSearch: AiSuggestionSearch[];
    suggestionsSearchLoading: boolean;
    // (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>>;
    };
    UserAcceptedAQuery: {
        setAiQueryWire: Wire<string>;
    };
    UserAcceptedAQueryPreview: {
        setAiQueryFromPreviewWire: AnyWire;
    };
    UserClearedQuery: {
        setAiQueryWire: Wire<string>;
    };
    AiSuggestionsRequestUpdated: {
        resetAiStateWire: AnyWire;
        fetchAndSaveAiSuggestionsWire: Wire<AiSuggestionsRequest | null>;
    };
    UserClickedAiOverviewExpandButton: {
        fetchAndSaveAiSuggestionsSearchWire: Wire<boolean>;
    };
    SelectedRelatedTagsChanged: {
        setAiRelatedTagsWire: Wire<RelatedTag_2[]>;
    };
    SelectedFiltersForRequestChanged: {
        setSelectedFiltersWire: Wire<Filter[]>;
    };
    AiOverviewMounted: {
        saveAiOriginWire: AnyWire;
    };
};

// @public
export interface AiXEvents {
    // (undocumented)
    AiOverviewMounted: 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<    {
'x-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>;

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

// @public
export const animateScale: (animationOrigin?: AnimationOrigin) => DefineComponent;

// @public
export const animateTranslate: (animationOrigin?: AnimationOrigin) => DefineComponent;

// @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: Vue.DefineComponent<Vue.ExtractPropTypes<{
    columns: {
        type: PropType<number[]>;
        required: true;
    };
    modelValue: NumberConstructor;
    animation: PropType<string | typeof Vue>;
}>, {
    emitEvents: (column: number) => void;
    hasToggleSlot: boolean;
    selectedColumns: Vue.Ref<number, number>;
}, {}, {}, {}, Vue.ComponentOptionsMixin, Vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", Vue.PublicProps, Readonly<Vue.ExtractPropTypes<{
    columns: {
        type: PropType<number[]>;
        required: true;
    };
    modelValue: NumberConstructor;
    animation: PropType<string | typeof Vue>;
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
    BaseDropdown: Vue.DefineComponent<{}, {}, any>;
}, {}, string, Vue.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[], HTMLButtonElement[]>;
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" | "AiOverviewMounted";
}, {}, {
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" | "AiOverviewMounted";
}, {}, {
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: Ref<HTMLElement | undefined, HTMLElement | undefined>;
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: ({ target }: 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: ({ target }: 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: Partial<CSSStyleDeclaration>;
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<HTMLElement | null | undefined, HTMLElement | null | undefined>;
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
exp