import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { ClassProp } from 'class-variance-authority/types';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ColumnDef } from '@tanstack/react-table';
import { ComponentProps } from 'react';
import { ConversationActionsProps } from './ConversationActions';
import { ConversationInputProps } from './ConversationInput';
import { ConversationMessagesProps } from './ConversationMessages';
import { ConversationStatusProps } from './ConversationStatus';
import { ConversationSuggestionsProps } from './ConversationSuggestions';
import { DayPicker } from 'react-day-picker';
import { default as default_2 } from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { DialogProps } from '@radix-ui/react-dialog';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { DropzoneOptions } from 'react-dropzone';
import { FC } from 'react';
import { Icon as Icon_2 } from '@phosphor-icons/react';
import { IconProps } from '@phosphor-icons/react';
import { JSONSchemaType } from 'ajv';
import * as LabelPrimitive from '@radix-ui/react-label';
import { Options } from 'react-markdown';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as React_2 from 'react';
import { ReactNode } from 'react';
import { Row } from '@tanstack/react-table';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { VariantProps } from 'class-variance-authority';

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 declare type AccountDropdownActionItem = {
    type?: 'action';
    id: string;
    label: string;
    icon?: React_2.ReactNode;
    onClick: () => void;
    /** Second line (e.g. "ID: xyz"); copy button shown when copyValue is set. */
    secondaryLabel?: React_2.ReactNode;
    copyValue?: string;
    onCopy?: (value: string) => void;
    /** Keyboard shortcut hint (e.g. "⌘K") shown on the right. */
    shortcut?: string;
};

export declare type AccountDropdownItem = AccountDropdownActionItem | AccountDropdownSubmenuItem;

declare interface AccountDropdownProps extends React_2.ComponentPropsWithoutRef<typeof DropdownMenu> {
    accountPhoto: string;
    accountName: string;
    /** Pass a flat array for a single group, or an array of arrays for multiple groups separated by dividers. */
    accountDropdownItems: AccountDropdownItem[] | AccountDropdownItem[][];
    teams: AccountDropdownTeam[];
    /** Side the dropdown opens on relative to the trigger. Defaults to 'bottom'. */
    side?: React_2.ComponentPropsWithoutRef<typeof DropdownMenuContent>['side'];
    /** Alignment of the dropdown relative to the trigger. Defaults to 'end'. */
    align?: React_2.ComponentPropsWithoutRef<typeof DropdownMenuContent>['align'];
    isSuperAdmin?: boolean;
}

/** Sub-option with a required `value`, used in radio-mode submenus. */
export declare type AccountDropdownRadioSubOption = Omit<AccountDropdownSubOption, 'value' | 'onClick'> & {
    value: string;
};

declare type AccountDropdownSubmenuBase = {
    type: 'submenu';
    id: string;
    label: string;
    icon?: React_2.ReactNode;
    /** Second line on the submenu trigger (e.g. "ID: xyz"); copy button when copyValue is set. */
    secondaryLabel?: React_2.ReactNode;
    copyValue?: string;
    onCopy?: (value: string) => void;
};

export declare type AccountDropdownSubmenuItem = AccountDropdownSubmenuBase & ({
    /** The currently selected value. When provided with onValueChange, renders items as a radio group with selection indicators. */
    value: string;
    onValueChange: (value: string) => void;
    items: AccountDropdownRadioSubOption[];
} | {
    value?: never;
    onValueChange?: never;
    items: AccountDropdownSubOption[];
});

export declare type AccountDropdownSubOption = {
    id: string;
    label: string;
    icon?: React_2.ReactNode;
    /** Required for radio mode. */
    value?: string;
    /** Used in plain (non-radio) mode. */
    onClick?: () => void;
    /** Keyboard shortcut hint (e.g. "⌘K") shown on the right. */
    shortcut?: string;
};

export declare type AccountDropdownTeam = {
    id: string;
    name: string;
    isCurrent: boolean;
    logoUrl?: string;
};

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",
    LaunchIntercomChat = "launch_intercom_chat",
    LaunchZendeskChat = "launch_zendesk_chat",
    LaunchZendeskMessenger = "launch_zendesk_messenger",
    LaunchFreshdesk = "launch_freshdesk",
    LaunchSupportTicketForm = "launch_support_ticket_form",
    LaunchZendeskSunshineChat = "launch_zendesk_sunshine_chat"
}

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;
    };
};

/**
 * Curried function that adds popup widget-specific UTM parameters to URLs.
 * Uses 'brainfish' as source and 'popup_widget' as medium.
 */
export declare const addPopupWidgetUtm: (url: string) => string;

/**
 * Adds UTM parameters to a URL for tracking purposes.
 *
 * @param url The URL to add UTM parameters to
 * @param options UTM parameters to add (all optional)
 * @param options.source The UTM source (e.g., 'brainfish')
 * @param options.medium The UTM medium (e.g., 'popup_widget')
 * @param options.campaign Optional UTM campaign parameter
 * @returns The URL with UTM parameters added
 */
export declare function addUtmParameters(url: string, options: {
    source?: string;
    medium?: string;
    campaign?: string;
}): string;

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 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" | "suggestion" | "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" | "suggestion" | "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 declare const AlertTitle: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

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[];
    hasError?: boolean;
    attachments?: AnswerAttachment[];
}

declare interface AnswerAttachment {
    type: AttachmentType;
    url: string;
    filename?: string;
}

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 | SetAwaitingKnowledgeGroup | SetKnowledgeGroupSelected;

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";
    readonly SET_AWAITING_KNOWLEDGE_GROUP: "answers/set_awaiting_knowledge_group";
    readonly SET_KNOWLEDGE_GROUP_SELECTED: "answers/set_knowledge_group_selected";
};

declare type AnswerState = 'fetching-search-results' | 'fetching-stream' | 'streaming' | 'getting-action-inputs' | 'awaiting-knowledge-group' | '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;
        attachments?: AnswerAttachment[];
    };
};

export declare interface ArticleNavItem extends Omit<SidebarNavItem, 'Icon' | 'items'> {
    status?: 'discovery' | 'unpublished' | 'draft';
    hasChildren?: boolean;
    isLoadingChildren?: boolean;
    items?: ArticleNavItem[];
}

