react-instantsearch

Breadcrumb: ({
    attributes,
    rootPath,
    separator,
    transformItems,
    translations,
    ...props
}: BreadcrumbProps) => React.JSX.Element;

Carousel: <TObject extends Record<string, unknown>>(
    props: CarouselProps<TObject>
) => React.JSX.Element;

Chat: <TObject extends RecordWithObjectID, TUiMessage extends UIMessage>({
    tools: userTools,
    toggleButtonProps,
    headerProps,
    messagesProps,
    promptProps,
    itemComponent,
    toggleButtonComponent,
    toggleButtonIconComponent,
    headerComponent,
    headerTitleIconComponent,
    headerCloseIconComponent,
    headerMinimizeIconComponent,
    headerMaximizeIconComponent,
    messagesLoaderComponent,
    messagesErrorComponent,
    promptComponent,
    promptHeaderComponent,
    promptFooterComponent,
    assistantMessageLeadingComponent,
    assistantMessageFooterComponent,
    userMessageLeadingComponent,
    userMessageFooterComponent,
    actionsComponent,
    classNames,
    translations,
    title,
    getSearchPageURL,
    ...props
}: ChatProps<TObject, TUiMessage>) => React.JSX.Element;

ClearRefinements: ({
    includedAttributes,
    excludedAttributes,
    transformItems,
    translations,
    ...props
}: ClearRefinementsProps) => React.JSX.Element;

createDefaultTools: <TObject extends RecordWithObjectID>(
    itemComponent?: RecommendComponentProps<TObject>,
    getSearchPageURL?: (nextUiState: IndexUiState) => string
) => UserClientSideTools;

CurrentRefinements: ({
    includedAttributes,
    excludedAttributes,
    transformItems,
    ...props
}: CurrentRefinementsProps) => React.JSX.Element;

EXPERIMENTAL_Autocomplete: <TItem extends BaseHit = BaseHit>({
    indices,
    showSuggestions,
    showRecent,
    searchParameters: userSearchParameters,
    ...props
}: AutocompleteProps<TItem>) => React.JSX.Element;

FrequentlyBoughtTogether: <THit extends BaseHit = BaseHit>({
    objectIDs,
    limit,
    threshold,
    queryParameters,
    fallbackParameters,
    escapeHTML,
    transformItems,
    itemComponent,
    headerComponent,
    emptyComponent,
    layoutComponent,
    ...props
}: FrequentlyBoughtTogetherProps<THit>) => React.JSX.Element;

HierarchicalMenu: ({
    attributes,
    limit,
    rootPath,
    separator,
    showMore,
    showMoreLimit,
    showParentLevel,
    sortBy,
    transformItems,
    translations,
    ...props
}: HierarchicalMenuProps) => React.JSX.Element;

Highlight: <THit extends Hit<BaseHit>>({
    hit,
    attribute,
    highlightedTagName,
    nonHighlightedTagName,
    separator,
    ...props
}: HighlightProps<THit>) => React.JSX.Element;

Hits: <THit extends BaseHit = BaseHit>({
    escapeHTML,
    transformItems,
    hitComponent: HitComponent,
    bannerComponent: BannerComponent,
    ...props
}: HitsProps<THit>) => React.JSX.Element;

HitsPerPage: ({
    items: userItems,
    transformItems,
    ...props
}: HitsPerPageProps) => React.JSX.Element;

InfiniteHits: <THit extends BaseHit = BaseHit>({
    showPrevious: shouldShowPrevious,
    cache,
    escapeHTML,
    transformItems,
    translations,
    bannerComponent: BannerComponent,
    ...props
}: InfiniteHitsProps<THit>) => React.JSX.Element;

LookingSimilar: <THit extends BaseHit = BaseHit>({
    objectIDs,
    limit,
    threshold,
    queryParameters,
    fallbackParameters,
    escapeHTML,
    transformItems,
    itemComponent,
    headerComponent,
    emptyComponent,
    layoutComponent,
    ...props
}: LookingSimilarProps<THit>) => React.JSX.Element;

Menu: ({
    attribute,
    limit,
    showMore,
    showMoreLimit,
    sortBy,
    transformItems,
    translations,
    ...props
}: MenuProps) => React.JSX.Element;

Pagination: ({
    showFirst,
    showPrevious,
    showNext,
    showLast,
    padding,
    totalPages,
    translations,
    ...props
}: PaginationProps) => React.JSX.Element;

PoweredBy: (props: PoweredByProps) => React.JSX.Element;

RangeInput: ({
    attribute,
    min,
    max,
    precision,
    translations,
    ...props
}: RangeInputProps) => React.JSX.Element;

