@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 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 type { Directive } from 'vue';
import type { EndpointAdapter } from '@empathyco/x-adapter';
import { ExtractPropTypes } from 'vue';
import { default as FiltersIcon } from './filters.vue';
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 { 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 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 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;
    // Warning: (ae-forgotten-export) The symbol "AiSuggestionsSearchRequest" needs to be exported by the entry point index.d.ts
    fetchAndSaveAiSuggestionsSearch: (request: AiSuggestionsSearchRequest | null) => 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;
};

// @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;
    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;
    setSuggestionsLoading: (value: boolean) => void;
    // Warning: (ae-forgotten-export) The symbol "AiSuggestionSearch" needs to be exported by the entry point index.d.ts
    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<    {
title: {
type: PropType<string>;
default: string;
};
titleLoading: {
type: PropType<string>;
default: string;
};
expandText: {
type: PropType<string>;
default: string;
};
collapseText: {
type: PropType<string>;
default: string;
};
slidingPanelsClasses: {
type: PropType<string>;
};
slidingPanelContainersClasses: {
type: PropType<string>;
};
slidingPanelButtonsClasses: {
type: PropType<string>;
};
}, {
buttonText: ComputedRef<string>;
expanded: Ref<boolean>;
queries: ComputedRef<AiSuggestionQuery[]>;
responseText: ComputedRef<string>;
suggestionsLoading: ComputedRef<boolean>;
queriesResults: ComputedRef<Record<string, {
results: AiSuggestionSearch["results"];
numFound: number;
}>>;
suggestionsSearch: ComputedRef<AiSuggestionSearch[]>;
suggestionText: ComputedRef<string>;
setExpanded: (newValue: boolean) => void;
onExpandButtonClick: (newValue: boolean) => void;
query: ComputedRef<string>;
tagging: ComputedRef<AiSuggestionTagging | undefined>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: PropType<string>;
default: string;
};
titleLoading: {
type: PropType<string>;
default: string;
};
expandText: {
type: PropType<string>;
default: string;
};
collapseText: {
type: PropType<string>;
default: string;
};
slidingPanelsClasses: {
type: PropType<string>;
};
slidingPanelContainersClasses: {
type: PropType<string>;
};
slidingPanelButtonsClasses: {
type: PropType<string>;
};
}>>, {
title: string;
titleLoading: string;
expandText: string;
collapseText: string;
}, {}>;

export { AIStarIcon }

// @public
export interface AiState extends QueryState {
    // (undocumented)
    config: AiConfig;
    params: Dictionary<unknown>;
    // (undocumented)
    queries: AiSuggestionQuery[];
    relatedTags: RelatedTag_2[];
    responseText: string;
    suggestionsLoading: boolean;
    suggestionsSearch: AiSuggestionSearch[];
    suggestionsSearchLoading: boolean;
    // (undocumented)
    suggestionText: string;
    // (undocumented)
    tagging: AiSuggestionTagging | undefined;
}

// @internal
export const aiWiring: {
    ParamsLoadedFromUrl: {
        setUrlParams: Wire<UrlParams>;
    };
    ExtraParamsChanged: {
        setExtraParams: Wire<Dictionary<unknown>>;
    };
    UserAcceptedAQuery: {
        setAiQuery: Wire<string>;
    };
    UserClearedQuery: {
        setAiQuery: Wire<string>;
    };
    AiSuggestionsRequestUpdated: {
        resetAiState: AnyWire;
        fetchAndSaveAiSuggestions: Wire<AiSuggestionsRequest | null>;
    };
    AiSuggestionsSearchRequestUpdated: {
        fetchAndSaveAiSuggestionsSearch: Wire<AiSuggestionsSearchRequest | null>;
    };
    SelectedRelatedTagsChanged: {
        setAiRelatedTags: Wire<RelatedTag_2[]>;
    };
};

// @public
export interface AiXEvents {
    // (undocumented)
    AiSuggestionsRequestUpdated: AiSuggestionsRequest | null;
    // (undocumented)
    AiSuggestionsSearchRequestUpdated: AiSuggestionsSearchRequest | null;
    // (undocumented)
    UserClickedAiOverviewExpandButton: boolean;
}