export declare type Attachment = {
    id: string;
    type: 'image' | 'file';
    name: string;
    url: string;
    file?: File;
};

export declare type AttachmentAction = {
    type: 'select-collection';
    collection: Collection_2;
} | {
    type: 'attach-tab';
} | {
    type: 'screenshot';
} | {
    type: 'record-video';
} | {
    type: 'add-file';
};

declare type AttachmentType = 'image' | 'file';

export declare function Avatar({ className, size, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Root> & {
    size?: 'default' | 'sm' | 'lg';
}): React_2.JSX.Element;

export declare function AvatarBadge({ className, ...props }: React_2.ComponentProps<'span'>): React_2.JSX.Element;

export declare function AvatarFallback({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Fallback>): React_2.JSX.Element;

export declare function AvatarGroup({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function AvatarGroupCount({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function AvatarImage({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Image>): React_2.JSX.Element;

export declare function Badge({ className, variant, ...props }: BadgeProps): React_2.JSX.Element;

export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
}

export declare const badgeVariants: (props?: ({
    variant?: "default" | "disabled" | "destructive" | "success" | "warning" | null | undefined;
} & ClassProp) | undefined) => string;

declare function Body_2({ children }: {
    children?: default_2.ReactNode;
}): default_2.JSX.Element;

declare namespace Body_2 {
    var displayName: string;
}

export declare const BrainfishColors: {
    primary: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
        foreground: string;
    };
    dark: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    orange: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    yellow: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    lime: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    green: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    blue: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    teal: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    purple: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
    magenta: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: 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: {
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        1000: string;
        DEFAULT: string;
    };
};

export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare function ButtonGroup({ className, orientation, rounded, ...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;
    rounded?: boolean | null | undefined;
} & ClassProp) | undefined) => string;

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" | "suggestion" | "ghost" | "shadow" | "shadowSurface" | null | undefined;
    size?: "default" | "icon" | "xs" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

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 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 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;
    loadConversation: (conversationId: string) => void;
}

export declare interface ChatSearchProps {
    suggestions?: Suggestion_2[];
    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;
    uploadEndpoint?: string;
    feedbackEndpoint?: string;
    feedbackReasonEndpoint?: string;
    loadConversationEndpoint?: string;
    followUpQuestionsEndpoint?: string;
    autocompleteEndpoint?: string;
    contentTypeEndpoint?: string;
    disableFollowUpQuestions?: boolean;
    enableFileAttachment?: 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, conversation, }: {
        action: NextBestAction;
        searchQueryId: string;
        query: string;
        answer: string;
        conversation?: ConversationContext;
    }) => void;
    userData?: Record<string, unknown> | null;
    redirectRules?: RedirectRule[];
    secretAttributes?: string;
    allowedRegions?: string[];
    style?: React.CSSProperties;
    isAgentAssist?: boolean;
    isSearchWidget?: boolean;
    hideCitations?: boolean;
    conversationInlineSlot?: ReactNode;
    liveHumanAgentChatSlot?: ReactNode;
    knowledgeSourceGroups?: KnowledgeSourceGroup[];
}

export declare const ChatSearchProvider: default_2.FC<{
    children: ReactNode;
    searchPath?: string;
    contentTypeEndpoint?: string;
    widgetKey?: string;
}>;

export declare interface ChatSearchState {
    showResults: boolean;
    answers: Answer[];
    isLoading: boolean;
    error?: string;
}

export declare type Citation = {
    id: string;
    index: number;
    title: string;
    url: string;
};

declare type ClearAll = {
    type: typeof AnswersActions.CLEAR_ALL;
};

/**
 * Clear the font cache from localStorage
 * Useful for forcing a fresh fetch of fonts
 */
export declare const clearFontCache: () => void;

declare type ClearUserFeedback = {
    type: typeof AnswersActions.CLEAR_USER_FEEDBACK;
    payload: {
        index?: number;
    };
};

export declare const CodeBlock: FC<Props_2>;

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 declare interface Collection {
    id: string;
    name: string;
    siteEnabled?: boolean;
}

declare type Collection_2 = {
    id: string;
    label: string;
};

export declare function Combobox<T extends ComboboxItem = ComboboxItem>({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, dropdownWidth, value: controlledValue, disabled, renderItem, renderValue, renderTrigger, appendToBody, }: ComboboxProps<T>): React_2.JSX.Element;

export declare interface ComboboxItem {
    value: string;
    label: string;
    icon?: React_2.ReactNode;
    /** Additional data that can be passed to custom renderers */
    data?: any;
}

export declare interface ComboboxProps<T extends ComboboxItem = ComboboxItem> {
    options: T[];
    defaultValueLabel: string;
    placeholder: string;
    noResultsLabel: string;
    className?: string;
    dropdownWidth?: number;
    value?: string;
    /** Whether the combobox is disabled */
    disabled?: boolean;
    /** Callback on open state change */
    onOpenChange?: (open: boolean) => void;
    /** Callback on value change */
    onChange?: (value: string) => void;
    /** Custom render function for each item in the dropdown */
    renderItem?: (props: ComboboxRenderItemProps<T>) => React_2.ReactNode;
    /** Custom render function for the selected value in the trigger button */
    renderValue?: (item: T) => React_2.ReactNode;
    /** Custom render function for the entire trigger button content */
    renderTrigger?: (props: {
        selectedItem: T | undefined;
        isOpen: boolean;
    }) => React_2.ReactNode;
    /**
     * When false, the dropdown stays in the React tree instead of portaling to body.
     * Use inside modals/dialogs so the list is not detached from the dialog layer.
     */
    appendToBody?: boolean;
}

export declare interface ComboboxRenderItemProps<T extends ComboboxItem = ComboboxItem> {
    item: T;
    isSelected: boolean;
    onSelect: () => void;
}

export declare const Command: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.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_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandDialog: ({ children, ...props }: DialogProps) => React_2.JSX.Element;

export declare const CommandEmpty: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandGroup: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
    heading?: React_2.ReactNode;
    value?: string | undefined;
    forceMount?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandInput: React_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>> & {
    ref?: React_2.Ref<HTMLInputElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | "asChild" | keyof React_2.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
    value?: string | undefined;
    onValueChange?: ((search: string) => void) | undefined;
} & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;

export declare const CommandItem: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
    disabled?: boolean | undefined;
    onSelect?: ((value: string) => void) | undefined;
    value?: string | undefined;
    keywords?: string[] | undefined;
    forceMount?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandList: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
    label?: string | undefined;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandSeparator: React_2.ForwardRefExoticComponent<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement> | undefined;
} & {
    asChild?: boolean | undefined;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
    alwaysRender?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandShortcut: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): React_2.JSX.Element;
    displayName: string;
};

