@brainfish-ai/components 0.18.4-alpha.6 → 0.18.4

package/dist/accordion.d.ts

@@ -0,0 +1,12 @@
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as React_2 from 'react';
+
+export declare function Accordion({ ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Root>): React_2.JSX.Element;
+
+export declare function AccordionContent({ className, children, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Content>): React_2.JSX.Element;
+
+export declare function AccordionItem({ className, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Item>): React_2.JSX.Element;
+
+export declare function AccordionTrigger({ className, children, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Trigger>): React_2.JSX.Element;
+
+export { }

package/dist/alert-dialog.d.ts

@@ -0,0 +1,46 @@
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { ClassProp } from 'class-variance-authority/types';
+import * as React_2 from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare const AlertDialog: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogProps & React_2.RefAttributes<never>>;
+
+export declare const AlertDialogAction: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "link" | "dark" | "default" | "destructive" | "success" | "outline" | "secondary" | "ghost" | "shadow" | "shadowSurface" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & {
+    asChild?: boolean | undefined;
+} & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const AlertDialogCancel: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "link" | "dark" | "default" | "destructive" | "success" | "outline" | "secondary" | "ghost" | "shadow" | "shadowSurface" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const AlertDialogContent: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    zIndex?: string | undefined;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertDialogDescription: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const AlertDialogFooter: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
+    displayName: string;
+};
+
+export declare const AlertDialogHeader: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
+    displayName: string;
+};
+
+export declare const AlertDialogOverlay: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    zIndex?: string | undefined;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertDialogPortal: React_2.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+
+export declare const AlertDialogTitle: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare const AlertDialogTrigger: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export { }

package/dist/alert.d.ts

@@ -0,0 +1,18 @@
+import { ClassProp } from 'class-variance-authority/types';
+import * as React_2 from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare const Alert: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "success" | "warning" | "danger" | "info" | null | undefined;
+    layout?: "compact" | "longForm" | null | undefined;
+} & ClassProp) | undefined) => string>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertAction: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertDescription: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertTitle: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export { }

package/dist/badge.d.ts

@@ -0,0 +1,14 @@
+import { ClassProp } from 'class-variance-authority/types';
+import * as React_2 from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare function Badge({ className, variant, ...props }: BadgeProps): React_2.JSX.Element;
+
+export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "disabled" | "destructive" | "success" | "warning" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export { }

package/dist/button-group.d.ts

@@ -0,0 +1,21 @@
+import { ClassProp } from 'class-variance-authority/types';
+import { default as default_2 } from 'react';
+import * as React_2 from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import { VariantProps } from 'class-variance-authority';
+
+export declare function ButtonGroup({ className, orientation, ...props }: default_2.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): default_2.JSX.Element;
+
+export declare function ButtonGroupSeparator({ className, orientation, ...props }: default_2.ComponentProps<typeof Separator>): default_2.JSX.Element;
+
+export declare function ButtonGroupText({ className, asChild, ...props }: default_2.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): default_2.JSX.Element;
+
+export declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export { }

package/dist/button.d.ts

@@ -0,0 +1,16 @@
+import { ClassProp } from 'class-variance-authority/types';
+import * as React_2 from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "dark" | "default" | "destructive" | "success" | "outline" | "secondary" | "ghost" | "shadow" | "shadowSurface" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export { }

package/dist/calendar.d.ts

@@ -0,0 +1,12 @@
+import { DayPicker } from 'react-day-picker';
+import * as React_2 from 'react';
+
+export declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): React_2.JSX.Element;
+
+export declare namespace Calendar {
+    var displayName: string;
+}
+
+export declare type CalendarProps = React_2.ComponentProps<typeof DayPicker>;
+
+export { }

package/dist/card.d.ts

@@ -0,0 +1,15 @@
+import * as React_2 from 'react';
+
+export declare const Card: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export { }

package/dist/chart-area-linear.d.ts

