@brainfish-ai/widgets-initiator 0.1.1-beta → 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,801 @@
+/// <reference types="react" />
+import * as React from 'react';
+import React__default, { ReactNode, FC } from 'react';
+import { JSONSchemaType } from 'ajv';
+import { Options } from 'react-markdown';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import { VariantProps } from 'class-variance-authority';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogProps } from '@radix-ui/react-dialog';
+
+declare function customColor(cssVariable: string, fallbackColor?: string): ({ opacityVariable, opacityValue }: {
+    opacityVariable: string;
+    opacityValue: string;
+}) => string;
+
+declare const BrainfishColors: {
+    primary: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: ({ opacityVariable, opacityValue }: {
+            opacityVariable: string;
+            opacityValue: string;
+        }) => string;
+        foreground: ({ opacityVariable, opacityValue }: {
+            opacityVariable: string;
+            opacityValue: string;
+        }) => string;
+    };
+    dark: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    orange: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    yellow: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    green: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    blue: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    purple: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    pink: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+    red: {
+        50: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        DEFAULT: string;
+    };
+};
+
+type FeatureFlags = { [key: string]: boolean | string | number };
+
+type JSONSchema<T> = JSONSchemaType<T>;
+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 enum ActionType {
+    CallPhone = "call_phone",
+    OpenUrl = "open_url",
+    SendEmail = "send_email",
+    RunCallback = "run_callback"
+}
+type FeedbackResponse = 'accept' | 'reject';
+/**
+ * Defines a URL redirect rule with pattern matching
+ * @example { source: '/knowledge/:id/:path', destination: '/knowledge/test/:path' }
+ */
+type RedirectRule = {
+    source: string;
+    destination: string;
+};
+type MarkdownTextBlock = {
+    id: string;
+    type: 'markdown-text';
+    text: string;
+};
+type ActionButtonsBlock = {
+    id: string;
+    type: 'action-buttons';
+};
+type ActionInputFormBlock = {
+    id: string;
+    type: 'action-input-form';
+    state: 'ready' | 'processing' | 'completed';
+    actionId: string;
+    initialValues: ActionInputs;
+    schema: ActionInputsSchema;
+    onSubmit?: (inputs: ActionInputs) => void;
+    inputs: ActionInput[];
+};
+type ActionInput = {
+    name: string;
+    required: boolean;
+    schema: {
+        type: string;
+        title: string;
+        description: string;
+        oneOf?: {
+            const: string;
+            title: string;
+        }[];
+    };
+    type: string;
+    ui: {
+        type: string;
+    };
+};
+type AnswerBlock = MarkdownTextBlock | ActionButtonsBlock | ActionInputFormBlock;
+type AnswerState = 'fetching-search-results' | 'fetching-stream' | 'streaming' | 'getting-action-inputs' | 'completed';
+type Action = {
+    id: string;
+    type: ActionType;
+    action: {
+        version: string;
+        options: {
+            title?: string;
+            [key: string]: any;
+        };
+    };
+};
+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[];
+}
+type ActionInputValue = string | number | boolean | null;
+type ActionInputs = Record<string, ActionInputValue>;
+type ActionInputsSchema = JSONSchemaType<ActionInputs>;
+interface SearchResult {
+    id: string;
+    title: string;
+    url: string;
+}
+interface Collection {
+    id: string;
+    name: string;
+}
+interface Suggestion {
+    id: string;
+    question: string;
+    conversationId?: string;
+    messageCount?: number;
+}
+interface ChatSearchProps {
+    suggestions?: Suggestion[];
+    collections?: Array<{
+        id: string;
+        name: string;
+    }>;
+    selectedCollectionId?: string;
+    onCollectionChange?: (collectionId: string) => void;
+    searchEndpoint: string;
+    answerEndpoint: string;
+    answerStreamEndpoint: string;
+    feedbackEndpoint?: string;
+    loadConversationEndpoint?: string;
+    followUpQuestionsEndpoint?: string;
+    autocompleteEndpoint?: 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[];
+    attributesSigned?: string;
+}
+interface ChatSearchState {
+    showResults: boolean;
+    answers: Answer[];
+    isLoading: boolean;
+    error?: string;
+}
+type UrlString = string & {
+    __url: never;
+};
+declare enum NextBestActionType {
+    Link = "link",
+    Email = "email",
+    Phone = "phone",
+    Callback = "callback",
+    Function = "function"
+}
+type NextBestAction = {
+    id?: string;
+    label: string;
+    type: NextBestActionType;
+    icon?: string | UrlString;
+    value: any;
+};
+
+interface ChatSearchHandle {
+    createNewThread: (firstQuery?: string) => void;
+    showFollowUpThread: (show: boolean) => void;
+    subscribeToStateChanges: (callback: (state: ChatSearchState) => void) => () => void;
+    focusSearchField: () => void;
+    showCloseButton: (showButton: boolean) => void;
+}
+declare const ChatSearch: React__default.ForwardRefExoticComponent<ChatSearchProps & React__default.RefAttributes<ChatSearchHandle>>;
+
+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 GET_ACTION_INPUTS: "answers/request_action_inputs";
+    readonly INVOKE_ACTION: "answers/invoke_action";
+    readonly ADD_ACTION_BUTTONS: "answers/add_action_buttons";
+};
+type SetAnswers = {
+    type: typeof AnswersActions.SET_ANSWERS;
+    payload: {
+        answers: Answer[];
+    };
+};
+type ClearAll = {
+    type: typeof AnswersActions.CLEAR_ALL;
+};
+type AppendNewAnswer = {
+    type: typeof AnswersActions.APPEND_NEW_ANSWER;
+    payload: {
+        id?: string;
+        query: string;
+    };
+};
+type SetSearchResults = {
+    type: typeof AnswersActions.SET_SEARCH_RESULTS;
+    payload: {
+        searchQueryId: string;
+        results: SearchResult[];
+        index?: number;
+    };
+};
+type AppendAnswerChunk = {
+    type: typeof AnswersActions.APPEND_ANSWER_CHUNK;
+    payload: {
+        text: string;
+        index?: number;
+    };
+};
+type SetAnswerError = {
+    type: typeof AnswersActions.SET_ANSWER_ERROR;
+    payload: {
+        error: string;
+        index?: number;
+    };
+};
+type SetUserFeedback = {
+    type: typeof AnswersActions.SET_USER_FEEDBACK;
+    payload: {
+        feedback: FeedbackResponse;
+        index?: number;
+    };
+};
+type ClearUserFeedback = {
+    type: typeof AnswersActions.CLEAR_USER_FEEDBACK;
+    payload: {
+        index?: number;
+    };
+};
+type SetFollowUpQuestions = {
+    type: typeof AnswersActions.SET_FOLLOW_UP_QUESTIONS;
+    payload: {
+        questions: string[];
+        index?: number;
+    };
+};
+type AppendBlock = {
+    type: typeof AnswersActions.APPEND_BLOCK;
+    payload: {
+        block: AnswerBlock;
+        index?: number;
+    };
+};
+type CompleteAnswer = {
+    type: typeof AnswersActions.COMPLETE_ANSWER;
+    payload: {
+        index?: number;
+    };
+};
+type MarkAsUncertain = {
+    type: typeof AnswersActions.MARK_AS_UNCERTAIN;
+    payload: {
+        uncertaintyText: string;
+        index?: number;
+    };
+};
+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;
+    };
+};
+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;
+    };
+};
+type InvokeAction = {
+    type: typeof AnswersActions.INVOKE_ACTION;
+    payload: {
+        index?: number;
+    };
+};
+type AnswerListAction = SetAnswers | ClearAll | AppendNewAnswer | SetSearchResults | AppendAnswerChunk | SetAnswerError | SetUserFeedback | ClearUserFeedback | SetFollowUpQuestions | AppendBlock | CompleteAnswer | MarkAsUncertain | InvokeAction | GetActionInputs | AddActionButtons;
+
+interface ChatSearchContextProps {
+    query: string;
+    setQuery: React__default.Dispatch<React__default.SetStateAction<string>>;
+    queryId: string;
+    setQueryId: React__default.Dispatch<React__default.SetStateAction<string>>;
+    followUpQuery: string;
+    setFollowUpQuery: React__default.Dispatch<React__default.SetStateAction<string>>;
+    isSearching: boolean;
+    setIsSearching: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    showResults: boolean;
+    setShowResults: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    answers: Answer[];
+    answerListDispatch: React__default.Dispatch<AnswerListAction>;
+    activeAnswerIndex: number;
+    setActiveAnswerIndex: React__default.Dispatch<React__default.SetStateAction<number>>;
+    conversationId: string | undefined;
+    setConversationId: (id: string) => void;
+    clearConversationId: () => void;
+    isLoadingConversation: boolean;
+    setIsLoadingConversation: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    loadError: string;
+    setLoadError: React__default.Dispatch<React__default.SetStateAction<string>>;
+    showMobileCloseWidgetButton: boolean;
+    setShowMobileCloseWidgetButton: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+}
+declare const ChatSearchProvider: React__default.FC<{
+    children: ReactNode;
+    searchPath?: string;
+}>;
+declare const useChatSearch: () => ChatSearchContextProps;
+
+declare const useIsChatSearchDirty: () => boolean;
+
+interface Props$1 {
+    language: string;
+    value: string;
+}
+declare const CodeBlock: FC<Props$1>;
+
+type Message = {
+    content: string;
+    uncertaintyFallbackText?: Record<string, string>;
+};
+interface Props {
+    message: Message;
+    isStreaming?: boolean;
+    redirectRules?: RedirectRule[];
+}
+declare const FormattedMessage: FC<Props>;
+
+interface MemoizedReactMarkdownProps extends Options {
+    isStreaming?: boolean;
+}
+declare const MemoizedReactMarkdown: FC<MemoizedReactMarkdownProps>;
+
+interface MermaidDiagramProps {
+    content: string;
+}
+declare const MermaidDiagram: React__default.FC<MermaidDiagramProps>;
+
+interface ZoomableImageProps {
+    src?: string;
+    alt?: string;
+}
+declare const ZoomableImage: React.FC<ZoomableImageProps>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "dark" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const Collapsible: React__default.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React__default.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React__default.FC<CollapsiblePrimitive.CollapsibleContentProps>;
+
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const TooltipProvider: ({ delayDuration, ...props }: TooltipPrimitive.TooltipProviderProps) => React.JSX.Element;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    background?: string;
+    textColor?: string;
+    borderColor?: string;
+}
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_dist_types.ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string | undefined;
+    shouldFilter?: boolean | undefined;
+    filter?: ((value: string, search: string, keywords?: string[] | undefined) => number) | undefined;
+    defaultValue?: string | undefined;
+    value?: string | undefined;
+    onValueChange?: ((value: string) => void) | undefined;
+    loop?: boolean | undefined;
+    disablePointerSelection?: boolean | undefined;
+    vimBindings?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => React.JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string | undefined;
+    onValueChange?: ((search: string) => void) | undefined;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string | undefined;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string | undefined;
+    forceMount?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean | undefined;
+    onSelect?: ((value: string) => void) | undefined;
+    value?: string | undefined;
+    keywords?: string[] | undefined;
+    forceMount?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+type SelectOption = {
+    label: string;
+    value: string;
+};
+interface SimpleSelectProps {
+    options: SelectOption[];
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    appendToBody?: boolean;
+}
+declare function SimpleSelect({ options, value, onChange, placeholder, disabled, className, appendToBody, }: SimpleSelectProps): React.JSX.Element;
+
+interface DatePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    className?: string;
+    placeholder?: string;
+}
+declare function DatePicker({ date, setDate, className, placeholder }: DatePickerProps): React.JSX.Element;
+
+interface ComboboxProps {
+    options: {
+        value: string;
+        label: string;
+    }[];
+    defaultValueLabel: string;
+    placeholder: string;
+    noResultsLabel: string;
+    className?: string;
+    onOpenChange?: (open: boolean) => void;
+    onChange?: (value: string) => void;
+}
+declare function Combobox({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, }: ComboboxProps): React.JSX.Element;
+
+interface FilterOption {
+    id: string;
+    label: string;
+}
+declare enum Operator {
+    IS = "is",
+    IS_NOT = "is not",
+    CONTAINS = "contains",
+    DOES_NOT_CONTAIN = "does not contain",
+    STARTS_WITH = "starts with"
+}
+interface FilterValue {
+    id: string | number;
+    source?: string;
+    operator?: Operator;
+    value?: string;
+}
+/**
+ * Filter rules for each source
+ * How this works:
+ * - You can define the rules for each source
+ * - The rules are used to determine the available operators and value type
+ * - The input type is used to determine the type of input displayed in when the dropdown is opened
+ * - The getValueOptions function is used to determine the available options for the value
+ *
+ * @example
+ * {
+ *   'sourceId': {
+ *     operators: [
+ *       { id: 'is', label: 'is' },
+ *       { id: 'is not', label: 'is not' },
+ *     ],
+ *     inputType: 'dropdown' | 'custom',
+ *     getValueOptions?: () => FilterOption[],
+ *   },
+ * }
+ */
+interface FilterRules {
+    [sourceId: string]: {
+        operators: FilterOption[];
+        inputType: 'dropdown' | 'custom';
+        getValueOptions?: () => FilterOption[];
+    };
+}
+interface FilterProps {
+    filter: FilterValue;
+    sourceOptions: FilterOption[];
+    rules: FilterRules;
+    onSourceChange?: (sourceId: string) => void;
+    onRemoveFilter: (id: string | number) => void;
+    onFilterChange: (filter: FilterValue) => void;
+    selectPlaceholder?: string;
+    customValuePlaceholder?: string;
+    customValueButtonLabel?: string;
+    sourceFirstMessage?: string;
+}
+declare const Filter: React__default.ForwardRefExoticComponent<FilterProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface FiltersProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    filters: FilterValue[];
+    onFilterChange: (filter: FilterValue) => void;
+    onFilterRemove: (filterId: string | number) => void;
+    sourceOptions: FilterOption[];
+    rules: FilterRules;
+}
+declare const Filters: ({ filters, onFilterChange, onFilterRemove, sourceOptions, rules, className }: FiltersProps) => React__default.JSX.Element;
+
+export { BrainfishColors, Button, ChatSearch, ChatSearchProvider, CodeBlock, Collapsible, CollapsibleContent, CollapsibleTrigger, Combobox, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, DatePicker, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Filter, Filters, FormattedMessage, Input, Label, MemoizedReactMarkdown, MermaidDiagram, Operator, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, ScrollArea, ScrollBar, SimpleSelect, Switch, Textarea, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, ZoomableImage, buttonVariants, customColor, useChatSearch, useIsChatSearchDirty };
+export type { Answer, ButtonProps, ChatSearchHandle, ChatSearchProps, ChatSearchState, Collection, ComboboxProps, FilterOption, FilterRules, FilterValue, MemoizedReactMarkdownProps, Props, SelectOption, SimpleSelectProps, TooltipContentProps };