declare type CompleteAnswer = {
    type: typeof AnswersActions.COMPLETE_ANSWER;
    payload: {
        index?: number;
    };
};

declare namespace Compounds {
    export {
        MainArea,
        Body_2 as Body,
        Header,
        LeftSidebar,
        Main,
        RightSidebar
    }
}

export declare type ContentBlock = TextBlock;

export declare type ContextPill = {
    id: string;
    label: string;
    icon?: string;
};

export declare const ContextPillBadge: ({ pill, onRemove }: ContextPillBadgeProps) => default_2.JSX.Element;

declare interface ContextPillBadgeProps {
    pill: ContextPill;
    onRemove?: (pill: ContextPill) => void;
}

export declare const Conversation: (({ messages, callbacks, children, suggestions, actions, placeholder, attachments, collections, contextPills, showBranding, className, }: ConversationProps) => default_2.JSX.Element) & {
    Messages: ({ className, bottomPadding, onContentBehind }: ConversationMessagesProps) => default_2.JSX.Element;
    Input: ({ placeholder, attachments, collections, contextPills, disabled, isElevated, className, }: ConversationInputProps) => default_2.JSX.Element;
    Suggestions: ({ items, className }: ConversationSuggestionsProps) => default_2.JSX.Element | null;
    Actions: ({ actions, onActionClick, className }: ConversationActionsProps) => default_2.JSX.Element | null;
    Loading: ({ className }: ConversationStatusProps) => default_2.JSX.Element;
};

export declare type ConversationAction = {
    id: string;
    label: string;
    icon?: string;
    description?: string;
};

export declare const ConversationActions: ({ actions, onActionClick, className }: ConversationActionsProps_2) => default_2.JSX.Element | null;

declare interface ConversationActionsProps_2 {
    actions: ConversationAction[];
    onActionClick?: (action: ConversationAction) => void;
    className?: string;
}

export declare type ConversationCallbacks = {
    onSend?: (text: string, attachments?: Attachment[]) => void;
    onStop?: () => void;
    onSuggestionClick?: (suggestion: Suggestion) => void;
    onActionClick?: (action: ConversationAction, messageId: string) => void;
    onFeedback?: (messageId: string, feedback: 'positive' | 'negative') => void;
    onCitationClick?: (citation: Citation) => void;
    onAttachmentAction?: (action: AttachmentAction) => void;
    onContextPillRemove?: (pill: ContextPill) => void;
    onCopy?: (messageId: string, content: string) => void;
};

export declare type ConversationContext = {
    conversationId?: string;
    messages: ConversationMessage[];
};

export declare interface ConversationContextValue {
    messages: Message[];
    callbacks: ConversationCallbacks;
    isStreaming: boolean;
}

export declare const ConversationInput: ({ placeholder, attachments, collections, contextPills, disabled, isElevated, className, }: ConversationInputProps_2) => default_2.JSX.Element;

declare interface ConversationInputProps_2 {
    placeholder?: string;
    attachments?: Attachment[];
    collections?: Collection_2[];
    contextPills?: ContextPill[];
    disabled?: boolean;
    isElevated?: boolean;
    className?: string;
}

export declare type ConversationMessage = {
    question: string;
    answer: string;
};

export declare const ConversationMessageAssistant: ({ message, className }: ConversationMessageAssistantProps) => default_2.JSX.Element;

declare interface ConversationMessageAssistantProps {
    message: Message;
    className?: string;
}

export declare const ConversationMessages: ({ className, bottomPadding, onContentBehind }: ConversationMessagesProps_2) => default_2.JSX.Element;

declare interface ConversationMessagesProps_2 {
    className?: string;
    bottomPadding?: number;
    onContentBehind?: (isBehind: boolean) => void;
}

export declare const ConversationMessageUser: ({ message, className }: ConversationMessageUserProps) => default_2.JSX.Element;

declare interface ConversationMessageUserProps {
    message: Message;
    className?: string;
}

declare interface ConversationProps {
    messages: Message[];
    callbacks: ConversationCallbacks;
    children?: ReactNode;
    suggestions?: Suggestion[];
    actions?: ConversationAction[];
    placeholder?: string;
    attachments?: Attachment[];
    collections?: Collection_2[];
    contextPills?: ContextPill[];
    showBranding?: boolean;
    className?: string;
}

export declare function ConversationProvider({ messages, callbacks, children }: ConversationProviderProps): default_2.JSX.Element;

declare interface ConversationProviderProps {
    messages: Message[];
    callbacks: ConversationCallbacks;
    children: default_2.ReactNode;
}

export declare const ConversationStatus: ({ className }: ConversationStatusProps_2) => default_2.JSX.Element;

declare interface ConversationStatusProps_2 {
    className?: string;
}

export declare const ConversationSuggestions: ({ items, className }: ConversationSuggestionsProps_2) => default_2.JSX.Element | null;

declare interface ConversationSuggestionsProps_2 {
    items: Suggestion[];
    className?: string;
}

export declare function DataTable<TData extends Record<string, any> & {
    id?: string | number;
}, TValue>({ columns, data, getRowCanExpand, className, expandeRowClassName, isLoading, skeletonRowCount, ...props }: DataTableProps<TData, TValue>): default_2.JSX.Element;

export declare interface DataTableProps<TData, TValue> extends default_2.HTMLAttributes<HTMLDivElement> {
    columns: ExtendedColumnDef<TData, TValue>[];
    data: TData[];
    getRowCanExpand?: (row: Row<TData>) => boolean;
    className?: string;
    expandeRowClassName?: string;
    isLoading?: boolean;
    skeletonRowCount?: number;
}

export declare function DatePicker({ date, setDate, className, placeholder }: DatePickerProps): React_2.JSX.Element;