RefinementList: ({
    searchable,
    searchablePlaceholder,
    searchableSelectOnSubmit,
    attribute,
    operator,
    limit,
    showMore,
    showMoreLimit,
    sortBy,
    escapeFacetValues,
    transformItems,
    translations,
    ...props
}: RefinementListProps) => React.JSX.Element;

RelatedProducts: <TItem extends BaseHit = BaseHit>({
    objectIDs,
    limit,
    threshold,
    fallbackParameters,
    queryParameters,
    escapeHTML,
    transformItems,
    itemComponent,
    headerComponent,
    emptyComponent,
    layoutComponent,
    ...props
}: RelatedProductsProps<TItem>) => React.JSX.Element;

ReverseHighlight: <THit extends Hit<BaseHit>>({
    hit,
    attribute,
    highlightedTagName,
    nonHighlightedTagName,
    separator,
    ...props
}: ReverseHighlightProps<THit>) => React.JSX.Element;

SearchBox: ({
    queryHook,
    searchAsYouType,
    ignoreCompositionEvents,
    translations,
    ...props
}: SearchBoxProps) => React.JSX.Element;

Snippet: <THit extends Hit<BaseHit>>({
    hit,
    attribute,
    highlightedTagName,
    nonHighlightedTagName,
    separator,
    ...props
}: SnippetProps<THit>) => React.JSX.Element;

SortBy: ({ items, transformItems, ...props }: SortByProps) => React.JSX.Element;

Stats: ({ translations, ...props }: StatsProps) => React.JSX.Element;

ToggleRefinement: ({
    attribute,
    on,
    off,
    ...props
}: ToggleRefinementProps) => React.JSX.Element;

TrendingItems: <TItem extends BaseHit = BaseHit>({
    facetName,
    facetValue,
    limit,
    threshold,
    fallbackParameters,
    queryParameters,
    escapeHTML,
    transformItems,
    itemComponent,
    headerComponent,
    emptyComponent,
    layoutComponent,
    ...props
}: TrendingItemsProps<TItem>) => React.JSX.Element;

useStickToBottom: (options?: any) => any;

type AutocompleteProps<TItem extends BaseHit> = ComponentProps<'div'> & {
    indices?: Array<IndexConfig<TItem>>;
    showSuggestions?: Partial<
        Pick<
            IndexConfig<{
                query: string;
            }>,
            | 'indexName'
            | 'getURL'
            | 'headerComponent'
            | 'itemComponent'
            | 'classNames'
        >
    >;
    showRecent?:
        | boolean
        | {
              /**
               * Storage key to use in the local storage.
               */
              storageKey?: string;
              /**
               * Component to use for each recent search item.
               */
              itemComponent: AutocompleteIndexProps<{
                  query: string;
              }>['ItemComponent'] & {
                  onRemoveRecentSearch: () => void;
              };
          };
    getSearchPageURL?: (nextUiState: IndexUiState) => string;
    onSelect?: AutocompleteIndexConfig<TItem>['onSelect'];
    panelComponent?: (props: {
        elements: PanelElements;
        indices: ReturnType<typeof useAutocomplete>['indices'];
    }) => React.JSX.Element;
    searchParameters?: AutocompleteSearchParameters;
    classNames?: Partial<AutocompleteClassNames>;
    placeholder?: string;
};

type BreadcrumbProps = Omit<BreadcrumbUiProps, keyof UiProps> &
    Omit<UseBreadcrumbProps, 'separator'> & {
        translations?: Partial<UiProps['translations']>;
    };

type CarouselProps<TObject extends Record<string, unknown>> = Omit<
    CarouselUiProps<TObject>,
    | 'listRef'
    | 'nextButtonRef'
    | 'previousButtonRef'
    | 'carouselIdRef'
    | 'canScrollLeft'
    | 'canScrollRight'
    | 'setCanScrollLeft'
    | 'setCanScrollRight'
>;

type ChatProps<TObject, TUiMessage extends UIMessage = UIMessage> = Omit<
    ChatUiProps,
    keyof UiProps