// @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<    {
facet: {
type: PropType<Facet>;
required: true;
};
}, {
clickEvent: ComputedRef<Partial<XEventsTypes>>;
cssClasses: ComputedRef<    {
'x-selected x-all-filter--is-selected': boolean;
}>;
isSelected: ComputedRef<boolean>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
facet: {
type: PropType<Facet>;
required: true;
};
}>>, {}, {}>;

// 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<ExtractPropTypes<    {}>>, {}, {}>;

// @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 "Filter" needs to be exported by the entry point index.d.ts
//
// @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<    {
isLoading: {
type: BooleanConstructor;
default: boolean;
};
durationInSeconds: {
type: NumberConstructor;
default: number;
};
}, {
cssStyles: ComputedRef<StyleValue>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
isLoading: {
type: BooleanConstructor;
default: boolean;
};
durationInSeconds: {
type: NumberConstructor;
default: number;
};
}>>, {
isLoading: boolean;
durationInSeconds: number;
}, {}>;

export { BagIcon }

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

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

export { BarCodeIcon }

export { BarcodeTinyIcon }

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

// @public
export const BaseColumnPickerDropdown: Vue.DefineComponent<{
    columns: {
        type: PropType<number[]>;
        required: true;
    };
    modelValue: NumberConstructor;
    animation: PropType<string | typeof Vue>;
}, {
    emitEvents: (column: number) => void;
    hasToggleSlot: boolean;
    selectedColumns: Vue.Ref<number>;
}, unknown, {}, {}, 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>;
}>> & {
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, {}>;

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

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

// @public
export const BaseDropdown: DefineComponent<    {
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>;
}>;
emitSelectedItemChanged: (item: DropdownItem) => void;
highlightFirstItem: () => void;
highlightLastItem: () => void;
highlightNextItem: () => void;
highlightPreviousItem: () => void;
highlightedItemIndex: Ref<number>;
isOpen: Ref<boolean>;
itemsButtonRefs: Ref<HTMLButtonElement[]>;
itemsCSSClasses: ComputedRef<    {
'x-dropdown__item--is-selected': boolean;
'x-dropdown__item--is-highlighted': boolean;
}[]>;
listId: string;
open: () => boolean;
rootRef: Ref<HTMLElement | undefined>;
toggle: () => boolean;
toggleButtonRef: Ref<HTMLButtonElement | undefined>;
updateSearchBuffer: (event: KeyboardEvent) => void;
}, unknown, {}, {}, 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;
};
}>> & {
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
animation: string | Function | Record<string, any>;
searchTimeoutMs: number;
}, {}>;

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

// @public
export const BaseEventsModal: DefineComponent<    {
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>;
openerElement: Ref<HTMLElement | undefined>;
baseModalEl: Ref<HTMLElement | undefined>;
emitBodyClickEvent: (event: MouseEvent | FocusEvent) => void;
}, unknown, {}, {}, 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)[];
}>>, {
eventsToOpenModal: (keyof XEventsTypes)[];
eventsToCloseModal: (keyof XEventsTypes)[];
bodyClickEvent: keyof XEventsTypes;
}, {}>;

// @public
export const BaseEventsModalClose: DefineComponent<    {
closingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}, {
events: ComputedRef<Partial<XEventsTypes>>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
closingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>>, {
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";
}, {}>;

// @public
export const BaseEventsModalOpen: DefineComponent<    {
openingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}, {
events: ComputedRef<Partial<XEventsTypes>>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
openingEvent: {
type: PropType<PropsWithType<XEventsTypes, void>>;
default: string;
};
}>>, {
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";
}, {}>;

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<    {
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<{
$el: HTMLElement;
} | HTMLElement | undefined>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
columns: {
type: NumberConstructor;
default: number;
};
items: {
type: PropType<ListItem[]>;
};
}>>, {
animation: string | Function | Record<string, any>;
columns: number;
}, {}>;

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

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

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

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

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

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

// @public
export const BaseKeyboardNavigation: DefineComponent<    {
navigationHijacker: {
type: PropType<TakeNavigationControl[]>;
default: () => {
xEvent: string;
moduleName: string;
direction: string;
}[];
};
eventsForDirectionLimit: {
type: PropType<Partial<EventsForDirectionLimit>>;
default: () => {
ArrowUp: string;
};
};
}, {
el: Ref<HTMLElement | undefined>;
focusNextNavigableElement: (direction: ArrowKey | KeyboardEvent) => void;
}, unknown, {}, {}, 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;
};
};
}>>, {
navigationHijacker: TakeNavigationControl[];
eventsForDirectionLimit: Partial<EventsForDirectionLimit>;
}, {}>;