declare interface DatePickerProps {
    date: Date | undefined;
    setDate: (date: Date | undefined) => void;
    className?: string;
    placeholder?: string;
}

export declare const Dialog: React_2.FC<DialogPrimitive.DialogProps>;

export declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const DialogContent: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const DialogFooter: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
    displayName: string;
};

export declare const DialogHeader: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
    displayName: string;
};

export declare const DialogOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DialogPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;

export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const DivButton: React_2.ForwardRefExoticComponent<DivButtonProps & React_2.RefAttributes<HTMLDivElement>>;

export declare interface DivButtonProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof divButtonVariants> {
    asChild?: boolean;
}

export declare const divButtonVariants: (props?: ({
    variant?: "link" | "dark" | "default" | "destructive" | "outline" | "secondary" | "suggestion" | "ghost" | "shadow" | "shadowSurface" | null | undefined;
    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const DropdownMenu: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;

export declare const DropdownMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
    /** Optional second row (e.g. ID + copy); consumer supplies full content as ReactNode. */
    secondaryRow?: React_2.ReactNode;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;

export declare const DropdownMenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuShortcut: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): React_2.JSX.Element;
    displayName: string;
};

export declare const DropdownMenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;

export declare const DropdownMenuSubContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
    /** Optional second row (e.g. ID + copy); consumer supplies full content as ReactNode. */
    secondaryRow?: React_2.ReactNode;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare type ExtendedColumnDef<TData, TValue = unknown> = ColumnDef<TData, TValue> & {
    expandedContent?: (row: Row<TData>) => default_2.ReactNode;
};

declare type FeatureFlags = {
    [key: string]: boolean | string | number;
};

declare type FeedbackResponse = 'accept' | 'reject';

export declare function FileUpload({ onDropAccepted, onDropRejected, accept, maxSize, // 5MB
    maxFiles, multiple, className, disabled, title, description, supportsMessage, children, }: FileUploadProps): default_2.JSX.Element;

export declare interface FileUploadProps extends DropzoneOptions {
    className?: string;
    title?: string;
    description?: ReactNode;
    supportsMessage?: ReactNode;
    children?: ReactNode;
}

export declare const FileUploadStatus: default_2.FC<FileUploadStatusProps>;

declare interface FileUploadStatusProps {
    uploads: UploadState[];
    className?: string;
    timeRemaining?: string;
    onCancelUpload?: (e: default_2.MouseEvent<HTMLButtonElement>) => void;
    steps?: ProcessingStep[];
    title?: string;
}

export declare const Filter: default_2.ForwardRefExoticComponent<FilterProps & default_2.RefAttributes<{
    focus: () => void;
}>>;

export declare interface FilterOption {
    id: string;
    label: string;
}

export declare 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;
}

/**
 * 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
 * - multiSelect determines if multiple values can be selected for dropdown type
 *
 * @example
 * {
 *   'sourceId': {
 *     operators: [
 *       { id: 'is', label: 'is' },
 *       { id: 'is not', label: 'is not' },
 *     ],
 *     inputType: 'dropdown' | 'custom',
 *     multiSelect?: boolean,
 *     getValueOptions?: () => FilterOption[],
 *   },
 * }
 */
export declare interface FilterRules {
    [sourceId: string]: {
        operators: FilterOption[];
        inputType: 'dropdown' | 'custom';
        multiSelect?: boolean;
        getValueOptions?: () => FilterOption[];
    };
}

export declare const Filters: ({ filters, onFilterChange, onFilterRemove, onFilterAdd, sourceOptions, rules, className, }: FiltersProps) => default_2.JSX.Element;

declare interface FiltersProps extends default_2.HTMLAttributes<HTMLDivElement> {
    filters: FilterValue[];
    onFilterChange: (filter: FilterValue) => void;
    onFilterRemove: (filterId: string | number) => void;
    onFilterAdd?: (filter: FilterValue) => void;
    sourceOptions: FilterOption[];
    rules: FilterRules;
}

export declare interface FilterValue {
    id: string | number;
    source?: string;
    operator?: Operator;
    value?: string | string[];
}

export declare interface FontOption {
    value: string;
    label: string;
    category?: string;
    variants?: string[];
}

/**
 * FontPicker - A searchable dropdown for selecting Google Fonts
 *
 * @example
 * ```tsx
 * const [font, setFont] = useState('Inter');
 *
 * <FontPicker
 *   apiKey="YOUR_API_KEY"
 *   value={font}
 *   onChange={setFont}
 *   placeholder="Select a font"
 * />
 * ```
 */
export declare function FontPicker({ value, onChange, apiKey, placeholder, searchPlaceholder, noResultsText, loadingText, disabled, className, dropdownWidth, maxFonts, onError, }: FontPickerProps): React_2.JSX.Element;

/**
 * Individual font item in the dropdown list
 * Loads font on mount for preview using Intersection Observer
 * Memoized to prevent unnecessary re-renders
 */
export declare const FontPickerItem: React_2.NamedExoticComponent<FontPickerItemProps>;

export declare interface FontPickerItemProps {
    font: FontOption;
    isSelected: boolean;
    onSelect: () => void;
}

export declare interface FontPickerProps {
    /** Currently selected font family */
    value?: string;
    /** Callback when font selection changes */
    onChange?: (fontFamily: string) => void;
    /** Google Fonts API key (required) */
    apiKey: string;
    /** Placeholder text when no font is selected */
    placeholder?: string;
    /** Text shown in search input */
    searchPlaceholder?: string;
    /** Text shown when no fonts match the search */
    noResultsText?: string;
    /** Text shown while fonts are loading */
    loadingText?: string;
    /** Whether the picker is disabled */
    disabled?: boolean;
    /** Additional CSS classes for the trigger button */
    className?: string;
    /** Width of the dropdown (defaults to trigger width) */
    dropdownWidth?: number;
    /** Maximum number of fonts to display (for performance) */
    maxFonts?: number;
    /** Callback when an error occurs fetching fonts */
    onError?: (error: Error) => void;
}

export declare const formatFileSize: (bytes: number) => string;

export declare const FormattedMessage: FC<Props>;

export declare const FullLayout: FullLayoutCompound;