> &
    UseChatProps<TUiMessage> & {
        itemComponent?: ItemComponent<TObject>;
        tools?: UserClientSideTools;
        getSearchPageURL?: (nextUiState: IndexUiState) => string;
        toggleButtonProps?: UserToggleButtonProps;
        headerProps?: UserHeaderProps;
        messagesProps?: UserMessagesProps;
        promptProps?: UserPromptProps;
        toggleButtonComponent?: ChatUiProps['toggleButtonComponent'];
        toggleButtonIconComponent?: ChatUiProps['toggleButtonProps']['toggleIconComponent'];
        headerComponent?: ChatUiProps['headerComponent'];
        headerTitleIconComponent?: ChatUiProps['headerProps']['titleIconComponent'];
        headerCloseIconComponent?: ChatUiProps['headerProps']['closeIconComponent'];
        headerMinimizeIconComponent?: ChatUiProps['headerProps']['minimizeIconComponent'];
        headerMaximizeIconComponent?: ChatUiProps['headerProps']['maximizeIconComponent'];
        messagesLoaderComponent?: ChatUiProps['messagesProps']['loaderComponent'];
        messagesErrorComponent?: ChatUiProps['messagesProps']['errorComponent'];
        promptComponent?: ChatUiProps['promptComponent'];
        promptHeaderComponent?: ChatUiProps['promptProps']['headerComponent'];
        promptFooterComponent?: ChatUiProps['promptProps']['footerComponent'];
        actionsComponent?: ChatUiProps['messagesProps']['actionsComponent'];
        assistantMessageLeadingComponent?: ChatMessageProps['leadingComponent'];
        assistantMessageFooterComponent?: ChatMessageProps['footerComponent'];
        userMessageLeadingComponent?: ChatMessageProps['leadingComponent'];
        userMessageFooterComponent?: ChatMessageProps['footerComponent'];
        translations?: Partial<{
            prompt: ChatUiProps['promptProps']['translations'];
            header: ChatUiProps['headerProps']['translations'];
            message: ChatUiProps['messagesProps']['messageTranslations'];
            messages: ChatUiProps['messagesProps']['translations'];
        }>;
    };

type ClearRefinementsProps = Omit<ClearRefinementsUiComponentProps, keyof UiProps> &
    UseClearRefinementsProps & {
        translations?: Partial<UiProps['translations']>;
    };

type CurrentRefinementsProps = Omit<
    CurrentRefinementsUiComponentProps,
    keyof UiProps
> &
    UseCurrentRefinementsProps;

type FrequentlyBoughtTogetherProps<THit extends BaseHit> = Omit<
    FrequentlyBoughtTogetherPropsUiComponentProps<Hit<THit>>,
    keyof UiProps<THit>
> &
    UseFrequentlyBoughtTogetherProps<THit> & {
        itemComponent?: FrequentlyBoughtTogetherPropsUiComponentProps<THit>['itemComponent'];
        headerComponent?: FrequentlyBoughtTogetherPropsUiComponentProps<THit>['headerComponent'];
        emptyComponent?: FrequentlyBoughtTogetherPropsUiComponentProps<THit>['emptyComponent'];
        layoutComponent?: FrequentlyBoughtTogetherPropsUiComponentProps<THit>['layout'];
    };

type HierarchicalMenuProps = Omit<HierarchicalMenuUiComponentProps, keyof UiProps> &
    UseHierarchicalMenuProps & {
        translations?: Partial<UiProps['translations']>;
    };

type HighlightProps<THit extends Hit<BaseHit>> = {
    hit: THit;
    attribute: keyof THit | string[];
} & PartialKeys<
    Omit<HighlightUiComponentProps, 'parts'>,
    'highlightedTagName' | 'nonHighlightedTagName' | 'separator'
>;

type HitsPerPageProps = Omit<HitsPerPageUiComponentProps, keyof UiProps> &
    UseHitsPerPageProps;

type HitsProps<THit extends BaseHit> = Omit<
    HitsUiComponentProps<Hit<THit>>,
    keyof UiProps<THit>
> & {
    hitComponent?: React.JSXElementConstructor<{
        hit: Hit<THit>;
        sendEvent: SendEventForHits;
    }>;
} & {
    bannerComponent?:
        | React.JSXElementConstructor<{
              banner: Required<HitsUiComponentProps<Hit<THit>>>['banner'];
              className: string;
          }>
        | false;
} & UseHitsProps<THit>;

type InfiniteHitsProps<THit extends BaseHit = BaseHit> = Omit<
    InfiniteHitsUiComponentProps<Hit<THit>>,
    keyof UiProps<THit>
> & {
    bannerComponent?:
        | React.JSXElementConstructor<{
              banner: Required<InfiniteHitsUiComponentProps<Hit<THit>>>['banner'];
              className: string;
          }>
        | false;
} & UseInfiniteHitsProps<THit> & {
        /**
         * Displays the "Show Previous" button when the UI is loaded from a page
         * beyond the first one.
         * @default true
         */
        showPrevious?: boolean;
        translations?: Partial<UiProps<THit>['translations']>;
    };