@@ -0,0 +1,41 @@
+import { default as default_2 } from 'react';
+import * as React_2 from 'react';
+
+export declare function ChartAreaLinear({ title, metric, data, chartConfig, locale }: ChartAreaLinearProps): default_2.JSX.Element;
+
+export declare interface ChartAreaLinearProps {
+    title: string;
+    metric: string;
+    data: {
+        date: Date | string;
+        key1: number;
+        key2?: number;
+        key3?: number;
+        key4?: number;
+        key5?: number;
+    }[];
+    chartConfig: ChartConfig;
+    locale?: string;
+}
+
+declare type ChartConfig = {
+    [k in string]: {
+        label?: React_2.ReactNode;
+        icon?: React_2.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+
+export declare const description = "A linear area chart";
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+
+export { }

package/dist/chart-radial-stacked.d.ts

@@ -0,0 +1,39 @@
+import { default as default_2 } from 'react';
+import * as React_2 from 'react';
+
+declare type ChartConfig = {
+    [k in string]: {
+        label?: React_2.ReactNode;
+        icon?: React_2.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+
+export declare function ChartRadialStacked({ title, data, chartConfig, trend, trendValue, className, }: ChartRadialStackedProps): default_2.JSX.Element | null;
+
+export declare interface ChartRadialStackedProps {
+    title: string;
+    data: Record<string, number>[];
+    chartConfig: ChartConfig;
+    trend: Trend;
+    trendValue: string;
+    className?: string;
+}
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+
+declare enum Trend {
+    UP = "up",
+    DOWN = "down",
+    FLAT = "flat"
+}
+
+export { }

package/dist/chat-search.d.ts

@@ -0,0 +1,426 @@
+import { default as default_2 } from 'react';
+import { JSONSchemaType } from 'ajv';
+import { ReactNode } from 'react';
+
+declare type Action = {
+    id: string;
+    type: ActionType;
+    action: {
+        version: string;
+        options: {
+            title?: string;
+            [key: string]: any;
+        };
+    };
+};
+
+declare type ActionButtonsBlock = {
+    id: string;
+    type: 'action-buttons';
+};
+
+declare type ActionInput = {
+    name: string;
+    required: boolean;
+    schema: {
+        type: string;
+        title: string;
+        description: string;
+        oneOf?: {
+            const: string;
+            title: string;
+        }[];
+    };
+    type: string;
+    ui: {
+        type: string;
+    };
+};
+
+declare type ActionInputFormBlock = {
+    id: string;
+    type: 'action-input-form';
+    state: 'ready' | 'processing' | 'completed';
+    actionId: string;
+    initialValues: ActionInputs;
+    schema: ActionInputsSchema;
+    onSubmit?: (inputs: ActionInputs) => void;
+    inputs: ActionInput[];
+};
+
+declare type ActionInputs = Record<string, ActionInputValue>;
+
+declare type ActionInputsSchema = JSONSchemaType<ActionInputs>;
+
+declare type ActionInputValue = string | number | boolean | null;
+
+declare enum ActionType {
+    CallPhone = "call_phone",
+    OpenUrl = "open_url",
+    SendEmail = "send_email",
+    RunCallback = "run_callback"
+}
+
+declare type AddActionButtons = {
+    type: typeof AnswersActions.ADD_ACTION_BUTTONS;
+    payload: {
+        searchIntentId: string;
+        actions: Array<{
+            id: string;
+            type: string;
+            action: {
+                version: string;
+                options: {
+                    title?: string;
+                    [key: string]: any;
+                };
+            };
+        }>;
+        index?: number;
+    };
+};
+
+export declare interface Answer {
+    id: string;
+    state: AnswerState;
+    question: string;
+    blocks: AnswerBlock[];
+    searchResults?: SearchResult[];
+    followUpQuestions?: string[];
+    searchQueryId?: string;
+    feedback?: FeedbackResponse;
+    isUncertain?: boolean;
+    uncertaintyLanguage?: string | null;
+    uncertaintyFallbackText?: string;
+    searchIntentId?: string;
+    actions?: Action[];
+}
+
+declare type AnswerBlock = MarkdownTextBlock | ActionButtonsBlock | ActionInputFormBlock;
+
+declare type AnswerListAction = SetAnswers | ClearAll | AppendNewAnswer | SetSearchResults | AppendAnswerChunk | SetAnswerError | SetUserFeedback | ClearUserFeedback | SetFollowUpQuestions | AppendBlock | CompleteAnswer | MarkAsUncertain | InvokeAction | GetActionInputs | AddActionButtons | NoArticlesFound;
+
+declare const AnswersActions: {
+    readonly SET_ANSWERS: "answers/set_answers";
+    readonly CLEAR_ALL: "answers/clear_all";
+    readonly APPEND_NEW_ANSWER: "answers/create_empty_answer";
+    readonly APPEND_BLOCK: "answers/append_block";
+    readonly APPEND_ANSWER_CHUNK: "answers/append_stream_chunk";
+    readonly SET_SEARCH_RESULTS: "answers/update_search_results";
+    readonly SET_FOLLOW_UP_QUESTIONS: "answers/set_follow_up_questions";
+    readonly COMPLETE_ANSWER: "answers/finish_streaming";
+    readonly SET_ANSWER_ERROR: "answers/set_error_state";
+    readonly SET_USER_FEEDBACK: "answers/set_user_feedback";
+    readonly CLEAR_USER_FEEDBACK: "answers/clear_user_feedback";
+    readonly MARK_AS_UNCERTAIN: "answers/mark_as_uncertain";
+    readonly NO_ARTICLES_FOUND: "answers/no_articles_found";
+    readonly GET_ACTION_INPUTS: "answers/request_action_inputs";
+    readonly INVOKE_ACTION: "answers/invoke_action";
+    readonly ADD_ACTION_BUTTONS: "answers/add_action_buttons";
+};
+
+declare type AnswerState = 'fetching-search-results' | 'fetching-stream' | 'streaming' | 'getting-action-inputs' | 'completed';
+
+declare type AppendAnswerChunk = {
+    type: typeof AnswersActions.APPEND_ANSWER_CHUNK;
+    payload: {
+        text: string;
+        index?: number;
+    };
+};
+
+declare type AppendBlock = {
+    type: typeof AnswersActions.APPEND_BLOCK;
+    payload: {
+        block: AnswerBlock;
+        index?: number;
+    };
+};
+
+declare type AppendNewAnswer = {
+    type: typeof AnswersActions.APPEND_NEW_ANSWER;
+    payload: {
+        id?: string;
+        query: string;
+    };
+};
+
+export declare const ChatSearch: default_2.ForwardRefExoticComponent<ChatSearchProps & default_2.RefAttributes<ChatSearchHandle>>;
+
+declare interface ChatSearchContextProps {
+    query: string;
+    setQuery: default_2.Dispatch<default_2.SetStateAction<string>>;
+    queryId: string;
+    setQueryId: default_2.Dispatch<default_2.SetStateAction<string>>;
+    followUpQuery: string;
+    setFollowUpQuery: default_2.Dispatch<default_2.SetStateAction<string>>;
+    isSearching: boolean;
+    setIsSearching: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+    showResults: boolean;
+    setShowResults: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+    answers: Answer[];
+    answerListDispatch: default_2.Dispatch<AnswerListAction>;
+    activeAnswerIndex: number;
+    setActiveAnswerIndex: default_2.Dispatch<default_2.SetStateAction<number>>;
+    conversationId: string | undefined;
+    setConversationId: (id: string) => void;
+    clearConversationId: () => void;
+    isLoadingConversation: boolean;
+    setIsLoadingConversation: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+    loadError: string;
+    setLoadError: default_2.Dispatch<default_2.SetStateAction<string>>;
+    showMobileCloseWidgetButton: boolean;
+    setShowMobileCloseWidgetButton: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+    contentTypeEndpoint?: string;
+}
+
+export declare interface ChatSearchHandle {
+    createNewThread: (firstQuery?: string) => void;
+    showFollowUpThread: (show: boolean) => void;
+    subscribeToStateChanges: (callback: (state: ChatSearchState) => void) => () => void;
+    focusSearchField: () => void;
+    showCloseButton: (showButton: boolean) => void;
+}
+
+export declare interface ChatSearchProps {
+    suggestions?: Suggestion[];
+    collections?: Array<Collection>;
+    selectedCollectionId?: string;
+    onCollectionChange?: (collectionId: string) => void;
+    selectedRegion?: string;
+    onRegionChange?: (region: string) => void;
+    apiKey?: string;
+    fetchRegionConfig?: (apiKey: string, region: string) => Promise<{
+        settings?: {
+            collections?: Collection[];
+        };
+    } | null>;
+    searchEndpoint: string;
+    answerEndpoint: string;
+    answerStreamEndpoint: string;
+    feedbackEndpoint?: string;
+    feedbackReasonEndpoint?: string;
+    loadConversationEndpoint?: string;
+    followUpQuestionsEndpoint?: string;
+    autocompleteEndpoint?: string;
+    contentTypeEndpoint?: string;
+    disableFollowUpQuestions?: boolean;
+    disableImageAttachment?: boolean;
+    disableFeedback?: boolean;
+    disclaimer?: string;
+    offset?: number;
+    headers?: Record<string, string>;
+    textConfig?: TextConfig;
+    searchPath?: string;
+    className?: string;
+    onToggleSizeButtonClick?: () => void;
+    trackEvent?: (eventName: string, data?: Record<string, any>) => void;
+    featureFlags?: FeatureFlags;
+    onCloseWidget?: () => void;
+    isWidgetMode?: boolean;
+    nextBestActions?: NextBestAction[];
+    bodyActionButtons?: NextBestAction[];
+    onNextBestActionClick?: ({ action, searchQueryId, query, answer, }: {
+        action: NextBestAction;
+        searchQueryId: string;
+        query: string;
+        answer: string;
+    }) => void;
+    userData?: Record<string, unknown> | null;
+    redirectRules?: RedirectRule[];
+    secretAttributes?: string;
+    allowedRegions?: string[];
+    style?: React.CSSProperties;
+    isAgentAssist?: boolean;
+    isSearchWidget?: boolean;
+}
+
+export declare const ChatSearchProvider: default_2.FC<{
+    children: ReactNode;
+    searchPath?: string;
+    contentTypeEndpoint?: string;
+}>;
+
+export declare interface ChatSearchState {
+    showResults: boolean;
+    answers: Answer[];
+    isLoading: boolean;
+    error?: string;
+}
+
+declare type ClearAll = {
+    type: typeof AnswersActions.CLEAR_ALL;
+};
+
+declare type ClearUserFeedback = {
+    type: typeof AnswersActions.CLEAR_USER_FEEDBACK;
+    payload: {
+        index?: number;
+    };
+};
+
+export declare interface Collection {
+    id: string;
+    name: string;
+    siteEnabled?: boolean;
+}
+
+declare type CompleteAnswer = {
+    type: typeof AnswersActions.COMPLETE_ANSWER;
+    payload: {
+        index?: number;
+    };
+};
+
+declare type FeatureFlags = {
+    [key: string]: boolean | string | number;
+};
+
+declare type FeedbackResponse = 'accept' | 'reject';
+
+declare type GetActionInputs = {
+    type: typeof AnswersActions.GET_ACTION_INPUTS;
+    payload: {
+        searchIntentId: string;
+        actionId: string;
+        inputs: ActionInput[];
+        schema: JSONSchema<ActionInputs>;
+        initialValues: ActionInputs;
+        onSubmit: (parameters: ActionInputs) => void;
+        index?: number;
+    };
+};
+
+declare type InvokeAction = {
+    type: typeof AnswersActions.INVOKE_ACTION;
+    payload: {
+        index?: number;
+    };
+};
+
+declare type JSONSchema<T> = JSONSchemaType<T>;
+
+declare type MarkAsUncertain = {
+    type: typeof AnswersActions.MARK_AS_UNCERTAIN;
+    payload: {
+        uncertaintyText: string;
+        index?: number;
+    };
+};
+
+declare type MarkdownTextBlock = {
+    id: string;
+    type: 'markdown-text';
+    text: string;
+};
+
+declare type NextBestAction = {
+    id?: string;
+    label: string;
+    type: NextBestActionType;
+    icon?: string | UrlString;
+    value: any;
+};
+
+declare enum NextBestActionType {
+    Link = "link",
+    Email = "email",
+    Phone = "phone",
+    Callback = "callback",
+    Function = "function"
+}
+
+declare type NoArticlesFound = {
+    type: typeof AnswersActions.NO_ARTICLES_FOUND;
+    payload: {
+        index?: number;
+    };
+};
+
+/**
+ * Defines a URL redirect rule with pattern matching
+ * @example { source: '/knowledge/:id/:path', destination: '/knowledge/test/:path' }
+ */
+declare type RedirectRule = {
+    source: string;
+    destination: string;
+};
+
+declare interface SearchResult {
+    id: string;
+    title: string;
+    url: string;
+}
+
+declare type SetAnswerError = {
+    type: typeof AnswersActions.SET_ANSWER_ERROR;
+    payload: {
+        error: string;
+        index?: number;
+    };
+};
+
+declare type SetAnswers = {
+    type: typeof AnswersActions.SET_ANSWERS;
+    payload: {
+        answers: Answer[];
+    };
+};
+
+declare type SetFollowUpQuestions = {
+    type: typeof AnswersActions.SET_FOLLOW_UP_QUESTIONS;
+    payload: {
+        questions: string[];
+        index?: number;
+    };
+};
+
+declare type SetSearchResults = {
+    type: typeof AnswersActions.SET_SEARCH_RESULTS;
+    payload: {
+        searchQueryId: string;
+        results: SearchResult[];
+        index?: number;
+        state?: Answer['state'];
+    };
+};
+
+declare type SetUserFeedback = {
+    type: typeof AnswersActions.SET_USER_FEEDBACK;
+    payload: {
+        feedback: FeedbackResponse;
+        index?: number;
+    };
+};
+
+declare interface Suggestion {
+    id: string;
+    question: string;
+    conversationId?: string;
+    messageCount?: number;
+}
+
+declare interface TextConfig {
+    headerText?: string;
+    searchPlaceholder?: string;
+    attachImageText?: string;
+    allDocumentsText?: string;
+    loadingSearchText?: string;
+    loadingAnswerText?: string;
+    errorText?: string;
+    followUpPlaceholder?: string;
+    positiveAnswerText?: string;
+    negativeAnswerText?: string;
+    suggestionsTitle?: string;
+    uncertaintyFallbackText?: Record<string, string>;
+}
+
+declare type UrlString = string & {
+    __url: never;
+};
+
+export declare const useChatSearch: () => ChatSearchContextProps;
+
+export declare const useIsChatSearchDirty: () => boolean;
+
+export { }

package/dist/collapsible.d.ts

@@ -0,0 +1,10 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import { default as default_2 } from 'react';
+
+export declare const Collapsible: default_2.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CollapsibleContent: default_2.FC<CollapsiblePrimitive.CollapsibleContentProps>;
+
+export declare const CollapsibleTrigger: default_2.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & default_2.RefAttributes<HTMLButtonElement>>;
+
+export { }