declare type FullLayoutCompound = typeof FullLayoutWithFlags & {
    MainArea: typeof Compounds.MainArea;
    Body: typeof Compounds.Body;
    Header: typeof Compounds.Header;
    LeftSidebar: typeof Compounds.LeftSidebar;
    Main: typeof Compounds.Main;
    RightSidebar: typeof Compounds.RightSidebar;
};

export declare interface FullLayoutContextValue {
    isSideNavOpen: boolean;
    isRightSidebarOpen: boolean;
    toggleSidebar: () => void;
    openRightSidebar: () => void;
    closeRightSidebar: () => void;
    toggleRightSidebar: () => void;
    showSidenav: () => void;
    disableLeftSideNav: boolean;
    leftNavWidth: number;
    isMobile: boolean;
    sideNavRef: default_2.RefObject<HTMLDivElement | null>;
    rightSidebarRef: default_2.RefObject<HTMLElement | null>;
    sidebarToggleRef: default_2.RefObject<HTMLButtonElement | null>;
    handleResizeStart: (e: default_2.MouseEvent) => void;
    handleResizeKeyDown: (e: default_2.KeyboardEvent) => void;
    ariaValuenow: number;
    ariaValuemin: number;
    ariaValuemax: number;
    /** Mirrors `FullLayout` prop; `FullLayout.Main` uses it for viewport height when Radix ScrollArea is off. */
    disableMainScrollArea: boolean;
}

export declare const FullLayoutHeader: default_2.ForwardRefExoticComponent<FullLayoutHeaderProps & default_2.RefAttributes<HTMLElement>>;

export declare interface FullLayoutHeaderProps extends default_2.ComponentPropsWithoutRef<'header'> {
    onOpenLeft?: () => void;
    onOpenRight?: () => void;
}

export declare const FullLayoutLeftSidebar: default_2.ForwardRefExoticComponent<FullLayoutLeftSidebarProps & default_2.RefAttributes<HTMLDivElement>>;

export declare interface FullLayoutLeftSidebarProps extends Omit<default_2.ComponentPropsWithoutRef<'div'>, 'children'> {
    open: boolean;
    widthPx: number;
    onResizeStart: (e: default_2.MouseEvent) => void;
    onResizeKeyDown: (e: default_2.KeyboardEvent) => void;
    ariaValuenow: number;
    ariaValuemin: number;
    ariaValuemax: number;
    sidebarProps: ComponentProps<typeof Sidebar>;
}

/** Nav state derived from route (e.g. active ids). Provided by Platform; when null, layout uses props only. */
export declare interface FullLayoutNavState {
    appNavActiveId?: string;
    sectionNavActiveId?: string;
    activeArticleId?: string;
}

export declare const FullLayoutNavStateContext: default_2.Context<FullLayoutNavState | null>;

export declare interface FullLayoutProps extends FullLayoutRootProps {
    /** Feature flags for layout/header (e.g. platform.brainfish-native.enabled). Passed through to FeatureFlagProvider. */
    featureFlags?: FeatureFlags;
}

export declare function FullLayoutProvider({ value, children }: FullLayoutProviderProps): default_2.JSX.Element;

declare interface FullLayoutProviderProps {
    value: FullLayoutContextValue;
    children: default_2.ReactNode;
}

export declare const FullLayoutRightSidebar: default_2.ForwardRefExoticComponent<FullLayoutRightSidebarProps & default_2.RefAttributes<HTMLElement>>;

export declare interface FullLayoutRightSidebarProps extends Omit<default_2.ComponentPropsWithoutRef<'aside'>, 'children'> {
    open: boolean;
    children: default_2.ReactNode;
    scrollable?: boolean;
}

export declare interface FullLayoutRootProps {
    children?: default_2.ReactNode;
    disableLeftSideNav?: boolean;
    /** When true, main column uses a plain div (no Radix ScrollArea); viewport height is applied on `FullLayout.Main`. */
    disableMainScrollArea?: boolean;
    className?: string;
    /** When true, the right sidebar is always open and cannot be toggled. */
    forceRightSidebarOpen?: boolean;
}

declare function FullLayoutWithFlags(props: FullLayoutProps): default_2.JSX.Element;

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;
    };
};

/**
 * Get cached fonts from localStorage
 */
export declare const getCachedFonts: () => FontOption[] | null;

declare function Header(props: ComponentProps<typeof HeaderNav>): default_2.JSX.Element | null;

declare namespace Header {
    var displayName: string;
}

export declare const HEADER_NAV_HEIGHT = 60;

export declare const HeaderNav: React_2.ForwardRefExoticComponent<HeaderNavProps & React_2.RefAttributes<HTMLElement>>;

declare interface HeaderNavProps extends React_2.ComponentPropsWithoutRef<'header'>, Omit<AccountDropdownProps, 'dir'> {
    isSideNavOpen?: boolean;
    onSideNavigationToggle: () => void;
    onHelpClick: () => void;
    onBrainfishNativeClick: () => void;
    onLogoNav: () => void;
    isHomePath?: boolean;
    showSuggestionAction?: boolean;
    suggestionAction?: React_2.ReactNode;
    onSuggestionActionClick?: () => void;
    showSidebarToggle?: boolean;
    isSuperAdmin?: boolean;
    isViewer?: boolean;
    /** Ref for the sidebar toggle button; used by layout to move focus here when sidebar is collapsed. */
    sidebarToggleRef?: React_2.Ref<HTMLButtonElement>;
}

export declare const Icon: default_2.ForwardRefExoticComponent<Omit<PhosphorIconProps, "ref"> & default_2.RefAttributes<SVGSVGElement>>;

export declare const Input: default_2.ForwardRefExoticComponent<InputProps & default_2.RefAttributes<HTMLInputElement>>;

export declare interface InputProps extends default_2.InputHTMLAttributes<HTMLInputElement> {
    startIcon?: Icon_2;
    endIcon?: Icon_2;
    onStartIconClick?: () => void;
    onEndIconClick?: () => void;
}

export declare function InputWithTags({ title, placeholder, tags, value: controlledValue, defaultValue, onChange, onTagClick, singleValue, className, inputClassName, tagsClassName, disabled, name, id, required, maxLength, minLength, rows, }: InputWithTagsProps): React_2.JSX.Element;