type LookingSimilarProps<THit extends BaseHit> = Omit<
    LookingSimilarPropsUiComponentProps<Hit<THit>>,
    keyof UiProps<THit>
> &
    UseLookingSimilarProps<THit> & {
        itemComponent?: LookingSimilarPropsUiComponentProps<THit>['itemComponent'];
        headerComponent?: LookingSimilarPropsUiComponentProps<THit>['headerComponent'];
        emptyComponent?: LookingSimilarPropsUiComponentProps<THit>['emptyComponent'];
        layoutComponent?: LookingSimilarPropsUiComponentProps<THit>['layout'];
    };

type MenuProps = Omit<MenuUiComponentProps, keyof UiProps> &
    UseMenuProps & {
        translations?: Partial<UiProps['translations']>;
    };

type PaginationProps = Omit<PaginationUiComponentProps, keyof UiProps> &
    UsePaginationProps & {
        translations?: Partial<UiProps['translations']>;
    };

type PoweredByProps = Omit<PoweredByUiComponentProps, keyof UiProps>;

type RangeInputProps = Omit<RangeInputUiProps, keyof UiProps> &
    UseRangeProps & {
        translations?: Partial<UiProps['translations']>;
    };

type RefinementListProps = Omit<RefinementListUiComponentProps, keyof UiProps> &
    UseRefinementListProps &
    Pick<
        RefinementListWidgetParams,
        'searchable' | 'searchablePlaceholder' | 'searchableSelectOnSubmit'
    > & {
        translations?: Partial<
            UiProps['translations'] &
                SearchBoxTranslations & {
                    /**
                     * What to display when there are no results.
                     */
                    noResultsText: string;
                }
        >;
    };

type RelatedProductsProps<TItem extends BaseHit> = Omit<
    RelatedProductsUiComponentProps<TItem>,
    keyof UiProps<TItem>
> &
    UseRelatedProductsProps & {
        itemComponent?: RelatedProductsUiComponentProps<TItem>['itemComponent'];
        headerComponent?: RelatedProductsUiComponentProps<TItem>['headerComponent'];
        emptyComponent?: RelatedProductsUiComponentProps<TItem>['emptyComponent'];
        layoutComponent?: RelatedProductsUiComponentProps<TItem>['layout'];
    };

type ReverseHighlightProps<THit extends Hit<BaseHit>> = {
    hit: THit;
    attribute: keyof THit | string[];
} & PartialKeys<
    Omit<ReverseHighlightUiComponentProps, 'parts'>,
    'highlightedTagName' | 'nonHighlightedTagName' | 'separator'
>;

type SearchBoxProps = Omit<
    SearchBoxUiComponentProps,
    Exclude<keyof UiProps, 'onSubmit' | 'autoFocus'>
> &
    UseSearchBoxProps & {
        /**
         * Whether to trigger the search only on submit.
         * @default true
         */
        searchAsYouType?: boolean;
        /**
         * Whether to update the search state in the middle of a
         * composition session.
         * @default false
         */
        ignoreCompositionEvents?: boolean;
        translations?: Partial<UiProps['translations']>;
    };

type SnippetProps<THit extends Hit<BaseHit>> = {
    hit: THit;
    attribute: keyof THit | string[];
} & PartialKeys<
    Omit<SnippetUiComponentProps, 'parts'>,
    'highlightedTagName' | 'nonHighlightedTagName' | 'separator'
>;

type SortByProps = Omit<SortByUiComponentProps, keyof UiProps> & UseSortByProps;

type StatsProps = Omit<StatsUiComponentProps, keyof UiProps> &
    UseStatsProps & {
        translations?: Partial<UiProps['translations']>;
    };

type ToggleRefinementProps = PartialKeys<
    Omit<ToggleRefinementUiComponentProps, keyof UiProps>,
    'label'
> &
    UseToggleRefinementProps;

type Tool = UserClientSideTool;

type Tools = UserClientSideTools;

type TrendingItemsProps<TItem extends BaseHit> = Omit<
    TrendingItemsUiComponentProps<TItem>,
    keyof UiProps<TItem>
> &
    UseTrendingItemsProps & {
        itemComponent?: TrendingItemsUiComponentProps<TItem>['itemComponent'];
        headerComponent?: TrendingItemsUiComponentProps<TItem>['headerComponent'];
        emptyComponent?: TrendingItemsUiComponentProps<TItem>['emptyComponent'];
        layoutComponent?: TrendingItemsUiComponentProps<TItem>['layout'];
    };