@inkeep/cxkit-types 0.0.0-dev-20250221234142

package/dist/index.d.ts

@@ -0,0 +1,1704 @@
+import { ComponentType } from 'react';
+import { HTMLProps } from 'react';
+import { ReactNode } from 'react';
+
+export declare interface AIChatActionButtonLabels {
+    /**
+     * Text shown on the button that clears the chat history.
+     * @example "Clear Chat" or "Start Over"
+     */
+    clearButtonLabel?: string;
+    /**
+     * Text shown on the button that generates a shareable chat link.
+     * @example "Share Chat" or "Get Link"
+     */
+    shareButtonLabel?: string;
+    /**
+     * Text shown on the button that opens the help options menu.
+     * @example "Get Help" or "Support Options"
+     */
+    getHelpButtonLabel?: string;
+    /**
+     * Text shown on the button that stops the AI from generating a response.
+     * @example "Stop" or "Cancel Response"
+     */
+    stopButtonLabel?: string;
+    /**
+     * Text shown on the button that copies the chat transcript.
+     * @example "Copy Chat" or "Copy Transcript"
+     */
+    copyChatButtonLabel?: string;
+}
+
+export declare interface AIChatBotResponseReceivedEvent {
+    eventName: 'chat_message_bot_response_received';
+    properties: {
+        messages: Message[];
+        messageId: string;
+        question: string;
+        responseMessage: Message;
+        linksUsedInResponse: SourceItem[];
+        workflowId?: string;
+    };
+}
+
+export declare interface AIChatDisclaimerSettings {
+    /**
+     * Controls whether the disclaimer message is shown.
+     * Enable this when you need to display important notices or legal disclaimers.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * The main text content of the disclaimer message.
+     * Should clearly communicate important information about AI usage or limitations.
+     * @example "AI responses are generated automatically and may require verification."
+     */
+    label?: string;
+    /**
+     * Additional information shown when hovering over the disclaimer.
+     * Use this to provide more detailed explanations or context.
+     */
+    tooltip?: string;
+}
+
+export declare interface AIChatFunctions {
+    /**
+     * Programmatically sends a message in the chat.
+     * @param message Optional message text. If omitted, sends the current input value.
+     */
+    submitMessage: (message?: string) => void;
+    /**
+     * Programmatically updates the text in the chat input field.
+     * @param message The new message text to set
+     */
+    updateInputMessage: (message: string) => void;
+    /**
+     * Resets the chat to its initial state.
+     * Removes all messages and resets any active workflows.
+     */
+    clearChat: () => void;
+    /**
+     * Displays a form overlay in the chat interface.
+     * @param formConfig Configuration object defining the form's fields and behavior
+     */
+    openForm: (formConfig: FormConfig) => void;
+    /**
+     * Programmatically sets focus to the chat input field.
+     * Useful after programmatic updates or when showing the chat interface.
+     */
+    focusInput: () => void;
+}
+
+export declare interface AIChatGetHelpOptionClickedEvent {
+    eventName: 'get_help_option_clicked';
+    properties: {
+        actionType?: ChatActionType;
+        name: string;
+        url?: string;
+        conversationId: string;
+    };
+}
+
+export declare interface AIChatHistoryClearedEvent {
+    eventName: 'chat_history_cleared';
+    properties: {
+        conversationId: string | null;
+    };
+}
+
+export declare interface AIChatMessageCopiedEvent {
+    eventName: 'chat_message_copied';
+    properties: {
+        messageId: string;
+    };
+}
+
+export declare interface AIChatMessageSubmittedEvent {
+    eventName: 'chat_message_submitted';
+    properties: {
+        messages: Message[];
+        messageId: string;
+        content: string;
+        workflowId?: string;
+    };
+}
+
+export declare interface AIChatResponseLinkOpenedEvent {
+    eventName: 'chat_response_link_opened';
+    properties: {
+        messageId: string;
+        title?: string;
+        url?: string;
+    };
+}
+
+export declare interface AIChatResponseSourceItemClickedEvent {
+    eventName: 'chat_response_source_item_clicked';
+    properties: {
+        messageId: string;
+        sourceType: SourceItem['type'];
+        title?: string;
+        url?: string;
+    };
+}
+
+export declare interface AIChatShareButtonClickedEvent {
+    eventName: 'chat_share_button_clicked';
+    properties: {
+        sharedChatUrl: string;
+        sharedConversationId: string;
+        originalConversationId: string;
+    };
+}
+
+export declare interface AIChatSharedSessionLoadedEvent {
+    eventName: 'chat_shared_session_loaded';
+    properties: {
+        conversationId: string;
+    };
+}
+
+export declare interface AIChatThumbsDownFeedbackSubmittedEvent {
+    eventName: 'chat_thumbs_down_feedback_submitted';
+    properties: FeedbackProperties;
+}
+
+export declare interface AIChatThumbsUpFeedbackSubmittedEvent {
+    eventName: 'chat_thumbs_up_feedback_submitted';
+    properties: FeedbackProperties;
+}
+
+export declare interface AIChatToolCallActionClickedEvent {
+    eventName: 'toolcall_action_clicked';
+    properties: {
+        actionType: ChatActionType;
+        conversationId: string;
+        question?: string;
+        answer?: string;
+        answerId?: string;
+        workflowId?: string;
+    };
+}
+
+export declare interface Analytics {
+    /**
+     * Whether to opt out of analytical cookies.
+     * @default false
+     */
+    optOutAnalyticalCookies?: boolean;
+    /**
+     * Whether to opt out of all analytics.
+     * @default false
+     */
+    optOutAllAnalytics?: boolean;
+    /**
+     * Whether to opt out of functional cookies.
+     * @default false
+     */
+    optOutFunctionalCookies?: boolean;
+}
+
+export declare type AnswerConfidence = 'very_confident' | 'somewhat_confident' | 'not_confident' | 'no_sources' | 'other';
+
+export declare interface AssistantMessage extends MessageBase {
+    role: 'assistant';
+    links: SourceItem[];
+}
+
+export declare type AvailableBuiltInIcons = 'FaBook' | 'FaGithub' | 'FaDatabase' | 'FaStackOverflow' | 'FaChrome' | 'FaPhone' | 'FaEnvelope' | 'FaPencil' | 'FaBlog' | 'FaSort' | 'FaPenSquare' | 'FaChevronRight' | 'FaChevronUp' | 'FaFilePdf' | 'FaDiscourse' | 'FaDiscord' | 'FaSlack' | 'IoDocumentTextSharp' | 'IoDocumentSharp' | 'IoSend' | 'IoInformationCircleOutline' | 'IoLinkOutline' | 'IoThumbsUpSharp' | 'IoThumbsDownSharp' | 'IoSearch' | 'IoCopyOutline' | 'IoCopy' | 'IoReturnDownBackOutline' | 'IoChevronForwardOutline' | 'IoReturnDownForward' | 'IoCloseOutline' | 'IoCheckmarkOutline' | 'IoBookOutline' | 'IoReaderOutline' | 'IoHelpBuoyOutline' | 'IoPeopleOutline' | 'IoDocumentTextOutline' | 'IoChatbubblesOutline' | 'FaRegFilePdf' | 'IoLogoDiscord' | 'IoLogoGithub' | 'IoTerminal' | 'FaBriefcase' | 'IoPlayCircleOutline' | 'IoPencilOutline' | 'IoCheckmarkDoneOutline' | 'IoHomeOutline' | 'IoMail' | 'IoOpenOutline' | 'FaTelegram' | 'FaTable' | 'FaMagnifyingGlass' | 'LuArrowLeft' | 'LuCircleCheck' | 'LuCommand' | 'LuCopy' | 'LuCheck' | 'LuCornerDownLeft' | 'LuRepeat' | 'LuThumbsDown' | 'LuThumbsUp' | 'LuUsers' | 'LuUser' | 'LuArrowUpRight' | 'LuBookOpen' | 'LuChevronDown' | 'LuLoaderCircle' | 'FiEdit' | 'LuSparkles';
+
+export declare interface BaseFormField {
+    name: string;
+    label: string;
+    required?: boolean;
+    isHidden?: boolean;
+    description?: string;
+}
+
+declare type ChatAction = InvokeCallbackAction | OpenFormAction | OpenUrlAction;
+
+export declare type ChatActionType = ChatAction['type'];
+
+export declare type ChatEvent = AIChatBotResponseReceivedEvent | AIChatMessageSubmittedEvent | AIChatSharedSessionLoadedEvent | AIChatThumbsDownFeedbackSubmittedEvent | AIChatThumbsUpFeedbackSubmittedEvent | AIChatHistoryClearedEvent | AIChatMessageCopiedEvent | AIChatGetHelpOptionClickedEvent | AIChatToolCallActionClickedEvent | AIChatShareButtonClickedEvent | AIChatResponseSourceItemClickedEvent | AIChatResponseLinkOpenedEvent | CodeBlockCopiedEvent;
+
+export declare enum ChatModel {
+    /**
+     * Inkeep's specialized model for technical Q&A interactions.
+     * Optimized for developer documentation and API support use cases.
+     */
+    QA_EXPERT = "inkeep-qa-expert"
+}
+
+declare interface CheckboxField extends BaseFormField {
+    inputType: 'CHECKBOX';
+    defaultValue?: boolean;
+}
+
+export declare interface Client {
+    currentUrl: string;
+}
+
+export declare type CloseFormAction = 'BACK_TO_CHAT' | 'CLOSE_MODAL';
+
+export declare interface CodeBlockCopiedEvent {
+    eventName: 'chat_code_block_copied';
+    properties: {
+        conversationId: string;
+        language: string;
+        code: string;
+    };
+}
+
+export declare interface ColorMode extends Omit<ColorModeProviderProps, 'children' | 'rootId' | 'shadowHostId'> {
+    /**
+     * Configuration for syncing the widget's color mode with an external element.
+     *
+     * This allows the widget to automatically match its color mode (light/dark) with your application's theme.
+     * The widget will observe changes to specified attributes on a target element and update its appearance accordingly.
+     *
+     * @example
+     * ```ts
+     * colorMode: {
+     *   sync: {
+     *     // Watch the document root for theme changes
+     *     target: document.documentElement,
+     *     // Monitor the data-theme attribute
+     *     attributes: ['data-theme'],
+     *     // Determine dark mode based on attribute value
+     *     isDarkMode: (attrs) => attrs['data-theme'] === 'dark',
+     *     // Optional callback when color mode changes
+     *     onChange: (mode) => console.log('Color mode changed to:', mode)
+     *   }
+     * }
+     * ```
+     */
+    sync?: SyncColorMode;
+}
+
+export declare interface ColorModeProviderProps {
+    /** List of all available colorMode names */
+    colorModes?: string[];
+    /** Forced colorMode name for the current page */
+    forcedColorMode?: string;
+    /** Whether to switch between dark and light colorModes based on prefers-color-scheme */
+    enableSystem?: boolean;
+    /** Disable all CSS transitions when switching colorModes */
+    disableTransitionOnChange?: boolean;
+    /** Whether to indicate to browsers which color scheme is used (dark or light) for built-in UI like inputs and buttons */
+    enableColorScheme?: boolean;
+    /** Key used to store colorMode setting in localStorage */
+    storageKey?: string;
+    /** Default colorMode name (for v0.0.12 and lower the default was light). If `enableSystem` is false, the default colorMode is light */
+    defaultColorMode?: string;
+    /** HTML attribute modified based on the active colorMode. Accepts `class` and `data-*` (meaning any data attribute, `data-mode`, `data-color`, etc.) */
+    attribute?: 'class' | (string & {});
+    /** Mapping of colorMode name to HTML attribute value. Object where key is the colorMode name and value is the attribute value */
+    value?: ValueObject;
+    /** Nonce string to pass to the inline script for CSP headers */
+    nonce?: string;
+    shadowHostId?: string;
+    rootId?: string;
+    children?: React.ReactNode;
+}
+
+declare interface CommonProperties {
+    conversationId: string;
+    interactionType: any;
+    tags: string[];
+}
+
+export declare interface ConversationBody {
+    visibility?: 'public' | 'private';
+    messages: Message[];
+    tags: string[];
+    userProperties: UserProperties;
+}
+
+export declare interface ConversationMessage {
+    id: string;
+    type: 'openai';
+    externalId: string;
+    externalUrl: string;
+    conversationId: string;
+    createdAt: string;
+    updatedAt: string;
+    role: 'assistant' | 'system' | 'user';
+    content: string;
+    name: string;
+    links: SourceItem[];
+    properties: Record<string, unknown>;
+    userProperties: Record<string, unknown>;
+    tool_calls: unknown[];
+}
+
+export declare interface ConversationResponse {
+    id: string;
+    externalId: string;
+    externalUrl: string;
+    type: 'openai' | 'support_ticket';
+    createdAt: string;
+    updatedAt: string;
+    projectId: string;
+    integrationId: string;
+    properties: Record<string, unknown>;
+    userProperties: Record<string, unknown>;
+    tags: string[];
+    messages: ConversationMessage[];
+    messagesOpenAIFormat: unknown[];
+}
+
+export declare type CustomIconMap = {
+    [K in keyof CustomIcons]?: InkeepCustomIcon;
+};
+
+export declare interface CustomIcons {
+    search: string;
+    thumbsUp: string;
+    thumbsDown: string;
+    messageCopy: string;
+    messageCopied: string;
+    messageRevise: string;
+    codeCopy: string;
+    codeCopied: string;
+    openLinkInNewTab: string;
+    openLinkInSameTab: string;
+    breadcrumbSeparator: string;
+    switchToSearch: string;
+    switchToChat: string;
+    chatSubmit: string;
+    close: string;
+    info: string;
+    command: string;
+}
+
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepPartial<T[P]> : T[P];
+};
+
+export declare type EntityType = 'conversation' | 'message' | 'search';
+
+declare type ExtendPropertiesWithCommon<T> = T extends {
+    properties: infer P;
+} ? T & {
+    properties: P & CommonProperties;
+} : T;
+
+export declare type FeebackReason = {
+    label: string;
+    details: string;
+};
+
+export declare interface FeedbackBody {
+    type: FeedbackType;
+    messageId: string;
+    createdAt: string;
+    reasons?: {
+        label: string;
+        details: string;
+    }[] | null;
+    userProperties: UserProperties;
+}
+
+export declare type FeedbackItemType = keyof MessageFeedback;
+
+declare interface FeedbackProperties {
+    conversationId: string;
+    messageId: string;
+    question: string;
+    answer: string;
+    reasons: FeebackReason[];
+    workflowId?: string;
+}
+
+export declare type FeedbackType = 'positive' | 'negative';
+
+export declare type FieldValues = Record<string, any>;
+
+declare interface FileField extends BaseFormField {
+    inputType: 'FILE';
+}
+
+export declare interface FormButtons {
+    submit: {
+        label?: string;
+        onSubmit: SubmitCallback;
+    };
+    close?: {
+        action: CloseFormAction;
+    };
+}
+
+export declare interface FormConfig {
+    heading?: string;
+    description?: string;
+    buttons: FormButtons;
+    fields: FormField[];
+    successView: SuccessView;
+}
+
+export declare type FormField = CheckboxField | FileField | SelectField | TextField | IncludeChatSessionField;
+
+export declare type FormInputType = NonNullable<FormField['inputType']>;
+
+export declare interface GetHelpCallToAction {
+    icon?: InkeepCustomIcon;
+    name: string;
+    pinToToolbar?: boolean;
+    action: ChatAction;
+}
+
+export declare enum GitHubIssueState {
+    Closed = "CLOSED",
+    Open = "OPEN"
+}
+
+export declare type IkpChatAction = GetHelpCallToAction | ToolCallAction;
+
+export declare type IkpTheme = DeepPartial<StrictIkpTheme>;
+
+export declare type IkpThemeCategory = keyof StrictIkpTheme;
+
+export declare type IkpThemeEntry = [keyof IkpTheme, Record<string, unknown>][];
+
+export declare interface IncludeChatSessionField extends BaseFormField {
+    _type: 'INCLUDE_CHAT_SESSION';
+    inputType?: 'CHECKBOX';
+    defaultValue?: boolean;
+}
+
+export declare interface InkeepAIChatSettings extends ToolConfig {
+    /**
+     * The placeholder text to display in the chat input field when empty.
+     * Use this to provide guidance on what kind of questions users can ask.
+     * @example "Ask me anything about our API documentation..."
+     */
+    placeholder?: string;
+    /**
+     * A welcome message shown at the start of a new chat session.
+     * Supports markdown formatting for rich text styling.
+     * Use this to introduce the bot's capabilities and set expectations.
+     * @example "👋 Hi! I'm here to help you with technical questions about our API..."
+     */
+    introMessage?: string;
+    /**
+     * The name of the product/service/topic that the chat assistant specializes in.
+     * This helps contextualize the chat experience for users.
+     * If not provided, defaults to the organization name from base settings.
+     * @example "MongoDB Atlas" or "React Router"
+     */
+    chatSubjectName?: string;
+    /**
+     * The display name for the AI assistant in the chat interface.
+     * Choose a name that reflects the assistant's role and your brand.
+     * @example "Atlas Assistant" or "DevBot"
+     */
+    botName?: string;
+    /**
+     * URL to the bot's avatar image for light mode.
+     * Should be a square image, recommended size 40x40px.
+     * Supports common image formats (PNG, JPG, SVG).
+     */
+    botAvatarSrcUrl?: string;
+    /**
+     * URL to the bot's avatar image for dark mode.
+     * Should be a square image, recommended size 40x40px.
+     */
+    botAvatarDarkSrcUrl?: string;
+    /**
+     * URL to the user's avatar image in the chat interface.
+     * Should be a square image, recommended size 40x40px.
+     * Falls back to a default user icon if not provided.
+     */
+    userAvatarSrcUrl?: string;
+    /**
+     * Controls whether links in chat messages open in new browser tabs.
+     * Enable this to help users maintain their chat context when following links.
+     * @default true
+     */
+    shouldOpenLinksInNewTab?: boolean;
+    /**
+     * Custom heading text for the quick questions section.
+     * Use this to better describe your suggested queries.
+     * @example "Common Questions" or "Try asking about..."
+     */
+    quickQuestionsLabel?: string;
+    /**
+     * A list of pre-written questions users can click to quickly start a conversation.
+     * These should reflect common use cases and help users understand the bot's capabilities.
+     * @example ["How do I reset my password?", "What are the API rate limits?"]
+     */
+    quickQuestions?: string[];
+    /**
+     * Whether to visually emphasize the first quick question.
+     * Use this to draw attention to the most important or common query.
+     */
+    shouldHighlightFirstQuickQuestion?: boolean;
+    /**
+     * Enables the ability to share chat conversations via URL.
+     * Useful for allowing users to share helpful conversations with teammates.
+     */
+    isChatSharingEnabled?: boolean;
+    /**
+     * The base URL path used when generating shareable chat links.
+     * Should match your application's routing structure.
+     * @example "/shared-chats/" or "/support/conversations/"
+     */
+    shareChatUrlBasePath?: string;
+    /**
+     * Controls the visibility of the copy chat button.
+     * Allows users to copy the entire chat transcript to their clipboard.
+     */
+    shouldShowCopyChatButton?: boolean;
+    /**
+     * Unique identifier for loading a specific chat session.
+     * Use this to restore a previous conversation state.
+     */
+    chatId?: string;
+    /**
+     * When enabled, prevents users from sending new messages.
+     * Useful for displaying archived or shared chat sessions.
+     * @default false
+     */
+    isViewOnly?: boolean;
+    /**
+     * Configuration for the chat's disclaimer message.
+     * Use this to display important notices about AI limitations or data usage.
+     */
+    disclaimerSettings?: AIChatDisclaimerSettings;
+    /**
+     * Callback function triggered whenever the user modifies their input message.
+     * @param message The current content of the input field
+     */
+    onInputMessageChange?: (message: string) => void;
+    /**
+     * React ref for accessing the chat component's methods.
+     * Enables programmatic control of chat functions from parent components.
+     */
+    chatFunctionsRef?: React.Ref<AIChatFunctions>;
+    /**
+     * Array of actions available in the "Get Help" menu.
+     * Use this to provide alternative support options like contact forms or documentation links.
+     */
+    getHelpCallToActions?: GetHelpCallToAction[];
+    /**
+     * System-level instructions that guide the AI's behavior and responses.
+     * Use these to define the assistant's personality, knowledge boundaries, and response style.
+     */
+    prompts?: string[];
+    /**
+     * Custom heading text for the workflows section.
+     * Use this to describe available automated processes or guided flows.
+     */
+    workflowsHeader?: string;
+    /**
+     * Collection of interactive workflows that can be triggered during chat.
+     * These can guide users through complex processes or data collection.
+     */
+    workflows?: Workflow[];
+    /**
+     * Custom labels for the chat interface's action buttons.
+     * Use this for internationalization or to better match your application's terminology.
+     */
+    actionButtonLabels?: AIChatActionButtonLabels;
+    /**
+     * Specifies which AI model to use for generating responses.
+     * Different models may have different capabilities or specializations.
+     * @default 'inkeep-qa-expert'
+     */
+    model?: `${ChatModel}`;
+}
+
+export declare interface InkeepBaseSettings {
+    /**
+     * The API key to use for authenticating with Inkeep's services.
+     * Required for accessing Inkeep's API endpoints.
+     */
+    apiKey?: string;
+    /**
+     * The display name of your organization that will be shown in various UI elements.
+     * For example, this may appear in chat messages or headers.
+     */
+    organizationDisplayName?: string;
+    /**
+     * The primary brand color used throughout the widget UI.
+     * This color will be used to generate a cohesive color scheme.
+     * Should be provided as a valid CSS color value (hex, rgb, etc).
+     */
+    primaryBrandColor: string;
+    /**
+     * Settings to control the color mode (light/dark) behavior.
+     * Can be used to sync with your application's theme or set a forced color mode.
+     * @see ColorMode type for detailed configuration options
+     */
+    colorMode?: ColorMode;
+    /**
+     * Theme customization settings for the widget.
+     * Allows customizing colors, typography, component styles, and more.
+     */
+    theme?: UserTheme;
+    /**
+     * Custom icon overrides for the default icon set.
+     * Allows replacing any of the built-in icons with your own components.
+     */
+    customIcons?: CustomIconMap;
+    /**
+     * Properties to identify and provide context about the current user.
+     * Used for personalization and analytics tracking.
+     * @see UserProperties interface for available fields
+     */
+    userProperties?: UserProperties;
+    /**
+     * Authentication token for the current user.
+     * Used for authenticated API requests if required.
+     */
+    userAuthToken?: string;
+    /**
+     * Callback function to handle analytics events from the widget.
+     * Receives InkeepCallbackEvent objects containing event details.
+     * @param event The analytics event object
+     */
+    logEventCallback?: (event: InkeepCallbackEvent) => void;
+    /**
+     * Configuration for analytics behavior and tracking.
+     * Controls what events are tracked and how they are processed.
+     */
+    analytics?: Analytics;
+    /**
+     * Custom base URL for analytics API endpoints.
+     * Useful when routing analytics requests through a proxy.
+     * Should include protocol (e.g., 'https://analytics.your-proxy.com')
+     */
+    analyticsBaseUrl?: string;
+    /**
+     * Custom base URL for search and chat API endpoints.
+     * Useful when routing API requests through a proxy.
+     * Should include protocol (e.g., 'https://api.your-proxy.com')
+     */
+    baseUrl?: string;
+    /**
+     * Whether to bypass the captcha challenge. Only enable this flag if using a server side API type api key, otherwise the api requests will fail without the challenge solution.
+     * @default false
+     */
+    bypassChallenge?: boolean;
+    /**
+     * Function to transform source data before display.
+     * Allows customizing how source information is presented in the widget.
+     * @param source The original source data
+     * @returns The transformed source data
+     */
+    transformSource?: TransformSource;
+    /**
+     * Environment setting for the widget.
+     * Affects API endpoints and debug behaviors.
+     * @default 'PRODUCTION'
+     */
+    env?: 'DEVELOPMENT' | 'PRODUCTION';
+    /**
+     * Reference to the shadow DOM host element if using custom Shadow DOM.
+     * Required when embedding the widget within a Shadow DOM.
+     */
+    shadowHost?: HTMLElement | null;
+    /**
+     * Reference to the root element where the widget is mounted.
+     * Used for positioning and event handling.
+     */
+    rootElement?: HTMLElement | null;
+    /**
+     * Custom tags for widget identification.
+     * Used in analytics to segment and filter widget instances.
+     * Array of string identifiers.
+     */
+    tags?: string[];
+    /**
+     * Instance of the Prism syntax highlighting library.
+     * Required for code block syntax highlighting functionality.
+     */
+    prism?: any;
+    /**
+     * Query parameters to automatically append to URLs in the widget.
+     * Useful for tracking or maintaining context in navigation.
+     * Object mapping parameter names to values.
+     */
+    appendQueryParamsToUrls?: UrlQueryParam;
+}
+
+export declare type InkeepCallbackEvent = InkeepEventWithCommon & {
+    userProperties: UserProperties;
+};
+
+export declare interface InkeepConfig {
+    /**
+     * The prefix to use for the widget.
+     * @default 'ikp'
+     */
+    prefix?: string;
+    /**
+     * The type widget.
+     */
+    interactionType: any;
+    /**
+     * Configuration for the chat.
+     */
+    aiChatSettings: InkeepAIChatSettings & {
+        shouldAutoFocusInput?: boolean;
+    };
+    /**
+     * Configuration for the base settings.
+     */
+    baseSettings: InkeepBaseSettings;
+    /**
+     * Configuration for the search settings.
+     */
+    searchSettings: InkeepSearchSettings & {
+        shouldAutoFocusInput?: boolean;
+    };
+}
+
+export declare type InkeepCustomIcon = {
+    builtIn: AvailableBuiltInIcons;
+} | {
+    custom: string;
+};
+
+export declare type InkeepEvent = SearchEvent | ChatEvent | IntelligentFormEvent;
+
+export declare type InkeepEventWithCommon = ExtendPropertiesWithCommon<InkeepEvent>;
+
+export declare interface InkeepModalSettings {
+    /**
+     * Whether the modal is open.
+     */
+    open?: boolean;
+    /**
+     * Callback fired when the modal open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The shortcut key.
+     *
+     * The key to trigger the modal when pressed with Cmd (Mac) / Ctrl (Windows).
+     *
+     * Set to `null` to disable the shortcut.
+     *
+     * @default 'k'
+     */
+    shortcutKey?: string | null;
+}
+
+export declare interface InkeepSearchSettings {
+    /**
+     * The placeholder text to use.
+     * @default
+     * 'Search anything...' (desktop)
+     * 'Search' (mobile)
+     */
+    placeholder?: string;
+    /**
+     * The default query to use.
+     * @default ''
+     */
+    defaultQuery?: string;
+    /**
+     * Callback for when the search query changes.
+     */
+    onQueryChange?: (query: string) => void;
+    /**
+     * The maximum number of hits to return.
+     * @default 40
+     */
+    maximumHitsLimit?: number;
+    /**
+     * The time in milliseconds to wait triggering the search.
+     * @default 0
+     */
+    debounceTime?: number;
+    /**
+     * Ref to the AIChat component's callable functions
+     */
+    searchFunctionsRef?: React.Ref<SearchFunctions>;
+    /**
+     * Whether to open links in new tab.
+     * @default false
+     */
+    shouldOpenLinksInNewTab?: boolean;
+    /**
+     * Tabs to display in the search results, and in the **desired order**. Each tab can be either a string or a tuple of [string, options].
+     *
+     * Default tabs if none provided: All, Publications, PDFs, GitHub, Forums, Discord, Slack, StackOverflow
+     *
+     * Behavior:
+     * - Omit 'All' from tabs array to hide the All tab
+     * - Empty tabs array will show all results without tab UI
+     * - Tabs only appear when they have results, unless alwaysVisible is set
+     *
+     * @example
+     * ```ts
+     * // Basic tabs
+     * tabs: ['Publications', 'GitHub']
+     *
+     * // With alwaysVisible option
+     * tabs: [
+     *   'Publications',
+     *   ['GitHub', { alwaysVisible: true }] // Shows even with no results
+     * ]
+     * ```
+     */
+    tabs?: (string | SearchTab)[];
+    /**
+     * The key to use for the search query parameter.
+     *
+     * When a user selects a search result, the query is added to the URL as a query parameter.
+     * This is the key of that query parameter.
+     *
+     * @default 'q'
+     */
+    searchQueryParamKey?: string;
+}
+
+export declare type InputMaybe<T> = T | null;
+
+export declare interface IntelligentFormAIErrorEvent {
+    eventName: 'intelligent_form_ai_error';
+    properties: {
+        conversationId: string;
+        error: string;
+    };
+}
+
+export declare interface IntelligentFormConfig {
+    /**
+     * Primary form section that is always shown
+     */
+    primary: {
+        /** Array of form fields to display */
+        fields: IntelligentFormField[];
+        /** Optional description text shown above the fields */
+        description?: string;
+    };
+    /**
+     * Secondary form section that can be conditionally shown
+     */
+    secondary: {
+        /** Array of form fields to display */
+        fields: IntelligentFormField[];
+        /**
+         * Optional description text shown above the fields.
+         * Can be either a simple string or an object with different messages
+         * based on AI confidence level
+         */
+        description?: string | {
+            /** Default message shown when AI confidence is low/medium */
+            default: string;
+            /** Message shown when AI has high confidence */
+            confident: string;
+        };
+    };
+    /** Configuration for the success view shown after form submission */
+    successView: IntelligentFormSuccessView;
+    /** Callback function called when form is submitted */
+    onSubmit: SubmitCallback;
+    /** Optional name of the bot shown in the form */
+    botName?: string;
+}
+
+export declare interface IntelligentFormContextSuggestionsEvent {
+    eventName: 'intelligent_form_context_suggestions';
+    properties: {
+        conversationId: string;
+        suggestedFields: string[];
+    };
+}
+
+export declare type IntelligentFormEvent = IntelligentFormSubmittedEvent | IntelligentFormSubmissionErrorEvent | IntelligentFormPrimarySubmittedEvent | IntelligentFormQAResponseEvent | IntelligentFormContextSuggestionsEvent | IntelligentFormAIErrorEvent;
+
+export declare type IntelligentFormField = Exclude<FormField, IncludeChatSessionField> & {
+    /**
+     * Controls AI field generation behavior
+     */
+    aiGenerated?: boolean;
+};
+
+export declare interface IntelligentFormPrimarySubmittedEvent {
+    eventName: 'intelligent_form_primary_submitted';
+    properties: {
+        conversationId: string;
+        fields: string[];
+        messages: Message[];
+    };
+}
+
+export declare interface IntelligentFormQAResponseEvent {
+    eventName: 'intelligent_form_qa_response';
+    properties: {
+        conversationId: string;
+        messages: Message[];
+        answer: string;
+        confidence?: AnswerConfidence;
+        recordsConsidered?: SourceItem[];
+    };
+}
+
+export declare interface IntelligentFormSubmissionErrorEvent {
+    eventName: 'intelligent_form_submission_error';
+    properties: {
+        conversationId: string;
+        error: string;
+    };
+}
+
+export declare interface IntelligentFormSubmittedEvent {
+    eventName: 'intelligent_form_submitted';
+    properties: {
+        conversationId: string;
+        values: Record<string, unknown>;
+    };
+}
+
+export declare interface IntelligentFormSuccessView {
+    heading: string;
+    message: string;
+    icon?: InkeepCustomIcon;
+}
+
+export declare interface InvokeCallbackAction {
+    type: 'INVOKE_CALLBACK';
+    callback: (args: InvokeCallbackArgs) => void;
+    shouldCloseModal?: boolean;
+}
+
+declare interface InvokeCallbackArgs {
+    conversation: ConversationResponse;
+}
+
+export declare type Message = AssistantMessage | UserMessage | SystemMessage;
+
+export declare type MessageAction = 'copy' | 'upvote' | 'downvote';
+
+export declare interface MessageAttachment {
+    contentType: MessageAttachmentContentType;
+    title: string;
+    content: string;
+    id: string;
+    context?: string[];
+}
+
+/**
+ * MessageAttachmentContentType represents possible type of information that can be attached to a Workflow.
+ */
+export declare type MessageAttachmentContentType = WorkflowCodeContentType | WorkflowTextContentType;
+
+export declare interface MessageAttributes {
+    attachments?: MessageAttachment[];
+    workflow?: Workflow;
+}
+
+declare interface MessageBase {
+    content: MessageContent;
+    id: string;
+    metadata?: MessageMetadata;
+}
+
+export declare type MessageContent = string | {
+    type: 'text';
+    text: string;
+}[];
+
+export declare interface MessageFeedback {
+    unrelated_response: boolean;
+    inaccurate_statement: boolean;
+    inaccurate_code_snippet: boolean;
+    irrelevant_citations: boolean;
+}
+
+export declare interface MessageMetadata {
+    attributes?: MessageAttributes;
+    context?: string;
+}
+
+export declare type ModalViewTypes = 'chat' | 'search';
+
+export declare type OnToggleView = (opts: {
+    view: ModalViewTypes;
+    query?: string;
+    autoSubmit?: boolean;
+}) => void;
+
+export declare interface OpenFormAction {
+    type: 'OPEN_FORM';
+    formConfig: FormConfig;
+}
+
+export declare interface OpenUrlAction {
+    type: 'OPEN_LINK';
+    url: string;
+}
+
+declare type RecordTypes = 'DocumentationRecord' | 'GitHubIssueRecord' | 'StackOverflowRecord' | 'DiscordRecord' | 'SlackEntry' | 'DiscourseRecord';
+
+export declare type RenderFn = ({ children, ssr, root, }: {
+    children: ReactNode;
+    ssr: boolean;
+    root: ShadowRoot | null;
+}) => ReactNode;
+
+export declare type Root = Record<string, ComponentType<HTMLProps<HTMLElement> & ShadowRootProps>>;
+
+export declare type SearchEvent = SearchQueryResponseReceivedEvent | SearchQuerySubmittedEvent | SearchResultClickedEvent;
+
+export declare type SearchFiltersInput = {
+    limit: number;
+};
+
+export declare interface SearchFunctions {
+    /**
+     * Update the query.
+     */
+    updateQuery: (query: string) => void;
+    /**
+     * Focus the input.
+     */
+    focusInput: () => void;
+}
+
+export declare interface SearchHit {
+    hitOnRoot: boolean;
+    id: string;
+    rootRecord: SearchRootRecord;
+    title?: string;
+    url?: string;
+    preview?: string;
+    pathHeadings?: {
+        content: string;
+    }[];
+    content?: {
+        content: string;
+    };
+}
+
+export declare type SearchInput = {
+    filters?: InputMaybe<SearchFiltersInput>;
+    searchQuery: string;
+};
+
+export declare interface SearchQueryResponseReceivedEvent {
+    eventName: 'search_query_response_received';
+    properties: {
+        searchQuery: string;
+        totalHits: number;
+    };
+}
+
+export declare interface SearchQuerySubmittedEvent {
+    eventName: 'search_query_submitted';
+    properties: {
+        searchQuery: string;
+    };
+}
+
+export declare interface SearchResultClickedEvent {
+    eventName: 'search_result_clicked';
+    properties: {
+        searchQuery: string;
+        title?: string;
+        url?: string;
+    };
+}
+
+export declare interface SearchRootRecord {
+    __typename: RecordTypes;
+    id: string;
+    title?: string;
+    url?: string;
+    preview?: string;
+    pathBreadcrumbs?: string[];
+    contentType?: string;
+    body?: string;
+    state?: `${GitHubIssueState}`;
+    markedAsCorrectAnswer?: {
+        url: string;
+        score: number;
+        content: string;
+    };
+}
+
+export declare interface SearchTab {
+    [0]: string;
+    [1]: {
+        alwaysVisible?: boolean;
+    };
+}
+
+declare interface SelectField extends BaseFormField {
+    inputType: 'SELECT';
+    items: SelectItem[];
+    defaultValue?: string;
+    placeholder?: string;
+}
+
+export declare interface SelectItem {
+    label: string;
+    value: string;
+}
+
+export declare interface ShadowRootProps {
+    mode?: 'closed' | 'open';
+    delegatesFocus?: boolean;
+    styleSheets?: CSSStyleSheet[];
+    ssr?: boolean;
+    children?: ReactNode;
+}
+
+export declare interface SourceItem {
+    id?: string;
+    title: string | undefined;
+    url: string;
+    description: string | undefined;
+    breadcrumbs: string[] | undefined;
+    type: `${SourceItemType}`;
+    contentType?: string;
+    tag?: string;
+}
+
+declare enum SourceItemType {
+    DOCUMENTATION = "documentation",
+    SITE = "site",
+    GITHUB_ISSUE = "github_issue",
+    GITHUB_DISCUSSION = "github_discussion",
+    DISCOURSE = "discourse",
+    DISCOURSE_POST = "discourse_post",
+    STACKOVERFLOW = "stackoverflow",
+    STACKOVERFLOW_QUESTION = "stackoverflow_question",
+    DISCORD = "discord",
+    DISCORD_MESSAGE = "discord_message",
+    DISCORD_FORUM_POST = "discord_forum_post",
+    MANUAL = "manual",
+    SUPPORT_TICKET = "support_ticket",
+    SLACK_MESSAGE = "slack_message"
+}
+
+export declare interface SourceTab {
+    [0]: string;
+    [1]: {
+        breadcrumbs: string[];
+    };
+}
+
+export declare interface StrictIkpTheme {
+    colors: Record<string, any>;
+    fontFamily: Record<string, string>;
+    fontSize: Record<string, string>;
+    zIndex: Record<string, string | number>;
+}
+
+export declare interface Style {
+    /**
+     * A unique identifier for the style.
+     * This is used to prevent duplicate styles and allow for style updates.
+     *
+     * @example
+     * key: 'custom-button-styles'
+     */
+    key?: string;
+    /**
+     * The type of style to apply.
+     * - 'link': Adds a <link> tag to load external resources like fonts or stylesheets
+     * - 'style': Injects CSS directly into a <style> tag
+     *
+     * @example
+     * type: 'link' // For loading external resources
+     * type: 'style' // For inline CSS
+     */
+    type: 'link' | 'style';
+    /**
+     * The content of the style.
+     * For type='link', this should be a valid URL to an external resource.
+     * For type='style', this should be valid CSS code.
+     *
+     * @example
+     * // For type='link':
+     * value: 'https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap'
+     *
+     * // For type='style':
+     * value: `.custom-button {
+     *   background: blue;
+     *   color: white;
+     * }`
+     */
+    value: string;
+}
+
+export declare type SubmitCallback = (values: SubmitCallbackArgs) => Promise<void> | void;
+
+export declare interface SubmitCallbackArgs {
+    values: FieldValues;
+    conversation: ConversationResponse | null;
+    client: Client;
+}
+
+declare interface SuccessView {
+    heading: string;
+    message: string;
+    button: SuccessViewButton;
+}
+
+declare interface SuccessViewButton {
+    label: string;
+    icon?: InkeepCustomIcon;
+    action: CloseFormAction;
+}
+
+export declare interface SyncColorMode {
+    /**
+     * The HTML element to watch for color mode changes.
+     * This element's attributes will be monitored for changes to determine the color mode.
+     *
+     * Common use cases include watching the document root or a specific app container.
+     *
+     * @example
+     * ```ts
+     * // Watch the document root element
+     * target: document.documentElement
+     *
+     * // Watch a specific container element
+     * target: document.querySelector('#app')
+     * ```
+     */
+    target: HTMLElement;
+    /**
+     * The specific attributes to monitor for color mode changes.
+     * The observer will only trigger when these attributes change on the target element.
+     *
+     * Common attributes used for theming include:
+     * - data-theme: Custom theme attribute
+     * - color-scheme: Standard CSS color scheme
+     * - class: Class-based theming
+     *
+     * @example
+     * ```ts
+     * // Watch data-theme attribute
+     * attributes: ['data-theme']
+     *
+     * // Watch color-scheme attribute
+     * attributes: ['color-scheme']
+     *
+     * // Watch class changes
+     * attributes: ['class']
+     * ```
+     */
+    attributes: string[];
+    /**
+     * A function that determines if dark mode is active based on the target element's attributes.
+     *
+     * The function receives an object containing the current values of all monitored attributes,
+     * where the keys are attribute names and values are the attribute values.
+     *
+     * @param attributes - Object containing the current values of monitored attributes
+     * @returns boolean - True if dark mode is detected, false otherwise
+     *
+     * @example
+     * ```ts
+     * // Check data-theme attribute
+     * isDarkMode: (attributes) => attributes['data-theme'] === 'dark'
+     *
+     * // Check class for dark mode
+     * isDarkMode: (attributes) => /\bdark\b/.test(attributes['class'])
+     *
+     * // Check color-scheme
+     * isDarkMode: (attributes) => attributes['color-scheme'] === 'dark'
+     * ```
+     */
+    isDarkMode: (attributes: Record<string, string | null>) => boolean;
+    /**
+     * Optional callback function that is invoked whenever the color mode changes.
+     *
+     * This can be used to perform side effects or sync the color mode with other parts of your application.
+     *
+     * @param colorMode - The new color mode value ('light' | 'dark')
+     *
+     * @example
+     * ```ts
+     * onChange: (colorMode) => {
+     *   console.log(`Color mode changed to: ${colorMode}`);
+     *   // Update other UI elements
+     * }
+     * ```
+     */
+    onChange?: (colorMode: string) => void;
+}
+
+export declare interface SyntaxHighlighterTheme {
+    lightTheme?: any;
+    darkTheme?: any;
+}
+
+export declare interface SystemMessage extends MessageBase {
+    role: 'system';
+}
+
+declare interface TextField extends BaseFormField {
+    inputType: 'EMAIL' | 'TEXT' | 'TEXTAREA';
+    defaultValue?: string;
+    placeholder?: string;
+}
+
+export declare interface Tool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: ToolsJSONSchema | unknown;
+    };
+}
+
+export declare interface ToolCall {
+    name: string;
+    arguments: string;
+    index: number;
+}
+
+export declare interface ToolCallAction {
+    label?: string;
+    icon?: InkeepCustomIcon;
+    action: ChatAction;
+}
+
+export declare interface ToolConfig {
+    /**
+     * Array of custom function tools that can be called by the AI assistant during chat interactions.
+     * Each tool must have a type (currently only 'function' is supported), a unique name, description,
+     * and a JSON Schema defining its parameters. Tools enable the AI to trigger actions in your application
+     * based on its responses, such as opening forms, links, or performing callbacks.
+     */
+    tools?: Tool[];
+    /**
+     * Callback function that handles tool calls triggered by the AI assistant.
+     * @param toolCall - Object containing the tool call details:
+     *   - name: The name of the function being called
+     *   - arguments: JSON string containing the arguments passed to the function
+     *   - index: The index of the tool call
+     * @returns A ToolCallAction object defining the action to perform (e.g., opening a link, displaying a form),
+     *          or undefined if no action should be taken
+     */
+    onToolCall?: (toolCall: ToolCall) => ToolCallAction | undefined;
+}
+
+export declare type ToolsJSONSchema = {
+    type: string;
+    properties?: Record<string, unknown>;
+    items?: unknown;
+    required?: string[];
+    description?: string;
+    enum?: unknown[];
+    const?: unknown;
+    anyOf?: unknown[];
+    allOf?: unknown[];
+    oneOf?: unknown[];
+    not?: unknown;
+    [key: string]: unknown;
+};
+
+export declare interface TransformedSource {
+    /**
+     * ID of the source.
+     */
+    id?: string;
+    /**
+     * Title of the source.
+     */
+    title: string;
+    /**
+     * URL of the source.
+     */
+    url: string;
+    /**
+     * Description of the source.
+     */
+    description?: string;
+    /**
+     * Breadcrumbs for the source.
+     *
+     * @example
+     * ```ts
+     * breadcrumbs: ['Subpath', 'Page']
+     * ```
+     */
+    breadcrumbs?: string[];
+    /**
+     * Tabs where this source shows up. (Only for searchResultsItem)
+     *
+     * @example
+     * ```ts
+     * tabs: ['Docs']
+     * tabs: ['Docs', 'API']
+     * ```
+     * You can also specify different breadcrumbs for specific tab.
+     * @example
+     * ```ts
+     * tabs: ['Docs', ['API', { breadcrumbs: ['Guides', 'API'] }]]
+     * ```
+     */
+    tabs?: (SourceTab | string)[];
+    /**
+     * Icon of the source.
+     *
+     * @example
+     * ```ts
+     * icon: { builtIn: 'LuBookOpen' }
+     * icon: { custom: 'https://example.com/icon.svg' }
+     * ```
+     */
+    icon: InkeepCustomIcon;
+    /**
+     * Whether to open the source in a new tab.
+     */
+    shouldOpenInNewTab?: boolean;
+    /**
+     * Search query params to append to the URL.
+     *
+     * @example
+     * If you want to know if the source is from chat or search, you can append the source type to the URL.
+     * ```ts
+     * appendToUrl: { from: 'chatSourceItem' }
+     * ```
+     */
+    appendToUrl?: UrlQueryParam;
+    /**
+     * Type of the source.
+     */
+    type: SourceItemType | `${SourceItemType}`;
+    /**
+     * Tag to append to the source.
+     */
+    tag?: string;
+}
+
+export declare type TransformSource = (source: SourceItem, type: TransformSourceType, opts?: TransformSourceOptions) => TransformedSource;
+
+export declare interface TransformSourceOptions {
+    organizationDisplayName?: string;
+    tabs?: InkeepSearchSettings['tabs'];
+}
+
+export declare type TransformSourceType = 'chatSourceItem' | 'searchResultItem' | 'intelligentFormSource';
+
+export declare type UrlQueryParam = Record<string, string>;
+
+export declare interface UseColorModeProps {
+    /** List of all available colorMode names */
+    colorModes: string[];
+    /** Forced colorMode name for the current page */
+    forcedColorMode?: string;
+    /** Update the colorMode */
+    setColorMode: (colorMode: string) => void;
+    /** Active colorMode name */
+    colorMode?: string;
+    /** If `enableSystem` is true and the active colorMode is "system", this returns whether the system preference resolved to "dark" or "light". Otherwise, identical to `colorMode` */
+    resolvedColorMode?: string;
+    /** If enableSystem is true, returns the System colorMode preference ("dark" or "light"), regardless what the active colorMode is */
+    systemColorMode?: 'dark' | 'light';
+}
+
+export declare interface UserMessage extends MessageBase {
+    role: 'user';
+}
+
+export declare interface UserProperties {
+    /**
+     * The user ID.
+     */
+    id?: string;
+    /**
+     * The user email.
+     */
+    email?: string;
+    /**
+     * The user name.
+     */
+    name?: string;
+    /**
+     * The user cohorts.
+     */
+    cohorts?: string[];
+}
+
+export declare interface UserProvidedColorScheme {
+    textBold?: string;
+    textSubtle?: string;
+    lighter?: string;
+    light?: string;
+    lightSubtle?: string;
+    medium?: string;
+    mediumSubtle?: string;
+    strong?: string;
+    stronger?: string;
+    textColorOnPrimary?: string;
+}
+
+export declare interface UserTheme extends Partial<IkpTheme> {
+    /**
+     * The syntax highlighter theme configuration for code blocks.
+     * Allows setting different themes for light and dark modes.
+     *
+     * @example
+     * ```ts
+     * syntaxHighlighter: {
+     *   lightTheme: themes.github,
+     *   darkTheme: themes.dracula
+     * }
+     * ```
+     */
+    syntaxHighlighter?: SyntaxHighlighterTheme;
+    /**
+     * The primary colors used to generate the color scheme.
+     * These colors will be used to create variations for different UI states.
+     *
+     * @example
+     * ```ts
+     * primaryColors: {
+     *   primary: '#26D6FF',
+     *   secondary: '#6366F1'
+     * }
+     * ```
+     */
+    primaryColors?: UserProvidedColorScheme;
+    /**
+     * The class name for the container that holds CSS variables.
+     * This class will be added to a wrapper div that provides theming context.
+     *
+     * @default 'ikp-variables'
+     */
+    varsClassName?: string;
+    /**
+     * Custom styles to be injected into the widget.
+     * Supports both inline styles and external stylesheets/resources.
+     * Styles are uniquely identified by their key to prevent duplicates.
+     *
+     * @example
+     * ```ts
+     * styles: [
+     *   // External stylesheet or font
+     *   {
+     *     key: 'google-fonts',
+     *     type: 'link',
+     *     value: 'https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap'
+     *   },
+     *   // Custom CSS rules
+     *   {
+     *     key: 'custom-theme',
+     *     type: 'style',
+     *     value: `
+     *       .ikp-ai-chat-message {
+     *         border-radius: 8px;
+     *         padding: 12px;
+     *       }
+     *       [data-theme='dark'] .ikp-ai-chat-message {
+     *         background: #2D3748;
+     *       }
+     *     `
+     *   }
+     * ]
+     * ```
+     */
+    styles?: Style[];
+}
+
+/** Adapted from https://github.com/pacocoursey/next-theme/blob/a385b8d865bbb317ff73a5b6c1319ae566f7d6f1/src/types.ts */
+declare interface ValueObject {
+    [colorModeName: string]: string;
+}
+
+export declare interface WidgetView {
+    /**
+     * Callback fired when the user toggles between chat and search views.
+     *
+     * The parent component can use this
+     * to coordinate showing/hiding the appropriate view.
+     */
+    onToggleView?: OnToggleView;
+    /**
+     * The label for the Ask AI button.
+     */
+    askAILabel?: string;
+    /**
+     * The label for the Search button.
+     */
+    searchLabel?: string;
+}
+
+/**
+ * Workflow defines the interaction steps for the AI bot.
+ */
+export declare interface Workflow {
+    id: string;
+    displayName: string;
+    goals: string[];
+    informationToCollect: WorkflowInformationToCollect[];
+    botPersona?: string;
+    context?: string[];
+    guidance?: string[];
+    initialReplyMessage: string;
+    supportedInputs?: WorkflowInputTypes[];
+}
+
+/**
+ * BaseType is a base interface for data types.
+ */
+declare interface WorkflowBaseContentType {
+    type: string;
+    contentInputLabel: string;
+    attachmentIcon?: InkeepCustomIcon;
+}
+
+/**
+ * WorkflowInputType defines the type of attachments in a Workflow.
+ */
+export declare interface WorkflowBaseInputTypes {
+    id: string;
+    type: string;
+    displayName: string;
+}
+
+export declare interface WorkflowCodeContentType extends WorkflowBaseContentType {
+    type: 'CODE';
+    language: string;
+}
+
+/**
+ * WorkflowFunctionalMultiInput represents a function to be called when the attachment is invoked.
+ */
+export declare interface WorkflowFunctionalMultiInput extends WorkflowBaseInputTypes {
+    type: 'FUNCTIONAL_MULTI_ATTACHMENT';
+    onInvoke: (workflow: Workflow, selectedInputType: WorkflowInputTypes, callback: (messageAttachments: MessageAttachment[]) => void, currentMessageAttachments: MessageAttachment[]) => void;
+}
+
+export declare interface WorkflowInformationToCollect {
+    description: string;
+    required: boolean;
+}
+
+/**
+ * WorkflowInputTypes represents possible ways of collecting attachments in a Workflow.
+ */
+export declare type WorkflowInputTypes = WorkflowFunctionalMultiInput | WorkflowModalSingleInput;
+
+export declare interface WorkflowModalProps {
+    titleInputLabel?: string;
+    modalHelpText?: string;
+    modalHelpElement?: React.ReactElement;
+}
+
+/**
+ * WorkflowModalSingleInput represents a modal input type.
+ */
+export declare interface WorkflowModalSingleInput extends WorkflowBaseInputTypes {
+    type: 'MODAL';
+    contentType: MessageAttachmentContentType;
+    workflowModalProps?: WorkflowModalProps;
+}
+
+export declare interface WorkflowTextContentType extends WorkflowBaseContentType {
+    type: 'TEXT';
+}
+
+export { }