export declare interface InputWithTagsProps {
    title: string;
    placeholder?: string;
    tags: Tag[];
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    onTagClick?: (tag: Tag) => void;
    singleValue?: boolean;
    className?: string;
    inputClassName?: string;
    tagsClassName?: string;
    disabled?: boolean;
    name?: string;
    id?: string;
    required?: boolean;
    maxLength?: number;
    minLength?: number;
    rows?: number;
}

declare type InvokeAction = {
    type: typeof AnswersActions.INVOKE_ACTION;
    payload: {
        index?: number;
    };
};

export declare function Item({ className, variant, size, asChild, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
    asChild?: boolean;
}): React_2.JSX.Element;

export declare function ItemActions({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemContent({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemDescription({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare function ItemFooter({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemGroup({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemHeader({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare type ItemLinkComponent = React_2.ComponentType<React_2.ComponentPropsWithoutRef<'a'> & {
    'data-sidebar-item-id'?: string;
    'data-sidebar-item-type'?: 'app' | 'article' | 'section';
}>;

export declare function ItemMedia({ className, variant, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof itemMediaVariants>): React_2.JSX.Element;

declare const itemMediaVariants: (props?: ({
    variant?: "image" | "default" | "icon" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function ItemSeparator({ className, ...props }: React_2.ComponentProps<typeof Separator>): React_2.JSX.Element;

export declare function ItemTitle({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

declare const itemVariants: (props?: ({
    variant?: "default" | "outline" | "muted" | null | undefined;
    size?: "default" | "sm" | null | undefined;
} & ClassProp) | undefined) => string;

declare type JSONSchema<T> = JSONSchemaType<T>;

export declare interface KnowledgeSourceGroup {
    id: string;
    name: string;
    collectionIds: string[];
}

export declare const Label: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ClassProp | undefined) => string> & React_2.RefAttributes<HTMLLabelElement>>;

declare function LeftSidebar(props: ComponentProps<typeof Sidebar>): default_2.JSX.Element | null;

declare namespace LeftSidebar {
    var displayName: string;
}

export declare type LoadedDiffDoc = {
    isNew: boolean;
    diffTitle: string;
    diffContent: default_2.ReactNode;
};

/**
 * Load a Google Font stylesheet dynamically
 */
export declare const loadFont: (fontFamily: string) => void;

export declare const Logo: React_2.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React_2.RefAttributes<SVGSVGElement>>;

export declare type LogoColor = 'default' | 'outline' | 'fill';

export declare interface LogoProps extends React_2.SVGProps<SVGSVGElement> {
    variant: LogoVariant;
    color?: LogoColor;
}

export declare type LogoVariant = 'mark' | 'text' | 'full';

declare function Main({ children, className }: {
    children?: default_2.ReactNode;
    className?: string;
}): default_2.JSX.Element;

declare namespace Main {
    var displayName: string;
}

declare function MainArea({ children }: {
    children?: default_2.ReactNode;
}): default_2.JSX.Element;

declare namespace MainArea {
    var displayName: string;
}

declare type MarkAsUncertain = {
    type: typeof AnswersActions.MARK_AS_UNCERTAIN;
    payload: {
        uncertaintyText: string;
        index?: number;
    };
};

declare type MarkdownTextBlock = {
    id: string;
    type: 'markdown-text';
    text: string;
};

export declare const MemoizedIcon: default_2.MemoExoticComponent<default_2.ForwardRefExoticComponent<Omit<PhosphorIconProps, "ref"> & default_2.RefAttributes<SVGSVGElement>>>;

export declare const MemoizedReactMarkdown: FC<MemoizedReactMarkdownProps>;

export declare interface MemoizedReactMarkdownProps extends Options {
    isStreaming?: boolean;
}

export declare const MermaidDiagram: default_2.FC<MermaidDiagramProps>;

declare interface MermaidDiagramProps {
    content: string;
}

export declare type Message = {
    id: string;
    role: MessageRole;
    content: ContentBlock[];
    status: MessageStatus;
    createdAt?: Date;
    feedback?: 'positive' | 'negative';
};

declare type Message_2 = {
    content: string;
    uncertaintyFallbackText?: Record<string, string>;
};

export declare type MessageRole = 'user' | 'ai';

export declare type MessageStatus = 'pending' | 'streaming' | 'completed' | 'error';

export declare const MicrosoftLogo: ({ size, variant, className, ...props }: MicrosoftLogoProps) => default_2.JSX.Element;

export declare interface MicrosoftLogoProps extends default_2.SVGAttributes<SVGSVGElement>, VariantProps<typeof microsoftLogoVariants> {
    size?: number;
}

declare const microsoftLogoVariants: (props?: ({
    variant?: "default" | "mono" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const MicrosoftTeamsLogo: ({ size, variant, className, ...props }: MicrosoftTeamsLogoProps) => default_2.JSX.Element;

export declare interface MicrosoftTeamsLogoProps extends default_2.SVGAttributes<SVGSVGElement>, VariantProps<typeof microsoftTeamsLogoVariants> {
    size?: number;
}

declare const microsoftTeamsLogoVariants: (props?: ({
    variant?: "default" | null | undefined;
} & ClassProp) | undefined) => 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",
    ZendeskChat = "zendesk_chat",
    ZendeskMessenger = "zendesk_messenger",
    IntercomChat = "intercom_chat",
    Freshdesk = "freshdesk",
    ZendeskSunshineChat = "zendesk_sunshine_chat"
}

declare type NoArticlesFound = {
    type: typeof AnswersActions.NO_ARTICLES_FOUND;
    payload: {
        index?: number;
    };
};

export declare enum Operator {
    IS = "is",
    IS_NOT = "is not",
    CONTAINS = "contains",
    DOES_NOT_CONTAIN = "does not contain",
    STARTS_WITH = "starts with"
}

declare interface PhosphorIconProps extends IconProps {
    iconName: string;
}

export declare const Popover: React_2.FC<PopoverPrimitive.PopoverProps>;

export declare const PopoverAnchor: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const PopoverContent: React_2.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    /**
     * When true (default), content is portaled to document.body.
     * Set false to keep the dropdown in the DOM tree (e.g. inside a Dialog).
     */
    appendToBody?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const PopoverTrigger: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare interface ProcessingStep {
    id: string;
    label: string;
    status: 'completed' | 'current' | 'pending' | 'error';
}

export declare const Progress: React_2.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    indicatorClassName?: string | undefined;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare interface Props {
    message: Message_2;
    isStreaming?: boolean;
    redirectRules?: RedirectRule[];
    contentTypeEndpoint?: string;
}

declare interface Props_2 {
    language: string;
    value: string;
}

/**
 * Defines a URL redirect rule with pattern matching
 * @example { source: '/knowledge/:id/:path', destination: '/knowledge/test/:path' }
 */
declare type RedirectRule = {
    source: string;
    destination: string;
};

export declare const ReviewList: default_2.ForwardRefExoticComponent<ReviewListProps & default_2.RefAttributes<HTMLUListElement>>;

export declare const ReviewListItem: React_2.ForwardRefExoticComponent<ReviewListItemProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare interface ReviewListItemProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement> {
    /** Unique identifier for the knowledge article */
    id: string;
    /** Primary text displayed in the first row */
    title: string;
    /** Content rendered in the top-right corner (e.g. relative timestamp) */
    timestamp: Date;
    /** Icon rendered at the start of the second row */
    icon?: React_2.ReactNode;
    /** Text or content next to the icon in the second row */
    description?: string | null;
    /** Whether this item is new */
    isNew?: boolean;
    /** Whether this item has been accepted (e.g. accepted as draft) */
    isAccepted?: boolean;
    /** Number of edits for this item */
    editCount?: number;
    /** Whether this item is currently selected */
    isSelected?: boolean;
}

declare interface ReviewListProps {
    items: ReviewListItemProps[];
    className?: string;
}

export declare type ReviewsProviderProps = {
    children: default_2.ReactNode;
    /** Optional initial selection (e.g. from server or mock data) */
    defaultSelectedItem?: ReviewListItemProps | null;
    onApproveAllSuggestions: () => void;
    onRejectAllSuggestions: () => void;
    onAcceptAndPublish?: () => void;
    onOpenArticleLink?: () => void;
    onSourceLinkClick?: () => void;
    breadcrumb?: string;
    suggestionReasonBody?: string;
};

export declare function ReviewsSelectionProvider({ children, defaultSelectedItem, onApproveAllSuggestions, onRejectAllSuggestions, onAcceptAndPublish, onOpenArticleLink, onSourceLinkClick, breadcrumb, suggestionReasonBody, }: ReviewsProviderProps): default_2.JSX.Element;

declare type ReviewsSelectionValue = {
    selectedItem: ReviewListItemProps | null;
    setSelectedItem: (item: ReviewListItemProps | null) => void;
    loadedDiffDoc: LoadedDiffDoc | null;
    setLoadedDiffDoc: (doc: LoadedDiffDoc | null) => void;
    loadingDiff: boolean;
    setLoadingDiff: (loading: boolean) => void;
    onApproveAllSuggestions: () => void;
    onRejectAllSuggestions: () => void;
    onAcceptAndPublish?: () => void;
    onOpenArticleLink?: () => void;
    onSourceLinkClick?: () => void;
    breadcrumb?: string;
    suggestionReasonBody?: string;
};

declare function RightSidebar({ children, scrollable }: {
    children?: default_2.ReactNode;
    scrollable?: boolean;
}): default_2.JSX.Element | null;

declare namespace RightSidebar {
    var displayName: string;
}

export declare const ScrollArea: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const ScrollBar: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

declare interface SearchResult {
    id: string;
    title: string;
    url: string;
}

export declare const Select: React_2.FC<SelectPrimitive.SelectProps>;

export declare const SelectContent: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    appendToBody?: boolean | undefined;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const SelectGroup: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const SelectItem: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SelectLabel: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare type SelectOption = {
    label: string;
    value: string;
};

export declare const SelectSeparator: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SelectTrigger: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;

export declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

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 SetAwaitingKnowledgeGroup = {
    type: typeof AnswersActions.SET_AWAITING_KNOWLEDGE_GROUP;
    payload: {
        index?: number;
    };
};

/**
 * Save fonts to localStorage cache
 */
export declare const setCachedFonts: (fonts: FontOption[]) => void;

declare type SetFollowUpQuestions = {
    type: typeof AnswersActions.SET_FOLLOW_UP_QUESTIONS;
    payload: {
        questions: string[];
        index?: number;
    };
};

declare type SetKnowledgeGroupSelected = {
    type: typeof AnswersActions.SET_KNOWLEDGE_GROUP_SELECTED;
    payload: {
        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;
    };
};

export declare const Sheet: React_2.FC<DialogPrimitive.DialogProps>;

export declare const SheetClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SheetContent: React_2.ForwardRefExoticComponent<SheetContentProps & React_2.RefAttributes<HTMLDivElement>>;

declare interface SheetContentProps extends React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
}

export declare const SheetDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const SheetFooter: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
    displayName: string;
};

export declare const SheetHeader: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;
    displayName: string;
};

export declare const SheetOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SheetPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;

export declare const SheetTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const SheetTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

declare const sheetVariants: (props?: ({
    side?: "left" | "right" | "bottom" | "top" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const Sidebar: React_2.ForwardRefExoticComponent<SidebarProps & React_2.RefAttributes<HTMLElement>>;

declare interface SidebarContextProps {
    collapsed: boolean;
    ItemLinkComponent: ItemLinkComponent;
    activeArticleId?: string;
    onSelectArticle?: (id: string) => void;
    onExpandArticle?: (id: string) => void;
    onSearchArticles?: (value: string) => void;
    onAddArticle?: (parentId: string | null) => Promise<ArticleNavItem>;
    onMoreActions?: (articleId: string) => void;
    canMoveArticle?: (move: {
        id: string;
        parentId: string | null;
        index: number;
    }) => boolean;
    onMoveArticle?: (moved: {
        id: string;
        parentId: string | null;
        index: number;
    }) => void | Promise<void>;
}

export declare interface SidebarContextValue extends SidebarContextProps {
    handleSearchArticles: (value: string) => void;
    isSearching: boolean;
    searchValue: string;
    setSearchValue: React_2.Dispatch<React_2.SetStateAction<string>>;
    /** Set when user selects from search results; tree uses this until activeArticleId catches up */
    lastSelectedArticleId: string | null;
    setLastSelectedArticleId: React_2.Dispatch<React_2.SetStateAction<string | null>>;
}

export declare interface SidebarNavItem {
    id: string;
    label: string;
    href: string;
    Icon?: Icon_2;
    items?: SidebarNavItem[];
}

export declare interface SidebarProps extends React_2.ComponentPropsWithoutRef<'aside'>, SidebarContextProps {
    showAppBack?: boolean;
    onAppBack?: () => void;
    appNavItems?: SidebarNavItem[];
    appNavActiveId?: string;
    showArticles?: boolean;
    isLoadingArticles?: boolean;
    articles?: ArticleNavItem[];
    sectionNavItems?: SidebarNavItem[];
    sectionNavActiveId?: string;
}

export declare function SimpleSelect({ options, value, onChange, placeholder, disabled, className, appendToBody, }: SimpleSelectProps): React_2.JSX.Element;

export declare interface SimpleSelectProps {
    options: SelectOption[];
    value?: string;
    onChange?: (value: string) => void;
    placeholder?: string;
    disabled?: boolean;
    className?: string;
    appendToBody?: boolean;
}

export declare const SlackLogo: ({ size, variant, className, ...props }: SlackLogoProps) => default_2.JSX.Element;

export declare interface SlackLogoProps extends default_2.SVGAttributes<SVGSVGElement>, VariantProps<typeof slackLogoVariants> {
    size?: number;
}

declare const slackLogoVariants: (props?: ({
    variant?: "default" | "mono" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Spinner({ className, ...props }: default_2.ComponentProps<"svg">): default_2.JSX.Element;

export declare type Suggestion = {
    id: string;
    text: string;
    icon?: string;
};

declare interface Suggestion_2 {
    id: string;
    question: string;
    conversationId?: string;
    messageCount?: number;
}

export declare const Switch: React_2.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const Table: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableElement> & React_2.RefAttributes<HTMLTableElement>>;

export declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;

export declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;

export declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;

export declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;

export declare interface Tag {
    label: string;
    value: string;
}

export declare const Textarea: React_2.ForwardRefExoticComponent<Omit<TextareaProps, "ref"> & React_2.RefAttributes<HTMLTextAreaElement>>;

export declare interface TextareaProps extends React_2.ComponentProps<"textarea"> {
    autoResize?: boolean;
}

export declare type TextBlock = {
    type: 'text';
    text: string;
    citations?: Citation[];
};

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>;
}

export declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;

export declare const TooltipContent: React_2.ForwardRefExoticComponent<TooltipContentProps & React_2.RefAttributes<HTMLDivElement>>;

declare interface TooltipContentProps extends React_2.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
    bgColor?: string;
}

export declare const TooltipProvider: ({ delayDuration, ...props }: TooltipPrimitive.TooltipProviderProps) => React_2.JSX.Element;

export declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare enum Trend {
    UP = "up",
    DOWN = "down",
    FLAT = "flat"
}

export declare const TrendValue: default_2.ForwardRefExoticComponent<TrendValueProps & default_2.RefAttributes<HTMLDivElement>>;

declare interface TrendValueProps extends default_2.HTMLAttributes<HTMLDivElement> {
    variant?: TrendVariant;
    trend: Trend;
    trendValue: string;
}

export declare type TrendVariant = 'default' | 'long';

export declare function TwoLevelCombobox({ firstLevelItems, fetchSecondLevelItems, onSelectionChange, firstLevelLabel, secondLevelLabel, firstLevelPlaceholder, className, debugMode, displayLabel, }: TwoLevelComboboxProps): React_2.JSX.Element;

export declare interface TwoLevelComboboxProps {
    firstLevelItems: ComboboxItem[];
    fetchSecondLevelItems: (firstLevelId: string) => Promise<ComboboxItem[]>;
    onSelectionChange?: (firstLevel: ComboboxItem | null, secondLevel: ComboboxItem | null) => void;
    firstLevelLabel?: string;
    secondLevelLabel?: string;
    firstLevelPlaceholder?: string;
    secondLevelPlaceholder?: string;
    className?: string;
    debugMode?: boolean;
    displayLabel?: boolean;
}

export declare interface UploadState {
    id: string;
    file: File;
    status: 'pending' | 'uploading' | 'success' | 'error';
    progress: number;
    error?: string;
    startTime?: number;
    url?: string;
}

declare type UrlString = string & {
    __url: never;
};

export declare const useChatSearch: () => ChatSearchContextProps;

export declare function useConversation(): ConversationContextValue;

/**
 * Hook to fetch and manage Google Fonts options
 * Handles caching, loading state, and font stylesheet loading
 */
export declare function useFontOptions({ apiKey, maxFonts, onError }: UseFontOptionsProps): UseFontOptionsReturn;

export declare interface UseFontOptionsProps {
    apiKey: string;
    maxFonts?: number;
    onError?: (error: Error) => void;
}

export declare interface UseFontOptionsReturn {
    fonts: FontOption[];
    isLoading: boolean;
    loadFont: typeof loadFont;
}

export declare function useFullLayoutContext(): FullLayoutContextValue | null;

export declare const useIsChatSearchDirty: () => boolean;

export declare function useReviewsSelection(): ReviewsSelectionValue;

/**
 * Convenience hook for programmatically controlling the right sidebar.
 *
 * Must be used inside a `<FullLayout>` tree.
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const rightSidebar = useRightSidebar();
 *   return <button onClick={rightSidebar.open}>Open sidebar</button>;
 * }
 * ```
 */
export declare function useRightSidebar(): UseRightSidebarReturn;

export declare interface UseRightSidebarReturn {
    /** Whether the right sidebar is currently open. */
    isOpen: boolean;
    /** Open the right sidebar (no-op if already open). */
    open: () => void;
    /** Close the right sidebar (no-op if already closed). */
    close: () => void;
    /** Toggle the right sidebar open/closed. */
    toggle: () => void;
}

export declare function useSidebar(): SidebarContextValue;

export declare const ZoomableImage: React_2.FC<ZoomableImageProps>;

declare interface ZoomableImageProps {
    src?: string;
    alt?: string;
}

export { }