// @public
export const BaseModal: DefineComponent<    {
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>;
modalContentRef: Ref<HTMLDivElement | undefined>;
modalRef: Ref<HTMLDivElement | undefined>;
}, unknown, {}, {}, 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;
}>> & {
"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>;
}, {}>;

export { BasePlaceholderImage }

// @public
export const BasePriceFilterLabel: DefineComponent<    {
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;
}>, unknown, {}, {}, 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;
};
}>>, {}, {}>;

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

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

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

// @public
export const BaseResultImage: DefineComponent<    {
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[]>;
loadedImages: Ref<string[]>;
isHovering: Ref<boolean>;
userHasHoveredImage: Ref<boolean>;
loaderStyles: Partial<CSSStyleDeclaration>;
animation: ComputedRef<string | Function | Record<string, any>>;
imageSrc: ComputedRef<string>;
shouldLoadNextImage: ComputedRef<boolean>;
flagImageAsFailed: () => void;
flagImageLoaded: () => void;
}, unknown, {}, {}, 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;
};
}>>, {
loadAnimation: string | Function | Record<string, any>;
showNextImageOnHover: boolean;
}, {}>;

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

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

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

// @public
export const BaseScroll: DefineComponent<    {
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>;
}, unknown, {}, {}, 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[];
};
}>> & {
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)[];
}, {}>;

// @public
export const BaseSlider: DefineComponent<    {
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>;
rangeSelected: ComputedRef<number[]>;
}, unknown, {}, {}, 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;
};
}>> & {
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
threshold: {
min: number;
max: number;
};
contentClass: string;
}, {}>;

// @public
export const BaseSuggestion: DefineComponent<    {
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>;
filter: ComputedRef<BooleanFilter | undefined>;
emitEvents: () => void;
dynamicCSSClasses: ComputedRef<VueCSSClasses>;
}, unknown, {}, {}, 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;
};
}>>, {
query: string;
highlightCurated: boolean;
}, {}>;

// @public
export const BaseSuggestions: DefineComponent<    {
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;
}, unknown, {}, {}, 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;
}>>, {
animation: string | Function | Record<string, any>;
showFacets: boolean;
showPlainSuggestion: boolean;
}, {}>;

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

// @public
export const BaseTabsPanel: DefineComponent<    {
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>;
slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
getTabs: () => string[];
selectTab: (tab: string) => void;
tabIsSelected: (tab: string) => boolean;
}, unknown, {}, {}, 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;
}>>, {
tabsAnimation: string | Function | Record<string, any>;
contentAnimation: string | Function | Record<string, any>;
initialTab: string;
allowTabDeselect: boolean;
}, {}>;

// @public (undocumented)
export const BaseTeleport: DefineComponent<    {
target: {
type: PropType<string | Element>;
required: true;
};
position: {
type: PropType<"beforebegin" | "afterbegin" | "beforeend" | "afterend" | "onlychild">;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
}, {
teleportHost: Ref<Element | undefined>;
}, unknown, {}, {}, 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;
};
}>>, {
position: "beforebegin" | "afterbegin" | "beforeend" | "afterend" | "onlychild";
disabled: boolean;
}, {}>;

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

// @public
export const BaseVariableColumnGrid: DefineComponent<    {
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;
}>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
animation: {
type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
default: string;
};
items: PropType<ListItem[]>;
columns: {
type: NumberConstructor;
default: number;
};
}>>, {
animation: string | Function | Record<string, any>;
columns: number;
}, {}>;