@carbon/ai-chat 0.5.1 → 0.5.2

package/dist/types/serverEntry-C7dK61Jb.d.ts

@@ -0,0 +1,4434 @@
+import { NOTIFICATION_KIND } from '@carbon/web-components/es/components/notification/defs.js';
+import { BUTTON_KIND } from '@carbon/web-components/es/components/button/defs.js';
+import { ReactNode } from 'react';
+import * as lit_html from 'lit-html';
+import { LitElement, PropertyValues } from 'lit';
+import { Root } from 'react-dom/client';
+
+/**
+ * Whether a particular Carbon AI Chat view is visible or not.
+ *
+ * @category Instance
+ */
+interface ViewState {
+    /**
+     * Whether the launcher is visible or not.
+     */
+    launcher: boolean;
+    /**
+     * Whether the main window is visible or not.
+     */
+    mainWindow: boolean;
+}
+/**
+ * A record of a notification to be shown in the UI.
+ *
+ * @experimental
+ * @category Instance
+ */
+interface NotificationMessage {
+    kind: NOTIFICATION_KIND;
+    /**
+     * The title to show in the message.
+     */
+    title: string;
+    /**
+     * The message to show.
+     */
+    message: string;
+    /**
+     * An optional action button that a user can click. If there is an action button, we will not auto dismiss.
+     */
+    actionButtonLabel?: string;
+    /**
+     * The group id that associates notifications together. This can be used to remove the notification later.
+     */
+    groupID?: string;
+    /**
+     * The callback called when someone clicks on the action button.
+     */
+    onActionButtonClick?: () => void;
+    /**
+     * The callback called when someone clicks on the close button.
+     */
+    onCloseButtonClick?: () => void;
+}
+/**
+ * The different views that can be shown by Carbon AI Chat.
+ *
+ * @category Instance
+ */
+declare enum ViewType {
+    /**
+     * The launcher view is used to open the main window.
+     */
+    LAUNCHER = "launcher",
+    /**
+     * The main window view is used to ask WA questions and converse with an agent, as well as many other things. The
+     * string value is kept camel case to align with the viewState mainWindow property.
+     */
+    MAIN_WINDOW = "mainWindow"
+}
+/**
+ * This manager handles fetching an instance for manipulating the custom panel.
+ *
+ * @category Instance
+ */
+interface CustomPanels {
+    /**
+     * Gets a custom panel instance.
+     */
+    getPanel: () => CustomPanelInstance;
+}
+/**
+ * The custom panel instance for controlling and manipulating a custom panel in Carbon AI Chat.
+ *
+ * @category Instance
+ */
+interface CustomPanelInstance {
+    /**
+     * The custom panel hostElement.
+     */
+    hostElement?: HTMLDivElement | undefined;
+    /**
+     * Opens the custom panel.
+     *
+     * @param options Custom panel options.
+     */
+    open: (options?: CustomPanelConfigOptions) => void;
+    /**
+     * Closes the custom panel.
+     */
+    close: () => void;
+}
+/**
+ * Describes general config options for a Carbon AI Chat panel. These options are also part of the
+ * {@link BasePanelComponentProps}, except the options here are also shared with {@link CustomPanelConfigOptions}.
+ *
+ * Any options specific to either the BasePanelComponent or CustomPanelConfigOptions should be added to the respective
+ * interface.
+ *
+ * @category Instance
+ */
+interface BasePanelConfigOptions {
+    /**
+     * The panel title which is left blank by default.
+     */
+    title?: string;
+    /**
+     * Indicates if the close button in the custom panel should be hidden.
+     */
+    hideCloseButton?: boolean;
+    /**
+     * Indicates if the panel header should be hidden.
+     */
+    hidePanelHeader?: boolean;
+    /**
+     * Indicates if the back button in the custom panel should be hidden.
+     */
+    hideBackButton?: boolean;
+    /**
+     * This callback is called when the close button is clicked. This is called even if {@link disableDefaultCloseAction}
+     * is set to true.
+     */
+    onClickClose?: () => void;
+    /**
+     * Called when the restart button is clicked.
+     */
+    onClickRestart?: () => void;
+    /**
+     * This callback is called when the back button is clicked.
+     */
+    onClickBack?: () => void;
+}
+/**
+ * Options that change how the custom panel looks.
+ *
+ * @category Instance
+ */
+interface CustomPanelConfigOptions extends BasePanelConfigOptions {
+    /**
+     * Determines if the panel open/close animation should be turned off.
+     */
+    disableAnimation?: boolean;
+    /**
+     * Disables the default action that is taken when the close button is clicked. The default
+     * action closes Carbon AI Chat and disabling this will cause the button to not do anything. You can override the button
+     * behavior by using the {@link onClickClose} callback.
+     */
+    disableDefaultCloseAction?: boolean;
+}
+
+/*
+ *  Copyright IBM Corp. 2025
+ *
+ *  This source code is licensed under the Apache-2.0 license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ *  @license
+ */
+
+/**
+ * Utility type that makes all properties in T optional recursively.
+ *
+ * This type is useful for configuration objects where you want to allow
+ * partial updates to nested object structures. It recursively applies
+ * the optional modifier (?) to all properties, including nested objects.
+ *
+ * @template T - The type to make deeply partial
+ *
+ * @example
+ * ```typescript
+ * interface Config {
+ *   server: {
+ *     host: string;
+ *     port: number;
+ *   };
+ *   database: {
+ *     url: string;
+ *     timeout: number;
+ *   };
+ * }
+ *
+ * // All properties become optional, including nested ones
+ * const partialConfig: DeepPartial<Config> = {
+ *   server: {
+ *     host: "localhost" // port is optional
+ *   }
+ *   // database is optional entirely
+ * };
+ * ```
+ *
+ * @category Utilities
+ */
+type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+/**
+ * The different type of error states a given message can be in.
+ *
+ * @category Messaging
+ */
+declare enum MessageErrorState {
+    /**
+     * No errors.
+     */
+    NONE = 1,
+    /**
+     * The message failed to be sent and no more attempts will be made.
+     */
+    FAILED = 2,
+    /**
+     * The message failed while streaming.
+     */
+    FAILED_WHILE_STREAMING = 3,
+    /**
+     * There was an error sending the message but the system is retrying the message.
+     */
+    RETRYING = 4,
+    /**
+     * Indicates that the previous message has entered the retrying state and that this message is waiting for it to
+     * finish or fail. This message will remain in the waiting state until it finishes successfully or it enters a
+     * retrying state itself.
+     */
+    WAITING = 5
+}
+
+/**
+ * This file contains the generic types for the API between a general chat widget and a chat back-end. It is
+ * intended to provide base types for a standalone widget and should not contain any imports of other types.
+ */
+
+/**
+ * This is the main interface that represents a request from a user sent to an assistant.
+ *
+ * @category Messaging
+ */
+interface MessageRequest<TInputType extends BaseMessageInput = MessageInput> {
+    /**
+     * The unique identifier for this request object. This value may be assigned by the client when a request is
+     * made but should be assigned by the service if one is not provided.
+     */
+    id?: string;
+    /**
+     * The history information to store as part of this request. This includes extra information that was provided to
+     * the user and about the user that was used in making the request.
+     */
+    history?: MessageRequestHistory;
+    /**
+     * The input data to the back-end to make in this request.
+     */
+    input: TInputType;
+    /**
+     * Optional context which is added from external resources.
+     */
+    context?: unknown;
+    /**
+     * The ID of the thread this request belongs to. This is here to prepare for input message editing and regenerating
+     * responses.
+     */
+    thread_id?: string;
+}
+/**
+ * The set of possible message input types in a request.
+ *
+ * @category Messaging
+ */
+declare enum MessageInputType {
+    /**
+     * Represents a simple text message.
+     */
+    TEXT = "text",
+    /**
+     * Represents an event message that can be used to send control, updates, or action information to the back-end.
+     */
+    EVENT = "event"
+}
+/**
+ * @category Messaging
+ */
+interface BaseMessageInput {
+    /**
+     * The type of user input.
+     */
+    message_type?: MessageInputType;
+}
+/**
+ * Base interface for an event message that can be used to send control, updates, or action information to the back-end.
+ *
+ * @category Messaging
+ */
+interface EventInput<TEventInputType = EventInputData> extends BaseMessageInput {
+    /**
+     * Event messages have this as their input type.
+     */
+    message_type: MessageInputType.EVENT;
+    /**
+     * The type of the event.
+     */
+    event: TEventInputType;
+}
+/**
+ * Input for an event. The name of the event is mandatory. Additional fields depend on the event.
+ *
+ * @template TNameType The type of the name property for the event. This can just be a string or it can be a
+ * specific string in order to create type safety ensuring each event has the right name (e.g. "typeof MY_EVENT_NAME").
+ *
+ * @category Messaging
+ */
+interface EventInputData<TNameType extends string = string> {
+    /**
+     * The name of the event.
+     */
+    name: TNameType;
+}
+/**
+ * The default interface for message input that is sent to an assistant in a message request. This represents basic text
+ * input.
+ *
+ * @category Messaging
+ */
+interface MessageInput extends BaseMessageInput {
+    /**
+     * The text of the user input to send to the back-end.
+     */
+    text?: string;
+    /**
+     * For messages that are sent between the user and a human agent, we assign an agent type to the message to distinguish what type it is.
+     */
+    agent_message_type?: HumanAgentMessageType;
+}
+/**
+ * This interface represents the main response content that is received by a client from an assistant. It is generally
+ * in response to a previous message request.
+ *
+ * @category Messaging
+ */
+interface MessageResponse<TGenericType = GenericItem[]> {
+    /**
+     * A unique identifier for this response object.
+     */
+    id?: string;
+    /**
+     * The id of the request that this is the response of.
+     */
+    request_id?: string;
+    /**
+     * The output from the back-end to be rendered or processed by the client.
+     */
+    output: MessageOutput<TGenericType>;
+    /**
+     * The context information returned by the back-end.
+     */
+    context?: unknown;
+    /**
+     * The ID of the thread this request belongs to. This is here to prepare for input message editing and regenerating
+     * responses.
+     */
+    thread_id?: string;
+    /**
+     * The history information to store as part of this request.
+     */
+    history?: MessageResponseHistory;
+    /**
+     * Options for the {@link MessageResponse}. This includes metadata about the user or assistant sending this response.
+     */
+    message_options?: MessageResponseOptions;
+}
+/**
+ * The output context for a message response from an assistant.
+ *
+ * @category Messaging
+ */
+interface MessageOutput<TGenericType = GenericItem[]> {
+    /**
+     * Responses intended to be processed by a generic channel. This will be an array of message response items.
+     */
+    generic?: TGenericType;
+}
+/**
+ * The set of possible message types in a response.
+ *
+ * @category Messaging
+ */
+declare enum MessageResponseTypes {
+    /**
+     * Represents a basic text response. The given text may contain rich content such as markdown.
+     */
+    TEXT = "text",
+    /**
+     * A response that requests the user choose an option from a list. The list of options may be presented as a list
+     * of buttons or it may be from a drop-down.
+     */
+    OPTION = "option",
+    /**
+     * Indicates that the conversation should be escalated to a human agent and offers that opportunity to the user.
+     */
+    CONNECT_TO_HUMAN_AGENT = "connect_to_agent",
+    /**
+     * Displays an image to the user.
+     */
+    IMAGE = "image",
+    /**
+     * Indicates that the chat should display a pause at this point in the conversation before displaying additional
+     * items.
+     */
+    PAUSE = "pause",
+    /**
+     * A user defined response will be displayed according to custom logic in the client.
+     */
+    USER_DEFINED = "user_defined",
+    /**
+     * Displays the contents of an iframe to the user.
+     */
+    IFRAME = "iframe",
+    /**
+     * Displays a video to the user using a video player.
+     */
+    VIDEO = "video",
+    /**
+     * Displays an audio clip to the user using an audio player.
+     */
+    AUDIO = "audio",
+    /**
+     * Asks the user to provide a date. This may result in a date picker being presented to the user.
+     */
+    DATE = "date",
+    /**
+     * Displays a general error message to the user and include developer info to be logged and to debug.
+     */
+    INLINE_ERROR = "inline_error",
+    /**
+     * Displays a card that can contain other response types.
+     */
+    CARD = "card",
+    /**
+     * Displays a carousel of cards that can contain other response types.
+     */
+    CAROUSEL = "carousel",
+    /**
+     * Displays a button that can either send a message back to the backend, open a url, or throw a client side event.
+     */
+    BUTTON = "button",
+    /**
+     * Ability to layout response types inside a grid.
+     */
+    GRID = "grid",
+    /**
+     * Ability to show citations on your RAG result.
+     */
+    CONVERSATIONAL_SEARCH = "conversational_search"
+}
+/**
+ * These are the human agent specific message types.
+ *
+ * @category Service desk
+ */
+declare enum HumanAgentMessageType {
+    /**
+     * There was an error in a message.
+     */
+    INLINE_ERROR = "inline_error",
+    /**
+     * The agent sent a message.
+     */
+    FROM_HUMAN_AGENT = "from_agent",
+    /**
+     * The user sent a message.
+     */
+    FROM_USER = "from_user",
+    /**
+     * The agent left the chat.
+     */
+    HUMAN_AGENT_LEFT_CHAT = "agent_left_chat",
+    /**
+     * The agent ended the conversation.
+     */
+    HUMAN_AGENT_ENDED_CHAT = "agent_ended_chat",
+    /**
+     * The agent joined the conversation.
+     */
+    HUMAN_AGENT_JOINED = "agent_joined",
+    /**
+     * A disconnection warning was emitted.
+     */
+    RELOAD_WARNING = "user_connected_warning",
+    /**
+     * The conversation was transferred to another agent.
+     */
+    TRANSFER_TO_HUMAN_AGENT = "transfer_to_agent",
+    /**
+     * The end user ended the conversation with the agent.
+     */
+    USER_ENDED_CHAT = "user_ended_chat",
+    /**
+     * The conversation was ended.
+     */
+    CHAT_WAS_ENDED = "chat_was_ended",
+    /**
+     * The conversation was disconnected.
+     */
+    DISCONNECTED = "disconnected",
+    /**
+     * The conversation was re-connected.
+     */
+    RECONNECTED = "reconnected",
+    /**
+     * Screen sharing requested.
+     */
+    SHARING_REQUESTED = "sharing_requested",
+    /**
+     * Screen sharing accepted.
+     */
+    SHARING_ACCEPTED = "sharing_accepted",
+    /**
+     * Screen sharing declined.
+     */
+    SHARING_DECLINED = "sharing_declined",
+    /**
+     * Screen sharing cancelled.
+     */
+    SHARING_CANCELLED = "sharing_cancelled",
+    /**
+     * Screen sharing ended.
+     */
+    SHARING_ENDED = "sharing_ended",
+    /**
+     * A system message.
+     */
+    SYSTEM = "system"
+}
+/**
+ * A general type to indicate any message.
+ *
+ * @category Messaging
+ */
+type Message = MessageRequest<MessageInput> | MessageRequest<EventInput> | MessageResponse;
+/**
+ * @category Messaging
+ */
+interface ItemStreamingMetadata {
+    /**
+     * An identifier for this item within the full message response. This ID is used to correlate a partial or
+     * complete item chunk with other chunks that represent the same item. This ID is only unique for a given message
+     * response.
+     */
+    id: string;
+    /**
+     * When included on a partial_item, indicates if the stream can be cancelled.
+     * If so, a "stop streaming" button will display in the UI.
+     */
+    cancellable?: boolean;
+    /**
+     * Indicates if the stream has stopped which will trigger the UI to respond with appropriate a11y states
+     * and messaging.
+     */
+    stream_stopped?: boolean;
+}
+/**
+ * Status of the chain of thought step.
+ *
+ * @category Messaging
+ */
+declare enum ChainOfThoughtStepStatus {
+    PROCESSING = "processing",
+    FAILURE = "failure",
+    SUCCESS = "success"
+}
+/**
+ * A chain of thought step is meant to show tool calls and other steps made by your agent
+ * to reach its final answer.
+ *
+ * @category Messaging
+ */
+interface ChainOfThoughtStep {
+    /**
+     * The plain text name of the step.
+     */
+    title?: string;
+    /**
+     * An optional human readable description of what the tool does.
+     *
+     * Accepts markdown formatted text.
+     */
+    description?: string;
+    /**
+     * The plain text name of the tool called.
+     */
+    tool_name?: string;
+    /**
+     * Optional request metadata sent to a tool.
+     */
+    request?: {
+        /**
+         * Arguments sent to the tool. If this is properly formed JSON, it will be shown as a code block.
+         */
+        args?: unknown;
+    };
+    /**
+     * Optional response from a tool.
+     */
+    response?: {
+        /**
+         * Content returned by the tool. If this is properly formed JSON, it will be shown as a code block.
+         *
+         * You can also return markdown compatible text here.
+         */
+        content: unknown;
+    };
+    /**
+     * Optionally, share the status of this step. An icon will appear in the view showing the status. If no status is
+     * shared, the UI will assume success.
+     */
+    status?: ChainOfThoughtStepStatus;
+}
+/**
+ * Options that control additional features available for a message item.
+ *
+ * @category Messaging
+ */
+interface GenericItemMessageOptions {
+    /**
+     * Controls the display of feedback options (thumbs up/down) for a message item.
+     */
+    feedback?: GenericItemMessageFeedbackOptions;
+}
+/**
+ * If you want to have different categories for positive and negative feedback, you can provide two different arrays.
+ *
+ * You may not provide one of the arrays. e.g. you want negative categories but don't care about positive categories.
+ *
+ * @category Messaging
+ */
+interface GenericItemMessageFeedbackCategories {
+    /**
+     * List of strings for positive feedback categories.
+     */
+    positive?: string[];
+    /**
+     * List of strings for negative feedback categories.
+     */
+    negative?: string[];
+}
+/**
+ * Controls the display of a feedback options (thumbs up/down) for a message item.
+ *
+ * @category Messaging
+ */
+interface GenericItemMessageFeedbackOptions {
+    /**
+     * Indicates if a request for feedback should be displayed.
+     */
+    is_on?: boolean;
+    /**
+     * A unique identifier for this feedback. This is required for the feedback to be recorded in message history.
+     */
+    id?: string;
+    /**
+     * Indicates if the user should be asked for additional detailed information when providing positive feedback. This
+     * defaults to true.
+     */
+    show_positive_details?: boolean;
+    /**
+     * Indicates if the user should be asked for additional detailed information when providing negative feedback. This
+     * defaults to true.
+     */
+    show_negative_details?: boolean;
+    /**
+     * Indicates whether the text area should be shown. This defaults to true.
+     */
+    show_text_area?: boolean;
+    /**
+     * Indicates whether the prompt line should be shown. This defaults to true.
+     */
+    show_prompt?: boolean;
+    /**
+     * The title to display in the popup. A default value will be used if no value is provided here.
+     */
+    title?: string;
+    /**
+     * The prompt text to display to the user. A default value will be used if no value is provided here.
+     */
+    prompt?: string;
+    /**
+     * An optional set of categories to allow the user to choose from. This can either be an array of strings for
+     * both positive and negative feedback or a {@link GenericItemMessageFeedbackCategories} object to make different
+     * configuration for both.
+     */
+    categories?: string[] | GenericItemMessageFeedbackCategories;
+    /**
+     * The placeholder to show in the text area. A default value will be used if no value is provided here.
+     */
+    placeholder?: string;
+    /**
+     * The legal disclaimer text to show at the bottom of the popup. This text may contain rich markdown content. If this
+     * value is not provided, no text will be shown.
+     */
+    disclaimer?: string;
+}
+/**
+ * @category Messaging
+ */
+type PartialOrCompleteItemChunk = PartialItemChunk | CompleteItemChunk;
+/**
+ * The base interface that all message response items must implement. Contains common properties
+ * shared by all item types.
+ *
+ * @category Messaging
+ */
+interface BaseGenericItem<TUserDefinedType = Record<string, unknown>> {
+    /**
+     * The response type of this message item.
+     */
+    response_type: MessageResponseTypes;
+    /**
+     * Metadata used to identify a generic item within the context of a stream in order to correlate any updates meant
+     * for a specific item.
+     */
+    streaming_metadata?: ItemStreamingMetadata;
+    /**
+     * An optional buckets of additional user defined properties for this item.
+     */
+    user_defined?: TUserDefinedType;
+    /**
+     * For messages that are sent between the user and a human agent, we assign an agent type to the message to distinguish what type it is.
+     */
+    agent_message_type?: HumanAgentMessageType;
+    /**
+     * Options that control additional features available for a message item.
+     */
+    message_item_options?: GenericItemMessageOptions;
+}
+/**
+ * The basic class for items returned from an assistant as part of a message response. These are the items contained
+ * in the {@link MessageOutput.generic} array.
+ *
+ * @category Messaging
+ */
+type GenericItem<TUserDefinedType = Record<string, unknown>> = TextItem<TUserDefinedType> | OptionItem<TUserDefinedType> | ConnectToHumanAgentItem<TUserDefinedType> | ImageItem<TUserDefinedType> | PauseItem<TUserDefinedType> | UserDefinedItem<TUserDefinedType> | IFrameItem<TUserDefinedType> | VideoItem<TUserDefinedType> | AudioItem<TUserDefinedType> | DateItem<TUserDefinedType> | InlineErrorItem<TUserDefinedType> | CardItem<TUserDefinedType> | CarouselItem<TUserDefinedType> | ButtonItem<TUserDefinedType> | GridItem<TUserDefinedType> | ConversationalSearchItem<TUserDefinedType>;
+/**
+ * A user defined item returned in a message response from an assistant.
+ *
+ * @category Messaging
+ */
+interface UserDefinedItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * If the user_defined response type should be rendered as full width and ignore margin on the "start".
+     */
+    full_width?: boolean;
+}
+/**
+ * A text item returned in a message response from an assistant.
+ *
+ * The Carbon AI Chat supports basic styling inside text responses to match the theme of your Carbon AI Chat,
+ * both with Markdown or HTML content returned from your assistant. Using Markdown and `user_defined`
+ * ({@link UserDefinedItem}) responses instead of HTML in your text responses is the recommendation. It allows
+ * adding channels that do not support HTML (such as Facebook, Slack, or WhatsApp) without having to rewrite
+ * your content.
+ *
+ * ## Markdown
+ *
+ * The Carbon AI Chat supports the following Markdown syntax in the text response type:
+ *
+ * **Text formatting:**
+ *
+ * - `**bold text**` or `__bold text__`
+ * - `*italic text*` or `_italic text_`
+ * - `~~strikethrough~~`
+ * - `==highlighted text==`
+ * - `^superscript^`
+ * - `~subscript~`
+ *
+ * **Code:**
+ *
+ * - `` `inline code` `` or fenced code blocks with syntax highlighting.
+ *
+ * **Headers:**
+ *
+ * - `# H1`, `## H2`, `### H3`, `#### H4`, `##### H5`, `###### H6`
+ *
+ * **Lists:**
+ *
+ * - Unordered lists using `*`, `+`, or `-`
+ * - Ordered lists using `1.`, `2.`, etc.
+ * - Nested lists are supported
+ *
+ * **Links and images:**
+ *
+ * - `[link text](URL)` for links (opens in new tab by default)
+ * - `![alt text](image URL)` for images
+ *
+ * **Other elements:**
+ *
+ * - `> blockquote text` for blockquotes
+ * - Tables using pipe syntax with automatic pagination and sorting
+ * - Horizontal rules using `---` or `***`
+ * - Line breaks are preserved (breaks: true)
+ * - Automatic URL detection and conversion to links
+ *
+ * **Attributes:**
+ *
+ * - Custom attributes using `{{class="my-class" id="my-id"}}` syntax
+ * - Supported attributes: `target`, `rel`, `class`, `id`
+ *
+ * **HTML support:**
+ *
+ * - Raw HTML is supported when enabled
+ * - Custom elements and web components are allowed
+ * - Content is sanitized for security when sanitization is enabled
+ *
+ * The Carbon AI Chat follows CommonMark rules with these extensions and enhancements.
+ *
+ * ## HTML content
+ *
+ * If you include HTML (including `style` and `script` tags) in your text response from your assistant, the
+ * Carbon AI Chat renders those elements as provided, unless you set {@link PublicConfig.shouldSanitizeHTML}
+ * to `true`. A better approach is to use a `user_defined` response instead of adding HTML directly to your
+ * responses to make adding support for channels that do not support HTML easier.
+ *
+ * @category Messaging
+ */
+interface TextItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * The text of the response.
+     */
+    text?: string;
+}
+/**
+ * A "connect to agent" item returned in a message response from an assistant. This is used when the back-end
+ * indicates that a user's conversation should be escalated to a human agent.
+ *
+ * @category Messaging
+ */
+interface ConnectToHumanAgentItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * A message to be sent to the human agent who will be taking over the conversation.
+     */
+    message_to_human_agent?: string;
+    /**
+     * Contains the message to be rendered if there are agents available.
+     */
+    agent_available?: {
+        message: string;
+    };
+    /**
+     * Contains the message to be rendered if there are no agents available.
+     */
+    agent_unavailable?: {
+        message: string;
+    };
+    /**
+     * When a conversation is escalated to an agent additional information is needed to fulfill the request. This
+     * additional information typically is added by the channel integration and cannot be deduced from the dialog
+     * itself.
+     */
+    transfer_info?: ConnectToHumanAgentItemTransferInfo;
+}
+/**
+ * Additional information as part of a {@link ConnectToHumanAgentItem} that may be needed to perform a transfer to an agent.
+ *
+ * @category Messaging
+ */
+interface ConnectToHumanAgentItemTransferInfo {
+    /**
+     * Each service desk may require different information to start the connection. It can be account details or
+     * security information. This is a bucket of all the service desk specific properties.
+     */
+    additional_data?: {
+        [key: string]: string;
+    };
+    /**
+     * An initial set of message items to send to the agent.
+     */
+    summary_message_to_agent?: TextItem[];
+}
+/**
+ * A pause item returned in a message response from an assistant. This indicates that the client should pause before
+ * displaying additional response items.
+ *
+ * @category Messaging
+ */
+interface PauseItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * How long to pause, in milliseconds.
+     */
+    time?: number;
+    /**
+     * Whether to display an "is typing" indicator during the pause.
+     */
+    typing?: boolean;
+}
+/**
+ * An option item returned in a message response from an assistant. This response type is used when displaying a list
+ * of options to the user. How the options are displayed is up to the client but is often displayed in either a
+ * drop-down or as a list of buttons.
+ *
+ * @category Messaging
+ */
+interface OptionItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * An array of objects describing the options from which the user can choose.
+     */
+    options: SingleOption[];
+    /**
+     * An optional title to be shown alongside the options.
+     */
+    title?: string;
+    /**
+     * An optional description to be shown alongside the options.
+     */
+    description?: string;
+    /**
+     * The preferred type of control to display (e.g. button or dropdown).
+     */
+    preference?: OptionItemPreference;
+}
+/**
+ * The set of possible response preferences for an options response.
+ *
+ * @category Messaging
+ */
+declare enum OptionItemPreference {
+    /**
+     * Indicates the options should be displayed as a drop-down.
+     */
+    DROPDOWN = "dropdown",
+    /**
+     * Indicates the options should be displayed as buttons.
+     */
+    BUTTON = "button"
+}
+/**
+ * Represents an individual option that is part of an "options" response.
+ *
+ * @category Messaging
+ */
+interface SingleOption {
+    /**
+     * The user-facing label for the option or disambiguation suggestion. This label is taken from the user_label property
+     * of the corresponding dialog node.
+     */
+    label: string;
+    value: {
+        /**
+         * An input object that should be sent back to the assistant when this option is chosen by a user.
+         */
+        input: MessageInput;
+    };
+}
+/**
+ * @category Messaging
+ */
+interface IFrameItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * The source URL to an embeddable page
+     */
+    source: string;
+    /**
+     * The preview image of the source URL. This property is unfurled from the source URL at runtime. It is used when
+     * IFrameItemDisplayOption is set to 'panel' for the preview card to open the panel.
+     */
+    image_url?: string;
+    /**
+     * The title of the source URL. This property is unfurled from the source URL at runtime. It is used when
+     * IFrameItemDisplayOption is set to 'panel' for the preview card to open the panel.
+     */
+    title?: string;
+    /**
+     * The description of the source URL. This property is unfurled from the source URL at runtime. It is used when
+     * IFrameItemDisplayOption is set to 'panel' for the preview card to open the panel.
+     */
+    description?: string;
+    /**
+     * How the iframe should be displayed.
+     */
+    display?: IFrameItemDisplayOption;
+}
+/**
+ * Dimension information for displaying a media item.
+ *
+ * @category Messaging
+ */
+interface MediaItemDimensions {
+    /**
+     * This property's value is used to calculate a responsive height for Carbon AI Chat's media player so that its aspect
+     * ratio is the same between different screen widths. This is set to a reasonable default depending on the response type
+     * and other details like what service you are pulling the content from (e.g. Youtube or SoundCloud).
+     */
+    base_height?: number;
+}
+/**
+ * The different ways an iframe item may be displayed.
+ *
+ * @category Messaging
+ */
+declare enum IFrameItemDisplayOption {
+    /**
+     * The iframe is displayed inline in the main message list.
+     */
+    INLINE = "inline",
+    /**
+     * The iframe is displayed in a separate panel after showing a card in the main message list.
+     */
+    PANEL = "panel"
+}
+/**
+ * A reusable media object that may need to display a title and description with an alt_text to label the item for
+ * accessibility purposes. This is used by the Audio, Video and Image response types.
+ *
+ * @category Messaging
+ */
+interface MediaItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * The url pointing to a media source, whether audio, video, or image.
+     *
+     * For video this can be a file like an .mp4 or a YouTube, Facebook, Vimeo, Twitch, Streamable, Wistia, or Vidyard url.
+     *
+     * For audio this can be a file like an .mp3 or a SoundCloud or Mixcloud url.
+     */
+    source: string;
+    /**
+     * The title for the item.
+     */
+    title?: string;
+    /**
+     * The description for the item.
+     */
+    description?: string;
+    /**
+     * The alt text for labeling the item. Screen readers will announce this text when the user's virtual cursor
+     * is focused on the item.
+     */
+    alt_text?: string;
+    /**
+     * Settings that control the dimensions for the media item.
+     */
+    dimensions?: MediaItemDimensions;
+}
+/**
+ * Citations for text generated by an AI to provide the user with relevant source information and context.
+ *
+ * @category Messaging
+ */
+interface ConversationalSearchItemCitation {
+    /**
+     * Optional url of the citation. May not be a valid URL.
+     */
+    url?: string;
+    /**
+     * Optional explanation text for the citation.
+     */
+    text?: string;
+    /**
+     * Optional title of the citation URL.
+     */
+    title?: string;
+    /**
+     * Optional array of ranges indicating where in `text` the citation is located.
+     */
+    ranges?: {
+        start: number;
+        end: number;
+    }[];
+    /**
+     * In some implementations, the content searched isn't in an accessible URL. For instance, it could be from Milvus or
+     * ElasticSearch. In that scenario, you may populate "search_results". This field will allow you define which index in
+     * the search_results array matches with this citation. The end user can then drill into the larger search result to
+     * view it rather than clicking on a URL to actually see the content.
+     */
+    search_result_idx?: number;
+}
+/**
+ * A text response generated by AI with an optional list of citations for where the information came from.
+ *
+ * @category Messaging
+ */
+interface ConversationalSearchItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * The returned conversational text. Any HTML/Markdown will be ignored.
+     */
+    text: string;
+    /**
+     * Citations are used to connect specific text within a conversational search response with the relevant documents
+     * returned by the backend.
+     */
+    citations?: ConversationalSearchItemCitation[];
+    /**
+     * In some implementations, the content searched isn't in an accessible URL. For instance, it could be from Milvus or
+     * ElasticSearch. In that scenario, you may populate "search_results". Combine this with
+     * {@link ConversationalSearchItemCitation.search_result_idx}.
+     */
+    search_results?: SearchResult[];
+}
+/**
+ * An inline error response generated by a conversational skill provider with a user-friendly text and developer debug info.
+ *
+ * @category Messaging
+ */
+interface InlineErrorItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * Some end user friendly text describing the error and what they should do next.
+     *
+     * If no specific text is passed, the client is responsible for fallback generic error message text.
+     */
+    text?: string;
+    /**
+     * Relevant debug info intended to be passed on to developers.
+     *
+     * This information should not include anything sensitive that might reveal details about our back-end environment that should not be public.
+     */
+    debug?: {
+        /**
+         * The error code of any underlying error, despite the service returning 200.
+         */
+        statusCode?: number;
+        /**
+         * Developer-friendly error text.
+         */
+        text?: string;
+        /**
+         * Any additional key-value pairs for debugging.
+         */
+        info?: Record<string, unknown>;
+    };
+}
+/**
+ * The image response type definition. This is currently the same as {@link MediaItem}.
+ *
+ * @category Messaging
+ */
+type ImageItem<TUserDefinedType = Record<string, unknown>> = MediaItem<TUserDefinedType>;
+/**
+ * The video response type definition for future reuse. This is currently the same as {@link MediaItem}.
+ *
+ * @category Messaging
+ */
+type VideoItem<TUserDefinedType = Record<string, unknown>> = MediaItem<TUserDefinedType>;
+/**
+ * The audio response type definition for future reuse. This is currently the same as {@link MediaItem}.
+ *
+ * @category Messaging
+ */
+type AudioItem<TUserDefinedType = Record<string, unknown>> = MediaItem<TUserDefinedType>;
+/**
+ * @category Messaging
+ */
+declare enum ButtonItemType {
+    /**
+     * A button that sends its value back to the backend.
+     */
+    POST_BACK = "post_back",
+    /**
+     * A button that throws an event for your UI to respond to.
+     */
+    CUSTOM_EVENT = "custom_event",
+    /**
+     * A button that shows a panel.
+     */
+    SHOW_PANEL = "show_panel",
+    /**
+     * A button that opens a URL.
+     */
+    URL = "url"
+}
+/**
+ * @category Messaging
+ */
+declare enum WidthOptions {
+    /**
+     * Width the size of the floating chat for smaller content.
+     */
+    SMALL = "small",
+    /**
+     * Max width of 438px, 2/3rd of the width of chat in fullscreen view with hasContentMaxWidth: true.
+     */
+    MEDIUM = "medium",
+    /**
+     * Max width of 585px, the full with of chat in fullscreen view with hasContentMaxWidth: true.
+     */
+    LARGE = "large"
+}
+/**
+ * @category Messaging
+ */
+interface WithWidthOptions {
+    /**
+     * Sets an optional max width of the component. Options are small, medium and large.
+     * By default, the component will be 100% width of the container.
+     */
+    max_width?: WidthOptions;
+}
+/**
+ * @category Messaging
+ */
+interface WithBodyAndFooter {
+    /**
+     * A list of message items to render in a Carbon AI Chat panel.
+     */
+    body?: GenericItem[];
+    /**
+     * A list of button items that are rendered under the panel body.
+     */
+    footer?: ButtonItem[];
+}
+/**
+ * @category Messaging
+ */
+interface MessageItemPanelInfo extends WithBodyAndFooter {
+    /**
+     * The title to give the panel in Carbon AI Chat.
+     */
+    title?: string;
+    /**
+     * Determines if the panel header should not be visible or not.
+     */
+    show_header?: boolean;
+    /**
+     * Determines if the panel close and open animations should be enabled or not.
+     */
+    show_animations?: boolean;
+}
+/**
+ * @category Messaging
+ */
+declare enum ButtonItemKind {
+    /**
+     * Default Carbon button.
+     */
+    DEFAULT = "default",
+    /**
+     * Secondary Carbon button.
+     */
+    SECONDARY = "secondary",
+    /**
+     * Tertiary Carbon button.
+     */
+    TERTIARY = "tertiary",
+    /**
+     * Danger Carbon button.
+     */
+    DANGER = "danger",
+    /**
+     * Ghost Carbon button.
+     */
+    GHOST = "ghost",
+    /**
+     * Button displayed like a link.
+     */
+    LINK = "link"
+}
+/**
+ * This message item represents a button that can perform various actions such as sending messages, opening URLs, or showing panels.
+ *
+ * @category Messaging
+ */
+interface ButtonItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    /**
+     * The style of button to display.
+     */
+    kind?: BUTTON_KIND | "LINK";
+    /**
+     * The type of button.
+     */
+    button_type: ButtonItemType;
+    /**
+     * The URL for the user to visit when the button is clicked.
+     */
+    url?: string;
+    /**
+     * Where to open the link. The default value is _self.
+     */
+    target?: string;
+    /**
+     * The display text for the link.
+     */
+    label?: string;
+    /**
+     * A custom event that can be listened to by Carbon AI Chat when the button item is clicked.
+     */
+    custom_event_name?: string;
+    value?: {
+        /**
+         * An input object that should be sent back to the assistant when this option is chosen by a user.
+         */
+        input: MessageInput;
+    };
+    /**
+     * The panel options to display in a panel when the "show_panel" button type is clicked.
+     */
+    panel?: MessageItemPanelInfo;
+    /**
+     * The URL pointing to an image.
+     */
+    image_url?: string;
+    /**
+     * The alt text for labeling the item. Screen readers will announce this text when the user's virtual cursor
+     * is focused on the item.
+     */
+    alt_text?: string;
+}
+/**
+ * @category Messaging
+ */
+type CardItem<TUserDefinedType = Record<string, unknown>> = BaseGenericItem<TUserDefinedType> & WithBodyAndFooter & WithWidthOptions;
+/**
+ * @category Messaging
+ */
+interface CarouselItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType> {
+    items: GenericItem[];
+}
+/**
+ * Horizontal alignment values for items in a grid response.
+ *
+ * @category Messaging
+ */
+type HorizontalCellAlignment = "left" | "center" | "right";
+/**
+ * Vertical alignment values for items in a grid response.
+ *
+ * @category Messaging
+ */
+type VerticalCellAlignment = "top" | "center" | "bottom";
+/**
+ * @category Messaging
+ */
+interface GridItem<TUserDefinedType = Record<string, unknown>> extends BaseGenericItem<TUserDefinedType>, WithWidthOptions {
+    /**
+     * Determines the horizontal alignment of all items in the grid.
+     */
+    horizontal_alignment?: HorizontalCellAlignment;
+    /**
+     * Determines the vertical alignment of all items in the grid.
+     */
+    vertical_alignment?: VerticalCellAlignment;
+    /**
+     * The list of column specifications. This will determine the maximum number of columns that can be rendered.
+     */
+    columns: {
+        width: string;
+    }[];
+    /**
+     * A list of rows to render.
+     */
+    rows: {
+        /**
+         * A list of cells to render in a row.
+         */
+        cells: {
+            /**
+             * Determines the horizontal alignment of items in the individual cell.
+             */
+            horizontal_alignment?: HorizontalCellAlignment;
+            /**
+             * Determines the vertical alignment of items in the individual cell.
+             */
+            vertical_alignment?: VerticalCellAlignment;
+            /**
+             * Message items to render in the cell.
+             */
+            items: GenericItem[];
+        }[];
+    }[];
+}
+/**
+ * This is the response item that represents a request for a date which should prompt the client to use a date picker or
+ * similar control to provide a date. There are currently no additional properties of the response.
+ *
+ * @category Messaging
+ */
+type DateItem<TUserDefinedType = Record<string, unknown>> = BaseGenericItem<TUserDefinedType>;
+/**
+ * @category Messaging
+ */
+interface Chunk {
+    /**
+     * Additional metadata associated with the stream.
+     */
+    streaming_metadata?: {
+        /**
+         * The ID of the complete message response object. This ID will be the ID of the full message that is received
+         * in the final chunk of the stream.
+         */
+        response_id: string;
+    };
+}
+/**
+ * This interface contains options for a {@link MessageResponse}.
+ *
+ * @category Messaging
+ */
+interface MessageResponseOptions {
+    /**
+     * This is the profile for the human or assistant who sent or triggered this message.
+     */
+    response_user_profile?: ResponseUserProfile;
+    /**
+     * Controls the display of the chain of thought component.
+     */
+    chain_of_thought?: ChainOfThoughtStep[];
+}
+/**
+ * This interface contains information about the history of a given {@link MessageResponse}. This information should be
+ * saved your history store.
+ *
+ * @category Messaging
+ */
+interface MessageResponseHistory {
+    /**
+     * The time at which this message occurred.
+     */
+    timestamp?: number;
+    /**
+     * Indicates if this is a "silent" message. These messages are sent to or received from the assistant but should
+     * not be displayed to the user.
+     */
+    silent?: boolean;
+    /**
+     * The error state of this message.
+     */
+    error_state?: MessageErrorState;
+    /**
+     * The state of feedback provided on the items in this message.
+     */
+    feedback?: {
+        [feedbackID: string]: MessageHistoryFeedback;
+    };
+}
+/**
+ * This interface contains information about the history of a given {@link MessageRequest}. This information should be
+ * saved your history store.
+ *
+ * @category Messaging
+ */
+interface MessageRequestHistory {
+    /**
+     * The time at which this message occurred.
+     */
+    timestamp?: number;
+    /**
+     * The user-friendly label that was associated with this message. This is used on messages that were sent by the
+     * user to the assistant to request a response. This is the user displayed text that was entered or selected by
+     * the user when that request was made. Most commonly used to make sure a {@link OptionItem} shows the correct button
+     * selected when loading history.
+     */
+    label?: string;
+    /**
+     * If the message was a welcome node request.
+     */
+    is_welcome_request?: boolean;
+    /**
+     * If this message is related to another message, this is the ID of that other message. This is used when a user
+     * choices an option and it includes the ID of the message response that presented the options to the user so we
+     * can associate the user's request with that earlier response and display the appropriate selected state.
+     */
+    related_message_id?: string;
+    /**
+     * Indicates if this is a "silent" message. These messages are sent to or received from the assistant but should
+     * not be displayed to the user.
+     */
+    silent?: boolean;
+    /**
+     * The error state of this message.
+     */
+    error_state?: MessageErrorState;
+}
+/**
+ * @category Messaging
+ */
+interface MessageHistoryFeedback {
+    /**
+     * Indicates if positive feedback was provided.
+     */
+    is_positive: boolean;
+    /**
+     * The feedback text provided by the user.
+     */
+    text?: string;
+    /**
+     * When submitting feedback details, this is the list of categories the user selected (if visible).
+     */
+    categories?: string[];
+}
+/**
+ * @category Messaging
+ */
+interface PartialResponse {
+    /**
+     * This contains the history of this response.
+     */
+    message_options?: DeepPartial<MessageResponseOptions>;
+}
+/**
+ * The interface for a chunk that represents a partial update (or first time chunk) to a message item.
+ *
+ * @category Messaging
+ */
+interface PartialItemChunk extends Chunk {
+    /**
+     * The partial details of the item. The client will decide what rules to follow for merging this in with any
+     * existing data for the same item (which is identified using the {@link ItemStreamingMetadata.id} property).
+     */
+    partial_item: DeepPartial<GenericItem>;
+    /**
+     * Change the agent display name and other items on the full response.
+     */
+    partial_response?: PartialResponse;
+}
+/**
+ * A chunk that represents a complete update to a single message item within a streaming response.
+ *
+ * This chunk type exists to allow immediate replacement of a streaming item with its final, corrected version
+ * before the entire message response is complete. This enables real-time corrections to individual items
+ * (like fixing typos in streaming text) while other items in the same message may still be streaming.
+ *
+ * The item provided here should have all the data necessary to render the item including any data that was
+ * previously received from partial chunks. This chunk may contain corrections to previous chunks.
+ *
+ * Use this when you need to finalize a specific item but the overall message response isn't ready yet.
+ *
+ * If you are only streaming a single item you can skip
+ * this chunk type entirely. CompleteItemChunk is primarily useful when streaming multiple different message
+ * items and you need to finalize one item while others are still streaming.
+ *
+ * For ending the entire streaming response en masse, use {@link FinalResponseChunk}.
+ *
+ * @category Messaging
+ */
+interface CompleteItemChunk extends Chunk {
+    complete_item: GenericItem;
+    /**
+     * Change the agent display name and other items on the full response.
+     */
+    partial_response?: PartialResponse;
+}
+/**
+ * A chunk that represents the entire completed message response, signaling the end of streaming.
+ *
+ * This chunk type exists as the definitive way to close a streaming session and provide the final,
+ * authoritative version of the complete message response. Unlike {@link CompleteItemChunk} which updates
+ * individual items, this chunk finalizes the entire response and triggers cleanup of streaming UI states
+ * (like hiding "stop streaming" buttons).
+ *
+ * The response provided here should have all the data necessary to render the response including any data
+ * that was previously received from item chunks. This final response may contain corrections to previous chunks.
+ *
+ * Use this to signal that streaming is complete and provide the canonical final state of the entire message.
+ * The ID of the message should match the ID that was previously provided by streaming_metadata.response_id.
+ *
+ * @category Messaging
+ */
+interface FinalResponseChunk {
+    final_response: MessageResponse;
+}
+/**
+ * @category Messaging
+ */
+type StreamChunk = PartialItemChunk | CompleteItemChunk | FinalResponseChunk;
+/**
+ * Types of users we accept messages from.
+ *
+ * @category Messaging
+ */
+declare enum UserType {
+    /**
+     * A message from a human.
+     */
+    HUMAN = "human",
+    /**
+     * A message from a non-watsonx assistant, used for interacting with assistants that are not backed by watsonx.
+     *
+     * Official guidance is to not use this for IBM products without explicit exception.
+     */
+    BOT = "bot",
+    /**
+     * A message from watsonx.
+     */
+    WATSONX = "watsonx"
+}
+/**
+ * Profile information about a specific agent that can be used to display information to the user. This may
+ * represent a human agent or a virtual assistant agent.
+ *
+ * @category Messaging
+ */
+interface ResponseUserProfile {
+    /**
+     * A unique identifier for this agent.
+     */
+    id: string;
+    /**
+     * The visible name for the response author. Can be the full name or just a first name for a human.
+     */
+    nickname: string;
+    /**
+     * The type of user. If its a "human" there is more protection against code injection attacks, where as assistant responses
+     * are trusted by default unless {@link PublicConfig.shouldSanitizeHTML} is set to true.
+     */
+    user_type: UserType;
+    /**
+     * A URL pointing to an avatar for the response author. This image should be a square.
+     */
+    profile_picture_url?: string;
+}
+/**
+ * A single search result.
+ *
+ * @category Messaging
+ */
+interface SearchResult {
+    /**
+     * The search result. This can be drilled into and viewed in a larger and scrollable format.
+     */
+    body?: string;
+}
+
+/**
+ * Constants for the Carbon FileStatus type because they weren't kind enough to include their own enum.
+ *
+ * @category Service desk
+ */
+declare enum FileStatusValue {
+    COMPLETE = "complete",
+    EDIT = "edit",
+    UPLOADING = "uploading",
+    SUCCESS = "success"
+}
+/**
+ * An interface that represents a file to upload and its current upload status.
+ *
+ * @category Service desk
+ */
+interface FileUpload {
+    /**
+     * A unique ID for the file.
+     */
+    id: string;
+    /**
+     * The file to upload.
+     */
+    file: File;
+    /**
+     * The current upload status.
+     */
+    status: FileStatusValue;
+    /**
+     * Indicates if the file contains an error or failed to upload.
+     */
+    isError?: boolean;
+    /**
+     * If the file failed to upload, this is an optional error message to display.
+     */
+    errorMessage?: string;
+}
+/**
+ * The section of the public config that contains configuration options for service desk integrations.
+ *
+ * @category Service desk
+ */
+interface ServiceDeskPublicConfig {
+    /**
+     * The timeout value in seconds to use when determining agent availability. When a connect_to_agent response is
+     * received, the system will ask the service desk if any agents are available. If no response is received within
+     * the timeout window, the system will return "false" to indicate no agents are available.
+     */
+    availabilityTimeoutSeconds?: number;
+    /**
+     * Indicates if Carbon AI Chat should auto-connect to an agent whenever it receives a connect_to_agent response and
+     * agents are available. This essentially mimics the user clicking the "Request agent" button on the card. The
+     * card is still displayed to the user.
+     */
+    skipConnectHumanAgentCard?: boolean;
+    /**
+     * The timeout value is seconds to use when waiting for an agent to join the chat after an agent has been
+     * requested. If no agent joins after this time, the chat will be ended and an error message will be displayed to
+     * the user. By default, there is no timeout.
+     */
+    agentJoinTimeoutSeconds?: number;
+    /**
+     * Indicates if Carbon AI Chat should automatically attempt to reconnect the user to a human agent when it is loaded. This
+     * only works if the service desk integration being used supports reconnecting. This value defaults to true.
+     */
+    allowReconnect?: boolean;
+}
+/**
+ * Represents the different states for the availability of a human agent from a service desk.
+ *
+ * @category Service desk
+ */
+declare enum HumanAgentsOnlineStatus {
+    /**
+     * Indicates that agents are online.
+     */
+    ONLINE = "online",
+    /**
+     * Indicates that no agents are online.
+     */
+    OFFLINE = "offline",
+    /**
+     * Indicates that it is unknown whether any agents are available. This may be because the service desk being used
+     * doesn't support the ability to determine this information.
+     */
+    UNKNOWN = "unknown"
+}
+/**
+ * The parameters that are passed to a service desk factory.
+ *
+ * @category Service desk
+ */
+interface ServiceDeskFactoryParameters {
+    /**
+     * The callback used by the service desk to communicate with the widget.
+     */
+    callback: ServiceDeskCallback;
+    /**
+     * The instance of Carbon AI Chat.
+     */
+    instance: ChatInstance;
+    /**
+     * Any state that was stored for the service desk. This value may be undefined if no state has been stored.
+     */
+    persistedState: unknown;
+}
+/**
+ * This interface represents the operations that a service desk integration can call on Carbon AI Chat when it wants web
+ * chat to do something. When a service desk integration instance is created, Carbon AI Chat will provide an
+ * implementation of this interface to the integration for it to use.
+ *
+ * @category Service desk
+ */
+interface ServiceDeskCallback<TPersistedStateType = unknown> {
+    /**
+     * Updates Carbon AI Chat with the capabilities supported by the service desk. Some of these capabilities may support
+     * being changed dynamically and can be updated at any time.
+     *
+     * @param capabilities The set of capabilities to update. Only properties that need to be changed need to be included.
+     */
+    updateCapabilities(capabilities: Partial<ServiceDeskCapabilities>): void;
+    /**
+     * Sends updated availability information to the chat widget for a user who is waiting to be connected to an
+     * agent (e.g. the user is number 2 in line). This may be called at any point while waiting for the connection to
+     * provide newer information.
+     *
+     * Note: Of the fields in the AgentAvailability object, only one of positionInQueue and estimatedWaitTime can be
+     * rendered in the widget. If both fields are provided, estimatedWaitTime will take priority and the
+     * positionInQueue field will be ignored.
+     *
+     * @param availability The availability information to display to the user.
+     */
+    updateAgentAvailability(availability: AgentAvailability): Promise<void>;
+    /**
+     * Informs the chat widget that an agent has joined the chat.
+     */
+    agentJoined(profile: ResponseUserProfile): Promise<void>;
+    /**
+     * Informs the chat widget that the agent has read all the messages that have been sent to the service desk.
+     */
+    agentReadMessages(): Promise<void>;
+    /**
+     * Tells the chat widget if an agent has started or stopped typing.
+     *
+     * @param isTyping If true, indicates that the agent is typing. False indicates the agent has stopped typing.
+     */
+    agentTyping(isTyping: boolean): Promise<void>;
+    /**
+     * Sends a message to the chat widget from an agent.
+     *
+     * Note: The text response type from the standard Watson API is supported in addition to the Carbon AI Chat specific
+     * MessageResponseTypes.INLINE_ERROR response type.
+     *
+     * @param message The message to display to the user. Note, the ability to pass a string for the message was added in
+     * Carbon AI Chat 6.7.0. Earlier versions of Carbon AI Chat will not work if you pass just a string.
+     * @param agentID The ID of the agent who is sending the message. If this is not provided, then the ID of the last
+     * agent who joined the conversation will be used.
+     */
+    sendMessageToUser(message: MessageResponse | string, agentID?: string): Promise<void>;
+    /**
+     * Informs the chat widget that a transfer to another agent is in progress. The agent profile information is
+     * optional if the service desk doesn't have the information available. This message simply tells the chat widget
+     * that the transfer has started. The service desk should inform the widget when the transfer is complete by
+     * sending a {@link agentJoined} message later.
+     */
+    beginTransferToAnotherAgent(profile?: ResponseUserProfile): Promise<void>;
+    /**
+     * Informs the chat widget that the agent has left the conversation. This does not end the conversation itself,
+     * rather the only action that occurs is the visitor receives the agent left status message. If the user sends
+     * another message, it is up to the service desk to decide what to do with it.
+     */
+    agentLeftChat(): Promise<void>;
+    /**
+     * Informs the chat widget that the agent has ended the conversation.
+     */
+    agentEndedChat(): Promise<void>;
+    /**
+     * Sets the state of the given error type.
+     *
+     * @param errorInfo Details for the error whose state is being set.
+     */
+    setErrorStatus(errorInfo: ServiceDeskErrorInfo): Promise<void>;
+    /**
+     * Updates the status of a file upload. The upload may either be successful or an error may have occurred. The
+     * location of a file upload may be in one of two places. The first occurs when the user has selected a file to be
+     * uploaded but has not yet sent the file. In this case, the file appears inside the Carbon AI Chat input area. If an
+     * error is indicated on the file, the error message will be displayed along with the file and the user must
+     * remove the file from the input area before a message can be sent.
+     *
+     * The second occurs after the user has sent the file and the service desk has begun to upload the file. In this
+     * case, the file no longer appears in the input area but appears as a sent message in the message list. If an
+     * error occurs during this time, an icon will appear next to the message to indicate an error occurred and an
+     * error message will be added to the message list.
+     *
+     * @param fileID The ID of the file upload to update.
+     * @param isError Indicates that the upload has an error or failed to upload.
+     * @param errorMessage An error message to display along with a file in error.
+     */
+    setFileUploadStatus(fileID: string, isError?: boolean, errorMessage?: string): Promise<void>;
+    /**
+     * Requests that the user share their screen with the agent. This will present a modal dialog to the user who must
+     * respond before continuing the conversation. This method returns a Promise that resolves when the user has
+     * responded to the request or the request times out.
+     *
+     * @returns Returns a Promise that will resolve with the state the of the request. This Promise will reject if no
+     * chat with an agent is currently running.
+     */
+    screenShareRequest(): Promise<ScreenShareState>;
+    /**
+     * Informs Carbon AI Chat that a screen sharing session has ended or been cancelled. This may occur while waiting for a
+     * screen sharing request to be accepted or while screen sharing is in progress.
+     */
+    screenShareEnded(): Promise<void>;
+    /**
+     * Returns the persisted agent state from the store. This is the current state as updated by
+     * {@link updatePersistedState}. The object returned here is frozen and may not be modified.
+     */
+    persistedState(): TPersistedStateType;
+    /**
+     * Allows the service desk to store state that may be retrieved when Carbon AI Chat is reloaded on a page. This information
+     * is stored in browser session storage which has a total limit of 5MB per origin so the storage should be used
+     * sparingly. Also, the value provided here must be JSON serializable.
+     *
+     * When Carbon AI Chat is reloaded, the data provided here will be returned to the service desk via the
+     * ServiceDeskFactoryParameters.persistedState property. This data may also be retrieved by using the
+     * {@link persistedState} method.
+     *
+     * @param state The state to update.
+     * @param mergeWithCurrent Indicates if the new state should be merged into the existing state. If false, then the
+     * existing state will be fully replaced with the new state. Merging with existing state expects the state to be
+     * an object. This argument is true by default.
+     */
+    updatePersistedState(state: DeepPartial<TPersistedStateType>, mergeWithCurrent?: boolean): void;
+}
+/**
+ * The set of capabilities and parameters that are supported by the service desk.
+ *
+ * @category Service desk
+ */
+type ServiceDeskCapabilities = FileUploadCapabilities;
+/**
+ * The possible state changes for a screen sharing request.
+ *
+ * @category Service desk
+ */
+declare enum ScreenShareState {
+    /**
+     * Indicates the screen sharing was accepted by the user.
+     */
+    ACCEPTED = "accepted",
+    /**
+     * Indicates the screen sharing was declined by the user.
+     */
+    DECLINED = "declined",
+    /**
+     * Indicates the screen sharing request was cancelled.
+     */
+    CANCELLED = "cancelled",
+    /**
+     * Indicates that screen sharing has ended.
+     */
+    ENDED = "ended"
+}
+/**
+ * Information about the current availability of an agent while a user is waiting to be connected. If these are not set
+ * the Carbon AI Chat will provide generic messaging letting the user know that a request for an agent has been sent.
+ *
+ * Note that only one of these fields will be used by Carbon AI Chat if more than one has been assigned a value. Priority
+ * first goes to estimatedWaitTime, then positionInQueue, and then message.
+ *
+ * @category Service desk
+ */
+interface AgentAvailability {
+    /**
+     * The current position of the user in a queue. E.g. "You are number 2 in line."
+     */
+    positionInQueue?: number;
+    /**
+     * The estimated wait time for the user in minutes. E.g. "Current wait time is 2 minutes."
+     */
+    estimatedWaitTime?: number;
+    /**
+     * A custom message to display to the user containing the updated status. This may contain markdown.
+     */
+    message?: string;
+}
+/**
+ * The possible events that may have some form of error status.
+ *
+ * @category Service desk
+ */
+declare enum ErrorType {
+    /**
+     * This error is meant to be displayed while the user is attempting to connect to a service desk and before an
+     * agent has joined. If this error is generated by the service desk, it is expected that the service desk will
+     * treat the chat as having ended (or never started).
+     */
+    CONNECTING = 1,
+    /**
+     * This is used to indicate the state of errors that can happen any time during a chat where the service desk
+     * implementation has lost a connection to the back-end. If this error occurs while the user is waiting for an
+     * agent to join, it will be treated as a {@link ErrorType.CONNECTING} error instead.
+     */
+    DISCONNECTED = 2,
+    /**
+     * This error is used to report when there was an error sending a message to the agent.
+     */
+    USER_MESSAGE = 3
+}
+/**
+ * This is the parent interface for the information passed to {@link ServiceDeskCallback#setErrorStatus}. It is used
+ * as a discriminating union where the {@link #type} property is the discriminating value that determines which
+ * child interface is to be used.
+ *
+ * @category Service desk
+ */
+interface BaseErrorInfo {
+    /**
+     * An optional value that will be logged to the console as an error.
+     */
+    logInfo?: unknown;
+}
+/**
+ * This error is meant to be displayed while the user is attempting to connect to a service desk and before an
+ * agent has joined. If this error is generated by the service desk, it is expected that the service desk will
+ * treat the chat as having ended (or never started).
+ *
+ * @category Service desk
+ */
+interface ConnectingErrorInfo extends BaseErrorInfo {
+    /**
+     * The discriminating value for this type.
+     */
+    type: ErrorType.CONNECTING;
+    /**
+     * An optional message that is displayed to the user in the assistant view. If this value is not provided, a default
+     * message will be shown instead.
+     *
+     * Note that support for this field was added in Carbon AI Chat 6.7.0. It will be ignored in earlier versions.
+     */
+    messageToUser?: string;
+}
+/**
+ * This is used to indicate the state of errors that can happen any time during a chat where the service desk
+ * implementation has lost a connection to the back-end. If this error occurs while the user is waiting for an
+ * agent to join, it will be treated as a {@link ErrorType.CONNECTING} error instead.
+ *
+ * @category Service desk
+ */
+interface DisconnectedErrorInfo extends BaseErrorInfo {
+    /**
+     * The discriminating value for this type.
+     */
+    type: ErrorType.DISCONNECTED;
+    /**
+     * Indicates if the service desk has become disconnected. A value of true can be passed that will indicate that a
+     * previous disconnection is over and the service desk is now connected again.
+     */
+    isDisconnected: boolean;
+}
+/**
+ * This error is used to report when there was an error sending a message to the agent.
+ *
+ * @category Service desk
+ */
+interface UserMessageErrorInfo extends BaseErrorInfo {
+    /**
+     * The discriminating value for this type.
+     */
+    type: ErrorType.USER_MESSAGE;
+    /**
+     * The ID of the message that is in error.
+     */
+    messageID: string;
+}
+/**
+ * The type for the information passed to {@link ServiceDeskCallback#setErrorStatus}. It is a discriminating union
+ * where the type property is the discriminating value that determines which child interface is to be used.
+ *
+ * @category Service desk
+ */
+type ServiceDeskErrorInfo = ConnectingErrorInfo | DisconnectedErrorInfo | UserMessageErrorInfo;
+/**
+ * Additional options that may be passed to the service desk when a chat is started.
+ *
+ * @category Service desk
+ */
+interface StartChatOptions<TPayloadType = unknown> {
+    /**
+     * Some arbitrary payload of data that was provided as part of the "human_agent:pre:startChat" event.
+     */
+    preStartChatPayload: TPayloadType;
+}
+/**
+ * Additional info that may be provided when a chat is ended.
+ *
+ * @category Service desk
+ */
+interface EndChatInfo<TPayloadType = unknown> {
+    /**
+     * Before a chat is ended, a {@link BusEventType.HUMAN_AGENT_PRE_END_CHAT} is fired. The payload value assigned to this
+     * event by a listener is provided here.
+     */
+    preEndChatPayload: TPayloadType;
+    /**
+     * Indicates if the chat was ended by the agent (or by the service desk integration). If false, indicates the chat
+     * was ended by the user or by Carbon AI Chat.
+     */
+    endedByHumanAgent: boolean;
+}
+/**
+ * This is a set of additional data that may be included when the user sends a message to an agent.
+ *
+ * @category Service desk
+ */
+interface AdditionalDataToAgent {
+    /**
+     * A set of files that user has selected to upload to an agent. This value may be undefined if there are no files
+     * to upload.
+     */
+    filesToUpload?: FileUpload[];
+}
+/**
+ * This is the public interface for a human agent service desk integration. This is the interface between the chat
+ * widget and the implementation of the human agent interface with one of the various supported service desks.
+ *
+ * @category Service desk
+ */
+interface ServiceDesk {
+    /**
+     * Returns a name for this service desk integration. This value should reflect the service desk that is being
+     * integrated to (e.g. "genesys web messenger"). This information will be reported to IBM and may be used to gauge
+     * interest in various service desks for the possibility of creating fully supported out-of-the-box implementations.
+     *
+     * This value is required for custom service desks and may have a maximum of 40 characters.
+     */
+    getName?: () => string;
+    /**
+     * Instructs the service desk to start a new chat. This will be called when a user requests to connect to an agent
+     * and Carbon AI Chat initiates the process (typically when the user clicks the button on the "Connect to Agent" card).
+     * It will make the appropriate calls to the service desk to start the chat and will make use of the callback to
+     * inform Carbon AI Chat when an agent joins or messages are received.
+     *
+     * This may be called multiple times by Carbon AI Chat. If a user begins a chat with an agent, ends the chat and then
+     * begins a new chat with an agent, this function will be called again.
+     *
+     * If the integration is unable to start a chat (such as if the service desk is down or no agents are available)
+     * then this function should throw an error to let Carbon AI Chat know that the chat could not be started.
+     *
+     * The {@link areAnyAgentsOnline} function is called before this function is called and is called as soon as a
+     * "connect_to_agent" message has been received from the assistant. This determines if the "Connect to Agent" card
+     * should be displayed to the user or if the "no agents are available" message configured in the skill should be
+     * shown instead.
+     *
+     * @param connectMessage The original server message response that caused the connection to an agent. It will
+     * contain specific information to send to the service desk as part of the connection. This can include things
+     * like a message to display to a human agent.
+     * @param startChatOptions Additional configuration for startChat.
+     * @returns Returns a Promise that resolves when the service desk has successfully started a new chat. This does
+     * not necessarily mean that an agent has joined the conversation or has read any messages sent by the user.
+     */
+    startChat: (connectMessage: MessageResponse, startChatOptions: StartChatOptions) => Promise<void>;
+    /**
+     * Tells the service desk to terminate the chat.
+     *
+     * @param info Additional info that may be provided as part of ending the chat.
+     * @returns Returns a Promise that resolves when the service desk has successfully handled the call.
+     */
+    endChat: (info: EndChatInfo<unknown>) => Promise<void>;
+    /**
+     * Sends a message to the agent in the service desk. Note that the message text may be empty if the user has
+     * selected files to upload and has not chosen to include a message to go along with the files.
+     *
+     * @param message The message from the user.
+     * @param messageID The unique ID of the message assigned by the widget.
+     * @param additionalData Additional data to include in the message to the agent.
+     * @returns Returns a Promise that resolves when the service desk has successfully handled the call.
+     */
+    sendMessageToAgent: (message: MessageRequest, messageID: string, additionalData: AdditionalDataToAgent) => Promise<void>;
+    /**
+     * Tells the service desk if a user has started or stopped typing.
+     *
+     * @param isTyping If true, indicates that the user is typing. False indicates the user has stopped typing.
+     * @returns Returns a Promise that resolves when the service desk has successfully handled the call.
+     * @since 5.1.1
+     */
+    userTyping?: (isTyping: boolean) => Promise<void>;
+    /**
+     * Informs the service desk that the user has read all the messages that have been sent by the service desk.
+     *
+     * @returns Returns a Promise that resolves when the service desk has successfully handled the call.
+     */
+    userReadMessages?: () => Promise<void>;
+    /**
+     * Checks if any agents are online and can connect to a user when they become available. This does not necessarily
+     * mean that an agent is immediately available; when a chat is started, the user may still have to wait for an
+     * agent to become available. The callback function {@link ServiceDeskCallback.updateAgentAvailability} is used to
+     * give the user more up-to-date information while they are waiting for an agent to become available.
+     *
+     * @param connectMessage The message that contains the transfer_info object that may be used by the service desk,
+     * so it can perform a more specific check.
+     * @returns True if some agents are available or false if no agents are available. This may also return null which
+     * means the availability status of agents is unknown or the service desk doesn't support this information.
+     */
+    areAnyAgentsOnline?: (connectMessage: MessageResponse) => Promise<boolean | null>;
+    /**
+     * Indicates that the user has selected some files to be uploaded but that the user has not yet chosen to send
+     * them to the agent. This method can use this as an opportunity to perform any early validation of the files in
+     * order to display an error to the user. It should not actually upload the files at this point. If the user
+     * chooses to send the files to the agent, they will be included later when {@link ServiceDesk#sendMessageToAgent} is called.
+     *
+     * This method may be called multiple times before a user sends the files.
+     *
+     * If there are errors in the files, this method should use {@link ServiceDeskCallback#setFileUploadStatus} to update
+     * the status with an error message. The user will not be able to upload any files until any files in error are
+     * removed.
+     */
+    filesSelectedForUpload?: (uploads: FileUpload[]) => void;
+    /**
+     * Tells the service desk that the user has requested to stop sharing their screen.
+     */
+    screenShareStop?: () => Promise<void>;
+    /**
+     * This will be called when the service desk is first initialized and it is determined that the user was previously
+     * connected to an agent. This function should perform whatever steps are necessary to reconnect the user. Web chat
+     * will assume the user is permitted to send messages and is connected to the same agent when this function resolves.
+     *
+     * @returns true to indicate that the reconnect was successful.
+     */
+    reconnect?: () => Promise<boolean>;
+}
+
+/**
+ * This file contains the type definitions for the event bus.
+ */
+
+/** @category Events */
+declare enum BusEventType {
+    /**
+     * When a panel has been closed.
+     */
+    CLOSE_PANEL_BUTTON_TOGGLED = "closePanelButton:toggled",
+    /**
+     * Fired before a message is received. Can take mutations to the message.
+     */
+    PRE_RECEIVE = "pre:receive",
+    /**
+     * Fired after a message is received.
+     */
+    RECEIVE = "receive",
+    /**
+     * Fired before a message is sent to customSendMessage. Can take mutations to the message.
+     */
+    PRE_SEND = "pre:send",
+    /**
+     * Fired after the message is sent to customSendMessage.
+     */
+    SEND = "send",
+    /**
+     * Fired before the view changes (e.g. when the chat window closes).
+     */
+    VIEW_PRE_CHANGE = "view:pre:change",
+    /**
+     * Fired after the view changes (e.g. when the chat window closes).
+     */
+    VIEW_CHANGE = "view:change",
+    MESSAGE_ITEM_CUSTOM = "messageItemCustom",
+    /**
+     * Fired when a userDefined message is received.
+     */
+    USER_DEFINED_RESPONSE = "userDefinedResponse",
+    /**
+     * Fired when history begins to load.
+     */
+    HISTORY_BEGIN = "history:begin",
+    /**
+     * Fired after history is loaded.
+     */
+    HISTORY_END = "history:end",
+    /**
+     * Fired before a conversation restarts.
+     */
+    PRE_RESTART_CONVERSATION = "pre:restartConversation",
+    /**
+     * Fired after a conversation restarts.
+     */
+    RESTART_CONVERSATION = "restartConversation",
+    /**
+     * When the chat has finished hydrating from history or welcome node request.
+     */
+    CHAT_READY = "chat:ready",
+    /**
+     * Fired before a custom panel opens.
+     */
+    CUSTOM_PANEL_PRE_OPEN = "customPanel:pre:open",
+    /**
+     * Fired after a custom panel opens.
+     */
+    CUSTOM_PANEL_OPEN = "customPanel:open",
+    /**
+     * Fired before a custom panel closes.
+     */
+    CUSTOM_PANEL_PRE_CLOSE = "customPanel:pre:close",
+    /**
+     * Fired after a custom panel closes.
+     */
+    CUSTOM_PANEL_CLOSE = "customPanel:close",
+    /**
+     * This event is fired before Carbon AI Chat processes a message received from a human agent from a service desk.
+     * You can use this to filter messages before they are displayed to the end user.
+     */
+    HUMAN_AGENT_PRE_RECEIVE = "human_agent:pre:receive",
+    /**
+     * This event is fired after Carbon AI Chat processes a message received from a human agent from a service desk.
+     * You can use this to update your history store.
+     */
+    HUMAN_AGENT_RECEIVE = "human_agent:receive",
+    /**
+     * This event is fired before Carbon AI Chat sends a message to a human agent from a service desk.
+     * You can use this to filter messages before they are sent to the agent.
+     */
+    HUMAN_AGENT_PRE_SEND = "human_agent:pre:send",
+    /**
+     * This event is fired after Carbon AI Chat sends a message to a human agent from a service desk.
+     * You can use this to update your history store.
+     */
+    HUMAN_AGENT_SEND = "human_agent:send",
+    /**
+     * This event is fired before a chat with a service desk has started. This occurs as soon as the user clicks the
+     * "Request agent" button and before any attempt is made to communicate with the service desk.
+     */
+    HUMAN_AGENT_PRE_START_CHAT = "human_agent:pre:startChat",
+    /**
+     * This event is fired before a chat with an agent is ended. This occurs after the user has selected "Yes" from the
+     * confirmation modal but it can also be fired if the chat is ended by the agent. Note that this is not fired if a
+     * request for an agent is cancelled. The human_agent:endChat event however is fired in that case.
+     */
+    HUMAN_AGENT_PRE_END_CHAT = "human_agent:pre:endChat",
+    /**
+     * This event is fired after a chat with an agent has ended. This is fired after {@link BusEventType.HUMAN_AGENT_PRE_END_CHAT} but
+     * can be fired both from the user leaving the chat or the agent ending the chat.
+     */
+    HUMAN_AGENT_END_CHAT = "human_agent:endChat",
+    /**
+     * This event is fired after Carbon AI Chat calls "areAnyAgentsOnline" for a service desk. It will report the value returned
+     * from that call. This is particularly useful if some custom code wants to take action if no agents are online.
+     */
+    HUMAN_AGENT_ARE_ANY_AGENTS_ONLINE = "human_agent:areAnyAgentsOnline",
+    /**
+     * Fired when a new chunk in a user_defined response comes through.
+     */
+    CHUNK_USER_DEFINED_RESPONSE = "chunk:userDefinedResponse",
+    /**
+     * This event is fired when the user interacts with the feedback controls on a message. This includes both the feedback
+     * buttons (thumbs up/down) as well as the details popup where the user can submit additional information.
+     */
+    FEEDBACK = "feedback",
+    /**
+     * This event is fired when the "stop streaming" button in the input field is clicked.
+     */
+    STOP_STREAMING = "stopStreaming",
+    /**
+     * This event is fired whenever the public state returned by ChatInstance.getState() changes.
+     * This includes changes to viewState, showUnreadIndicator, and other persisted state.
+     */
+    STATE_CHANGE = "state:change",
+    /**
+     * Fired if the disclaimer is accepted.
+     */
+    DISCLAIMER_ACCEPTED = "disclaimerAccepted"
+}
+/**
+ * The possible reasons why the view may be changed.
+ *
+ * @category Events
+ */
+declare enum ViewChangeReason {
+    /**
+     * Indicates the Carbon AI Chat has loaded for the first time and a view is trying to open. If openChatByDefault is
+     * true then the main window will be trying to open, otherwise the launcher will be trying to open.
+     */
+    WEB_CHAT_LOADED = "webChatLoaded",
+    /**
+     * Indicates the user clicked on our built-in launcher button that opened the main window.
+     */
+    LAUNCHER_CLICKED = "launcherClicked",
+    /**
+     * Indicates the user clicked on our built-in minimize button that closed the launcher.
+     */
+    MAIN_WINDOW_MINIMIZED = "mainWindowMinimized",
+    /**
+     * Indicates the user clicked the close and restart button that minimized to the launcher.
+     */
+    MAIN_WINDOW_CLOSED_AND_RESTARTED = "mainWindowClosedAndRestarted",
+    /**
+     * Indicates the view was changed by a call to {@link ChatInstance.changeView}.
+     */
+    CALLED_CHANGE_VIEW = "calledChangeView"
+}
+/**
+ * The different sources that can cause a send event to occur.
+ *
+ * @category Events
+ */
+declare enum MessageSendSource {
+    /**
+     * The user has entered a value from the main input on the message list.
+     */
+    MESSAGE_INPUT = "messageInput",
+    /**
+     * The user has entered a value from the input on the home screen.
+     */
+    HOME_SCREEN_INPUT = "homeScreenInput",
+    /**
+     * The user clicked a button from an option response.
+     */
+    OPTION_BUTTON = "optionButton",
+    /**
+     * The user selected a value from a dropdown for an option response.
+     */
+    OPTION_DROP_DOWN = "optionDropDown",
+    /**
+     * The message was sent as an automatic re-send when Carbon AI Chat is loaded. This occurs when Carbon AI Chat sees that the
+     * last message request did not receive a response.
+     */
+    HYDRATE_RESEND = "hydrateResend",
+    /**
+     * The message was sent as an event history update.
+     */
+    HISTORY_UPDATE = "historyUpdate",
+    /**
+     * An external call to the public "instance.send" method was made.
+     */
+    INSTANCE_SEND = "instanceSend",
+    /**
+     * The user chose a value from the date picker.
+     */
+    DATE_PICKER = "datePicker",
+    /**
+     * The user clicked a post back button from a button response.
+     */
+    POST_BACK_BUTTON = "postBackButton",
+    /**
+     * The user clicked a starter from the home screen.
+     */
+    HOME_SCREEN_STARTER = "homeScreenStarter",
+    /**
+     * A default request for the welcome message was made.
+     */
+    WELCOME_REQUEST = "welcomeRequest",
+    /**
+     * This is used for message events.
+     */
+    EVENT = "event",
+    /**
+     * Some other source.
+     */
+    OTHER = "other"
+}
+/**
+ * The discriminating union of all the possible bus event types.
+ * @category Events
+ */
+interface BusEvent {
+    /**
+     * The type of this event.
+     */
+    type: BusEventType;
+}
+/**
+ *
+ *
+ * @category Events
+ */
+interface BusEventClosePanelButtonClicked extends BusEvent {
+    type: BusEventType.CLOSE_PANEL_BUTTON_TOGGLED;
+}
+/**
+ * @category Events
+ */
+interface BusEventPreReceive extends BusEvent {
+    type: BusEventType.PRE_RECEIVE;
+    data: MessageResponse;
+}
+/**
+ * @category Events
+ */
+interface BusEventReceive extends BusEvent {
+    type: BusEventType.RECEIVE;
+    data: MessageResponse;
+}
+/**
+ * @category Events
+ */
+interface BusEventPreSend extends BusEvent {
+    type: BusEventType.PRE_SEND;
+    data: MessageRequest;
+    /**
+     * The source of the message being sent.
+     */
+    source: MessageSendSource;
+}
+/**
+ * @category Events
+ */
+interface BusEventSend extends BusEvent {
+    type: BusEventType.SEND;
+    data: MessageRequest;
+    /**
+     * The source of the message being sent.
+     */
+    source: MessageSendSource;
+}
+/**
+ * @category Service desk
+ */
+interface BusEventHumanAgentPreReceive extends BusEvent {
+    type: BusEventType.HUMAN_AGENT_PRE_RECEIVE;
+    data: MessageResponse;
+    responseUserProfile?: ResponseUserProfile;
+}
+/**
+ * @category Service desk
+ */
+interface BusEventHumanAgentReceive extends BusEvent {
+    type: BusEventType.HUMAN_AGENT_RECEIVE;
+    data: MessageResponse;
+    responseUserProfile?: ResponseUserProfile;
+}
+/**
+ * @category Service desk
+ */
+interface BusEventHumanAgentPreSend extends BusEvent {
+    type: BusEventType.HUMAN_AGENT_PRE_SEND;
+    data: MessageRequest;
+    files: FileUpload[];
+}
+/**
+ * @category Service desk
+ */
+interface BusEventHumanAgentSend extends BusEvent {
+    type: BusEventType.HUMAN_AGENT_SEND;
+    data: MessageRequest;
+    files: FileUpload[];
+}
+/**
+ * Fires before the view state is updated in the store. This event is awaited, making it ideal for async operations like animations.
+ *
+ * **Event Timing:**
+ * 1. VIEW_PRE_CHANGE fires (awaited)
+ * 2. View state is updated in store
+ * 3. VIEW_CHANGE fires (awaited)
+ *
+ * **Use cases:**
+ * - Run animations before the view changes
+ * - Modify the new view state before it's applied
+ * - Cancel the view change entirely
+ *
+ * @category Events
+ */
+interface BusEventViewPreChange extends BusEvent {
+    type: BusEventType.VIEW_PRE_CHANGE;
+    /**
+     * The reason the view is changing.
+     */
+    reason: ViewChangeReason;
+    /**
+     * The previous view state before this event.
+     */
+    oldViewState: ViewState;
+    /**
+     * The new view state that Carbon AI Chat is going to switch to. This new state can be changed by the event handler.
+     */
+    newViewState: ViewState;
+    /**
+     * This is used by the event handler to indicate that the view change should be cancelled and Carbon AI Chat's view should
+     * not be changed.
+     */
+    cancelViewChange: boolean;
+}
+/**
+ * Fires after the view state has been updated in the store. This event is awaited, making it ideal for async operations that should happen after the view change.
+ *
+ * **Event Timing:**
+ * 1. VIEW_PRE_CHANGE fires (awaited)
+ * 2. View state is updated in store
+ * 3. VIEW_CHANGE fires (awaited) ← You are here
+ *
+ * **Use cases:**
+ * - React to completed view changes
+ * - Run cleanup or follow-up animations
+ * - Cancel and revert the view change (causes immediate revert without firing events)
+ *
+ * @category Events
+ */
+interface BusEventViewChange extends BusEvent {
+    type: BusEventType.VIEW_CHANGE;
+    /**
+     * The reason the view is changing.
+     */
+    reason: ViewChangeReason;
+    /**
+     * The previous view state from before the view:pre:change event.
+     */
+    oldViewState: ViewState;
+    /**
+     * The new view state that Carbon AI Chat has switched to. This new state can be changed by the event handler.
+     */
+    newViewState: ViewState;
+    /**
+     * This is used by the event handler to indicate that the view change should be cancelled and Carbon AI Chat's view should
+     * not be changed. Since the view has already changed when this event is fired, this property will cause the view to
+     * change back. Note that the view change events are *not* fired when the view changes back.
+     */
+    cancelViewChange: boolean;
+}
+/**
+ * @category Events
+ */
+interface BusEventReset extends BusEvent {
+    type: BusEventType.RESTART_CONVERSATION;
+}
+/**
+ * @category Events
+ */
+interface BusEventChatReady extends BusEvent {
+    type: BusEventType.CHAT_READY;
+}
+/**
+ * @category Events
+ */
+interface BusEventPreReset extends BusEvent {
+    type: BusEventType.PRE_RESTART_CONVERSATION;
+}
+/**
+ * This describes a custom event that can be authored with the button response type of type "option". When clicked,
+ * this event will fire and provide information authored in the custom event.
+ *
+ * @category Events
+ */
+interface BusEventMessageItemCustom extends BusEvent {
+    type: BusEventType.MESSAGE_ITEM_CUSTOM;
+    /**
+     * The button item that triggered this custom event.
+     */
+    messageItem: ButtonItem;
+    /**
+     * The full message response that contained the button item that triggered this custom event.
+     */
+    fullMessage: MessageResponse;
+}
+/**
+ * Used to populate user_defined responses. Please see the React or web component documentation as usage of this
+ * differs based on implementation.
+ *
+ * @category Events
+ */
+interface BusEventUserDefinedResponse extends BusEvent {
+    type: BusEventType.USER_DEFINED_RESPONSE;
+    data: {
+        /**
+         * The individual message item that is being displayed in this custom response.
+         */
+        message: GenericItem;
+        /**
+         * The full message (response or request) that contains the message item.
+         */
+        fullMessage: Message;
+        /**
+         * The slot name for users of the web components cds-aichat-container or cds-aichat-custom-element.
+         */
+        slot?: string;
+    };
+}
+/**
+ * @category Events
+ */
+interface BusEventChunkUserDefinedResponse extends BusEvent {
+    type: BusEventType.CHUNK_USER_DEFINED_RESPONSE;
+    data: {
+        /**
+         * The individual message item that is being displayed in this custom response.
+         */
+        messageItem: DeepPartial<GenericItem>;
+        /**
+         * The full chunk that contained the user defined response.
+         */
+        chunk: PartialOrCompleteItemChunk;
+        /**
+         * The slot name for users of the web components cds-aichat-container or cds-aichat-custom-element.
+         */
+        slot?: string;
+    };
+}
+/**
+ * The event is fired whenever the widget begins processing a list of messages that have been loaded from history.
+ * This event may be fired not only when the history is first loaded but it may be fired later during the life of
+ * the widget if additional messages are loaded from history.
+ *
+ * This event is fired when this process begins. This is fired before all the "pre:receive" and "receive" events are
+ * fired which means that the messages here are the original messages before any possible modifications by the event
+ * handlers.
+ *
+ * @category Events
+ */
+interface BusEventHistoryBegin extends BusEvent {
+    /**
+     * The discriminating type of this event.
+     */
+    type: BusEventType.HISTORY_BEGIN;
+    /**
+     * The list of all the messages that are being loaded by this history event.
+     */
+    messages: Message[];
+    /**
+     * Indicates that modifications were made to the given messages and that updates to those messages should be saved in
+     * the history store. This is similar to the update behavior of the "pre:receive" event that is handled
+     * automatically.
+     */
+    updateMessageIDs?: string[];
+}
+/**
+ * The event is fired whenever the widget begins processing a list of messages that have been loaded from history.
+ * This event may be fired not only when the history is first loaded but it may be fired later during the life of
+ * the widget if additional messages are loaded from history.
+ *
+ * This event is fired when this process ends. This is fired after all the "pre:receive" and "receive" events are
+ * fired which means that the messages here are the potentially modified messages after any possible modifications
+ * by the event handlers.
+ *
+ * @category Events
+ */
+interface BusEventHistoryEnd extends BusEvent {
+    /**
+     * The discriminating type of this event.
+     */
+    type: BusEventType.HISTORY_END;
+    /**
+     * The list of all the messages that were loaded by this history event.
+     */
+    messages: Message[];
+}
+/**
+ * @category Events
+ */
+interface BusEventCustomPanelPreOpen extends BusEvent {
+    type: BusEventType.CUSTOM_PANEL_PRE_OPEN;
+}
+/**
+ * @category Events
+ */
+interface BusEventCustomPanelOpen extends BusEvent {
+    type: BusEventType.CUSTOM_PANEL_OPEN;
+}
+/**
+ * @category Events
+ */
+interface BusEventCustomPanelPreClose extends BusEvent {
+    type: BusEventType.CUSTOM_PANEL_PRE_CLOSE;
+}
+/**
+ * @category Events
+ */
+interface BusEventCustomPanelClose extends BusEvent {
+    type: BusEventType.CUSTOM_PANEL_CLOSE;
+}
+/**
+ * This event is fired before the user is connected to a service desk. This occurs as soon as the user clicks the
+ * "Request agent" button and before any attempt is made to communicate with the service desk.
+ *
+ * @category Service desk
+ */
+interface BusEventHumanAgentPreStartChat<TPayloadType = unknown> extends BusEvent {
+    /**
+     * The type of the event.
+     */
+    type: BusEventType.HUMAN_AGENT_PRE_START_CHAT;
+    /**
+     * The message that was used to trigger the connection to the agent.
+     */
+    message: MessageResponse;
+    /**
+     * This flag can be set by a listener to indicate that the connection process should be cancelled.
+     */
+    cancelStartChat?: boolean;
+    /**
+     * Some arbitrary payload of data that will be passed to the service desk when a chat is started.
+     */
+    preStartChatPayload?: TPayloadType;
+}
+/**
+ * This event is fired before a chat with an agent is ended. This occurs after the user has selected "Yes" from the
+ * confirmation modal but it can also be fired if the chat is ended by the agent.
+ *
+ * @category Service desk
+ */
+interface BusEventHumanAgentPreEndChat<TPayloadType = unknown> extends BusEvent {
+    /**
+     * The type of the event.
+     */
+    type: BusEventType.HUMAN_AGENT_PRE_END_CHAT;
+    /**
+     * Indicates if the chat was ended by the agent.
+     */
+    endedByHumanAgent: boolean;
+    /**
+     * An arbitrary payload object that a listener may set. This payload will be passed to the service desk
+     * ServiceDesk endChat function.
+     */
+    preEndChatPayload: TPayloadType;
+    /**
+     * This value may be set by a listener to indicate that the process of ending the chat should be cancelled.
+     */
+    cancelEndChat: boolean;
+}
+/**
+ * This event is fired after a chat with an agent has ended. This is fired after {@link BusEventType.HUMAN_AGENT_PRE_END_CHAT} but
+ * can be fired both from the user leaving the chat or the agent ending the chat.
+ *
+ * @category Service desk
+ */
+interface BusEventHumanAgentEndChat extends BusEvent {
+    /**
+     * The type of the event.
+     */
+    type: BusEventType.HUMAN_AGENT_END_CHAT;
+    /**
+     * Indicates if the chat was ended by the agent.
+     */
+    endedByHumanAgent: boolean;
+    /**
+     * Indicates if the chat was ended because the request for an agent was cancelled or an error occurred while
+     * starting the chat. This means the start never fully started.
+     */
+    requestCancelled: boolean;
+}
+/**
+ * This event is fired after Carbon AI Chat calls "areAnyAgentsOnline" for a service desk. It will report the value returned
+ * from that call. This is particularly useful if some custom code wants to take action if no agents are online.
+ *
+ * @category Service desk
+ */
+interface BusEventHumanAgentAreAnyAgentsOnline extends BusEvent {
+    /**
+     * The type of the event.
+     */
+    type: BusEventType.HUMAN_AGENT_ARE_ANY_AGENTS_ONLINE;
+    /**
+     * The result that was returned from "areAnyAgentsOnline". If an error occurred, this will be
+     * {@link HumanAgentsOnlineStatus.OFFLINE}.
+     */
+    areAnyAgentsOnline: HumanAgentsOnlineStatus;
+}
+/**
+ * The ways the user may interact with the feedback controls.
+ *
+ * @category Events
+ */
+declare enum FeedbackInteractionType {
+    /**
+     * Indicates the details popup was opened after the user clicked one of the feedback buttons.
+     */
+    DETAILS_OPENED = "detailsOpened",
+    /**
+     * Indicates the details popup was closed after the user clicked the "X" button to close it or if the user clicked the
+     * feedback button that opened it.
+     */
+    DETAILS_CLOSED = "detailsClosed",
+    /**
+     * Indicates feedback was submitted. This includes both when the details panel is open and submitted as well as when
+     * the user clicks a feedback button and the details are not shown.
+     */
+    SUBMITTED = "submitted"
+}
+/**
+ * This event is fired when the user interacts with the feedback controls on a message. This includes both the feedback
+ * buttons (thumbs up/down) as well as the details popup where the user can submit additional information.
+ *
+ * @category Events
+ */
+interface BusEventFeedback extends BusEvent {
+    /**
+     * The message item for which feedback was provided.
+     */
+    messageItem: GenericItem;
+    /**
+     * The message for which feedback was provided.
+     */
+    message: MessageResponse;
+    /**
+     * Indicates if the user is providing positive or negative feedback.
+     */
+    isPositive: boolean;
+    /**
+     * The type of interaction the user had with the feedback.
+     */
+    interactionType: FeedbackInteractionType;
+    /**
+     * When submitting feedback details, this is the text the user entered into the text field (if visible).
+     */
+    text?: string;
+    /**
+     * When submitting feedback details, this is the list of categories the user selected (if visible).
+     */
+    categories?: string[];
+}
+
+/**
+ * The types here describe the history structure.
+ * This is used currently for session history and is planned to be reused by the history.
+ */
+/**
+ * A single interaction in the Session History.
+ *
+ * @category Messaging
+ */
+interface HistoryItem {
+    /**
+     * The message represented by this history item.
+     */
+    message: MessageRequest | MessageResponse;
+    /**
+     * Time this message occurred. ISO Format (e.g. 2020-03-15T08:59:56.952Z).
+     */
+    time: string;
+}
+
+/**
+ * Reasons why a message request was cancelled via the abort signal.
+ *
+ * @category Messaging
+ */
+declare enum CancellationReason {
+    /**
+     * User clicked the "stop streaming" button during message streaming.
+     */
+    STOP_STREAMING = "Stop streaming",
+    /**
+     * User restarted or cleared the conversation.
+     */
+    CONVERSATION_RESTARTED = "Conversation restarted",
+    /**
+     * Message request exceeded the configured timeout duration.
+     */
+    TIMEOUT = "Request timeout"
+}
+/**
+ * Messaging actions for a chat instance.
+ *
+ * @category Messaging
+ */
+interface ChatInstanceMessaging {
+    /**
+     * Instructs the widget to process the given message as an incoming message received from the assistant. This will
+     * fire a "pre:receive" event immediately and a "receive" event after the event has been processed by the widget.
+     *
+     * @param message A {@link MessageResponse} object.
+     */
+    addMessage: (message: MessageResponse) => Promise<void>;
+    /**
+     * Adds a streaming message chunk to the chat widget.
+     */
+    addMessageChunk: (chunk: StreamChunk) => Promise<void>;
+    /**
+     * Removes the messages with the given IDs from the chat view.
+     */
+    removeMessages: (messageIDs: string[]) => Promise<void>;
+    /**
+     * Clears the current conversation. This will trigger a restart of the conversation but will not start a new
+     * conversation (hydration).
+     */
+    clearConversation: () => Promise<void>;
+    /**
+     * Inserts the given messages into the chat window as part of the chat history. This will fire the history:begin
+     * and history:end events.
+     */
+    insertHistory: (messages: HistoryItem[]) => Promise<void>;
+    /**
+     * Restarts the conversation with the assistant. This does not make any changes to a conversation with a human agent.
+     * This will clear all the current assistant messages from the main assistant view and cancel any outstanding
+     * messages. This will also clear the current assistant session which will force a new session to start on the
+     * next message.
+     */
+    restartConversation: () => Promise<void>;
+}
+/**
+ * @category Messaging
+ */
+interface CustomSendMessageOptions {
+    /**
+     * A signal to let customSendMessage to cancel a request if it has exceeded Carbon AI Chat's timeout.
+     */
+    signal: AbortSignal;
+    /**
+     * If the message was sent with "silent" set to true to not be displayed in the conversation history.
+     */
+    silent: boolean;
+    /**
+     *  BusEventSend provides extra context such as MessageSendSource.
+     */
+    busEventSend?: BusEventSend;
+}
+
+/**
+ * The subset of HumanAgentState that is persisted to browser storage.
+ *
+ * @category Instance
+ */
+interface PersistedHumanAgentState {
+    /** Indicates that the user is connected to a human agent. */
+    isConnected: boolean;
+    /** Indicates if the human agent conversation is currently suspended. */
+    isSuspended: boolean;
+    /** The profile of the last human agent to join the chat. */
+    responseUserProfile?: ResponseUserProfile;
+    /** Cache of known agent profiles by ID. */
+    responseUserProfiles: Record<string, ResponseUserProfile>;
+    /** Arbitrary state saved by the service desk. */
+    serviceDeskState?: unknown;
+}
+
+/**
+ * The interface represents the API contract with the chat widget and contains all the public methods and properties
+ * that can be used with Carbon AI Chat.
+ *
+ * @category Instance
+ */
+interface ChatInstance extends EventHandlers, ChatActions {
+    /**
+     * Returns state information of the Carbon AI Chat that could be useful.
+     */
+    getState: () => PublicChatState;
+    /**
+     * Manager for accessing and controlling custom panels.
+     */
+    customPanels?: CustomPanels;
+}
+/**
+ * This is the state made available by calling getState. This is a public method that returns immutable values.
+ *
+ * @category Instance
+ */
+type PublicChatState = Readonly<Omit<PersistedState, "humanAgentState"> & {
+    humanAgent: PublicChatHumanAgentState;
+}>;
+/**
+ * Current connection state of the human agent experience.
+ *
+ * @category Instance
+ */
+type PublicChatHumanAgentState = Readonly<PersistedHumanAgentState & {
+    /** Indicates if Carbon AI Chat is attempting to connect to an agent. */
+    isConnecting: boolean;
+}>;
+/**
+ * This is a subset of the public interface that is managed by the event bus that is used for registering and
+ * unregistering event listeners on the bus.
+ *
+ * @category Instance
+ */
+interface EventHandlers {
+    /**
+     * Adds the given event handler as a listener for events of the given type.
+     *
+     * @param handlers The handler or handlers along with the event type to start listening for events.
+     * @returns The instance for method chaining.
+     */
+    on: (handlers: TypeAndHandler | TypeAndHandler[]) => EventHandlers;
+    /**
+     * Removes an event listener that was previously added via {@link on} or {@link once}.
+     *
+     * @param handlers The handler or handlers along with the event type to stop listening for events.
+     * @returns The instance for method chaining.
+     */
+    off: (handlers: TypeAndHandler | TypeAndHandler[]) => EventHandlers;
+    /**
+     * Adds the given event handler as a listener for events of the given type. After the first event is handled, this
+     * handler will automatically be removed.
+     *
+     * @param handlers The handler or handlers along with the event type to start listening for an event.
+     * @returns The instance for method chaining.
+     */
+    once: (handlers: TypeAndHandler | TypeAndHandler[]) => EventHandlers;
+}
+/**
+ * The type of handler for event bus events. This function may return a Promise in which case, the bus will await
+ * the result and the loop will block until the Promise is resolved.
+ *
+ * @category Instance
+ */
+type EventBusHandler<T extends BusEvent = BusEvent> = (event: T, instance: ChatInstance) => unknown;
+/**
+ * The type of the object that is passed to the event bus functions (e.g. "on") when registering a handler.
+ *
+ * @category Instance
+ */
+interface TypeAndHandler {
+    /**
+     * The type of event this handler is for.
+     */
+    type: BusEventType;
+    /**
+     * The handler for events of this type.
+     */
+    handler: EventBusHandler;
+}
+/**
+ * This is a subset of the public interface that provides methods that can be used by the user to control the widget
+ * and have it perform certain actions.
+ *
+ * @category Instance
+ */
+interface ChatActions {
+    /**
+     * Messaging actions for a chat instance.
+     */
+    messaging: ChatInstanceMessaging;
+    /**
+     * This function can be called when another component wishes this component to gain focus. It is up to the
+     * component to decide where focus belongs. This may return true or false to indicate if a suitable focus location
+     * was found.
+     */
+    requestFocus: () => boolean | void;
+    /**
+     * Sends the given message to the assistant on the remote server. This will result in a "pre:send" and "send" event
+     * being fired on the event bus. The returned promise will resolve once a response has received and processed and
+     * both the "pre:receive" and "receive" events have fired. It will reject when too many errors have occurred and
+     * the system gives up retrying.
+     *
+     * @param message The message to send.
+     * @param options Options for the message sent.
+     */
+    send: (message: MessageRequest | string, options?: SendOptions) => Promise<void>;
+    /**
+     * Fire the view:pre:change and view:change events and change the view of the Carbon AI Chat. If a {@link ViewType} is
+     * provided then that view will become visible and the rest will be hidden. If a {@link ViewState} is provided that
+     * includes all of the views then all of the views will be changed accordingly. If a partial {@link ViewState} is
+     * provided then only the views provided will be changed.
+     */
+    changeView: (newView: ViewType | ViewState) => Promise<void>;
+    /**
+     * Returns the list of writable elements.
+     */
+    writeableElements: Partial<WriteableElements>;
+    /**
+     * Sets the input field to be invisible. Helpful for when
+     * you want to force input into a button, etc.
+     */
+    updateInputFieldVisibility: (isVisible: boolean) => void;
+    /**
+     * Changes the state of Carbon AI Chat to allow or disallow input. This includes the input field as well as inputs like
+     * buttons and dropdowns.
+     */
+    updateInputIsDisabled: (isDisabled: boolean) => void;
+    /**
+     * Updates the visibility of the custom unread indicator that appears on the launcher. This indicator appears as a
+     * small empty circle on the launcher. If there are any unread messages from a human agent, this indicator will be
+     * shown with a number regardless of the custom setting of this flag.
+     */
+    updateAssistantUnreadIndicatorVisibility: (isVisible: boolean) => void;
+    /**
+     * Scrolls to the (original) message with the given ID. Since there may be multiple message items in a given
+     * message, this will scroll the first message to the top of the message window.
+     *
+     * @param messageID The (original) message ID to scroll to.
+     * @param animate Whether or not the scroll should be animated. Defaults to true.
+     */
+    scrollToMessage: (messageID: string, animate?: boolean) => void;
+    /**
+     * Restarts the conversation with the assistant. This does not make any changes to a conversation with a human agent.
+     * This will clear all the current assistant messages from the main assistant view and cancel any outstanding
+     * messages. This will also clear the current assistant session which will force a new session to start on the
+     * next message.
+     *
+     * @deprecated Use {@link ChatInstanceMessaging.restartConversation} instead.
+     */
+    restartConversation: () => Promise<void>;
+    /**
+     * Initiates a doAutoScroll on the currently visible chat panel.
+     */
+    doAutoScroll: () => void;
+    /**
+     * Either increases or decreases the internal counter that indicates whether the "assistant is loading" indicator is
+     * shown. If the count is greater than zero, then the indicator is shown. Values of "increase" or "decrease" will
+     * increase or decrease the value. Any other value will log an error.
+     */
+    updateIsMessageLoadingCounter: (direction: IncreaseOrDecrease) => void;
+    /**
+     * Either increases or decreases the internal counter that indicates whether the hydration fullscreen loading state is
+     * shown. If the count is greater than zero, then the indicator is shown. Values of "increase" or "decrease" will
+     * increase or decrease the value. Any other value will log an error.
+     */
+    updateIsChatLoadingCounter: (direction: IncreaseOrDecrease) => void;
+    /**
+     * The state of notifications in the chat.
+     *
+     * @experimental
+     */
+    notifications: ChatInstanceNotifications;
+    /**
+     * Actions that are related to a service desk integration.
+     */
+    serviceDesk: ChatInstanceServiceDeskActions;
+    /**
+     * Remove any record of the current session from the browser's SessionStorage.
+     *
+     * @param keepOpenState If we are destroying the session to restart the chat this can be used to preserve if the web
+     * chat is open.
+     */
+    destroySession: (keepOpenState?: boolean) => Promise<void>;
+}
+/**
+ * @category Instance
+ */
+type IncreaseOrDecrease = "increase" | "decrease";
+/**
+ * This interface represents the options for when a MessageRequest is sent to the server with the send method.
+ *
+ * @category Instance
+ */
+interface SendOptions {
+    /**
+     * If you want to send a message to the API, but NOT have it show up in the UI, set this to true. The "pre:send"
+     * and "send" events will still be fired but the message will not be added to the local message list displayed in
+     * the UI. Note that the response message will still be added.
+     */
+    silent?: boolean;
+}
+/**
+ * An object of elements we expose to developers to write to. Be sure to check the documentation of the React or
+ * web component you are using for how to make use of this, as it differs based on implementation.
+ *
+ * @category Instance
+ */
+type WriteableElements = Record<WriteableElementName, HTMLElement>;
+/**
+ * @category Instance
+ */
+declare enum WriteableElementName {
+    /**
+     * An element that appears in the AI theme only and is shown beneath the title and description in the AI tooltip
+     * content.
+     */
+    AI_TOOLTIP_AFTER_DESCRIPTION_ELEMENT = "aiTooltipAfterDescriptionElement",
+    /**
+     * An element that appears in the main message body directly above the welcome node.
+     */
+    WELCOME_NODE_BEFORE_ELEMENT = "welcomeNodeBeforeElement",
+    /**
+     * An element that appears in the header on a new line. Only visible while talking to the assistant.
+     */
+    HEADER_BOTTOM_ELEMENT = "headerBottomElement",
+    /**
+     * An element that appears after the messages area and before the input area.
+     */
+    BEFORE_INPUT_ELEMENT = "beforeInputElement",
+    /**
+     * An element that appears above the input field on the home screen.
+     */
+    HOME_SCREEN_BEFORE_INPUT_ELEMENT = "homeScreenBeforeInputElement",
+    /**
+     * An element that appears on the home screen after the conversation starters.
+     */
+    HOME_SCREEN_AFTER_STARTERS_ELEMENT = "homeScreenAfterStartersElement",
+    /**
+     * An element that appears on the home screen above the welcome message and conversation starters.
+     */
+    HOME_SCREEN_HEADER_BOTTOM_ELEMENT = "homeScreenHeaderBottomElement",
+    /**
+     * An element to be housed in the custom panel.
+     */
+    CUSTOM_PANEL_ELEMENT = "customPanelElement"
+}
+/**
+ * Add notification messages to the chat. This component has some a11y bugs before we can mark it complete.
+ *
+ * @category Instance
+ *
+ * @experimental
+ */
+interface ChatInstanceNotifications {
+    /**
+     * Add a system level notification to the list of system notifications.
+     */
+    addNotification: (notification: NotificationMessage) => void;
+    /**
+     * Remove a system level notification from the list of system notifications.
+     */
+    removeNotifications: (groupID: string) => void;
+    /**
+     * Remove all system level notifications from the list of system notifications.
+     */
+    removeAllNotifications: () => void;
+}
+/**
+ * @category Instance
+ */
+type ChangeFunction = (text: string) => void;
+/**
+ * Upload options. Currently only applies to conversations with a human agent.
+ *
+ * @category Instance
+ */
+interface FileUploadCapabilities {
+    /**
+     * Indicates that file uploads may be performed by the user.
+     */
+    allowFileUploads: boolean;
+    /**
+     * If file uploads are allowed, this indicates if more than one file may be selected at a time. The default is false.
+     */
+    allowMultipleFileUploads: boolean;
+    /**
+     * If file uploads are allowed, this is the set a file types that are allowed. This is filled into the "accept"
+     * field for the file input element.
+     */
+    allowedFileUploadTypes: string;
+}
+/**
+ * Start or end conversations with human agent.
+ *
+ * @category Instance
+ */
+interface ChatInstanceServiceDeskActions {
+    /**
+     * Ends the conversation with a human agent. This does not request confirmation from the user first. If the user
+     * is not connected or connecting to a human agent, this function has no effect. You can determine if the user is
+     * connected or connecting by calling {@link ChatInstance.getState}. Note that this function
+     * returns a Promise that only resolves when the conversation has ended. This includes after the
+     * {@link BusEventType.HUMAN_AGENT_PRE_END_CHAT} and {@link BusEventType.HUMAN_AGENT_END_CHAT} events have been fired and
+     * resolved.
+     */
+    endConversation: () => Promise<void>;
+    /**
+     * Sets the suspended state for an agent conversation. A conversation can be suspended or un-suspended only if the
+     * user is currently connecting or connected to an agent. If a conversation is suspended, then messages from the user
+     * will no longer be routed to the service desk and incoming messages from the service desk will not be displayed. In
+     * addition, the current connection status with an agent will not be shown.
+     */
+    updateIsSuspended: (isSuspended: boolean) => Promise<void>;
+}
+
+/**
+ * The types of corners the chat can have.
+ *
+ * @category Config
+ */
+declare enum CornersType {
+    /**
+     * Makes the corners on the chat component rounded.
+     */
+    ROUND = "round",
+    /**
+     * Makes the corners on the chat component square.
+     */
+    SQUARE = "square"
+}
+
+/**
+ * A conversation starter button on the home screen. Currently, only label is provided by tooling.
+ *
+ * @category Config
+ */
+interface HomeScreenStarterButton {
+    /**
+     * The display label of the button. This is also the value that is sent as the user's utterance to the assistant
+     * when the button is clicked.
+     */
+    label: string;
+    /**
+     * Indicates if the button was previously clicked and should be displayed as selected.
+     */
+    isSelected?: boolean;
+}
+/**
+ * Starter buttons that appear on home screen.
+ *
+ * @category Config
+ */
+interface HomeScreenStarterButtons {
+    isOn?: boolean;
+    buttons?: HomeScreenStarterButton[];
+}
+/**
+ * Configuration for the optional home screen that appears before the assistant chat window.
+ *
+ * @category Config
+ */
+interface HomeScreenConfig {
+    /**
+     * If the home page is turned on via config or remote config.
+     */
+    isOn?: boolean;
+    /**
+     * The greeting to show to the user to prompt them to start a conversation.
+     */
+    greeting?: string;
+    /**
+     * Optional conversation starter utterances that are displayed as buttons.
+     */
+    starters?: HomeScreenStarterButtons;
+    /**
+     * Do not show the greeting or starters.
+     */
+    customContentOnly?: boolean;
+    /**
+     * Defaults to false. If enabled, a user can not navigate back to the home screen after they have sent a message to the
+     * assistant. If false, the home screen is navigatable after an initial message is sent.
+     */
+    disableReturn?: boolean;
+}
+/**
+ * Current state of home screen (currently, limited to if it is open or closed).
+ *
+ * @category Config
+ */
+interface HomeScreenState {
+    /**
+     * Indicates if the home screen is currently open.
+     */
+    isHomeScreenOpen: boolean;
+    /**
+     * Indicates if the home screen should display a "return to assistant" button. This button is displayed when the user
+     * has clicked the "back to home" button from the assistant.
+     */
+    showBackToAssistant: boolean;
+}
+
+/**
+ * Valid public CSS variables that can be controlled when white labeling is disabled.
+ * These variables map to CSS custom properties used in styling the AI chat interface.
+ *
+ * Keys map to the underlying `--cds-aichat-…` custom properties.
+ *
+ * @category Config
+ */
+declare enum LayoutCustomProperties {
+    /** Minimum height of the chat container (float layout). */
+    height = "height",
+    /** Maximum height of the chat container (float layout). */
+    max_height = "max-height",
+    /** Width of the chat panel (float layout). */
+    width = "width",
+    /** z-index of the chat overlay or container (float layout). */
+    z_index = "z-index"
+}
+
+/**
+ * Configuration for the launcher.
+ *
+ * @category Config
+ */
+interface LauncherConfig {
+    /**
+     * If the launcher is visible. Defaults to true.
+     */
+    isOn?: boolean;
+    /**
+     * Properties specific to the mobile launcher.
+     */
+    mobile?: LauncherCallToActionConfig;
+    /**
+     * Properties specific to the desktop launcher.
+     */
+    desktop?: LauncherCallToActionConfig;
+}
+/**
+ * @category Config
+ */
+interface LauncherCallToActionConfig {
+    /**
+     * If the launcher will expand with a call to action.
+     */
+    isOn?: boolean;
+    /**
+     * The title that will be used by the expanded state of the launcher. If nothing is set in the config then a default
+     * translated string will be used.
+     */
+    title?: string;
+    /**
+     * The amount of time to wait before extending the launcher. If nothing is set then the default time of
+     * 15s will be used.
+     */
+    timeToExpand?: number;
+    /**
+     * An optional override of the icon shown on the launcher.
+     */
+    avatarUrlOverride?: string;
+}
+
+/**
+ * This file contains the definition for the public application configuration operations that are provided by the
+ * host page.
+ */
+/**
+ * The raw strings used for {@link PublicConfig.strings}. Presented in ICU format.
+ *
+ * @category Config
+ */
+declare const enLanguagePack: {
+    ai_slug_label: string;
+    ai_slug_title: string;
+    ai_slug_description: string;
+    components_overflow_ariaLabel: string;
+    components_swiper_currentLabel: string;
+    errors_communicating: string;
+    errors_imageSource: string;
+    errors_videoSource: string;
+    errors_audioSource: string;
+    errors_iframeSource: string;
+    errors_singleMessage: string;
+    errors_ariaMessageRetrying: string;
+    errors_ariaMessageFailed: string;
+    errors_noHumanAgentsAvailable: string;
+    errors_noHumanAgentsJoined: string;
+    errors_connectingToHumanAgent: string;
+    errors_busy: string;
+    errors_agentAppSessionExpired: string;
+    errors_generalContent: string;
+    errors_somethingWrong: string;
+    input_ariaLabel: string;
+    input_placeholder: string;
+    input_buttonLabel: string;
+    input_uploadButtonLabel: string;
+    window_title: string;
+    window_ariaChatRegion: string;
+    window_ariaChatRegionNamespace: string;
+    window_ariaWindowOpened: string;
+    window_ariaWindowClosed: string;
+    window_ariaWindowLoading: string;
+    launcher_isOpen: string;
+    launcher_isClosed: string;
+    launcher_desktopGreeting: string;
+    launcher_mobileGreeting: string;
+    launcher_ariaIsExpanded: string;
+    launcher_closeButton: string;
+    messages_youSaid: string;
+    messages_assistantSaid: string;
+    messages_agentSaid: string;
+    messages_searchResults: string;
+    messages_searchResultsLink: string;
+    messages_searchResultsOpenDocument: string;
+    messages_searchResultsOpenDocumentWithLabel: string;
+    messages_searchResultsExpand: string;
+    messages_searchResultsCollapse: string;
+    messages_assistantIsLoading: string;
+    messages_agentIsTyping: string;
+    messages_scrollHandle: string;
+    messages_scrollHandleDetailed: string;
+    messages_scrollHandleEnd: string;
+    messages_scrollHandleEndDetailed: string;
+    messages_scrollMoreButton: string;
+    message_labelAssistant: string;
+    message_labelYou: string;
+    notifications_toastClose: string;
+    buttons_restart: string;
+    buttons_cancel: string;
+    buttons_retry: string;
+    options_select: string;
+    options_ariaOptionsDisabled: string;
+    header_previewLinkTitle: string;
+    header_ariaAssistantAvatar: string;
+    header_overflowMenu_options: string;
+    homeScreen_returnToAssistant: string;
+    homeScreen_returnToHome: string;
+    homeScreen_overflowMenuHomeScreen: string;
+    homeScreen_ariaQuickStartListButton: string;
+    homeScreen_ariaQuickStartListOpened: string;
+    homeScreen_ariaQuickStartListClosed: string;
+    default_agent_availableMessage: string;
+    default_agent_unavailableMessage: string;
+    agent_reason_error: string;
+    agent_sdMissingWarning: string;
+    agent_noName: string;
+    agent_chatTitle: string;
+    agent_startChat: string;
+    agent_connecting: string;
+    agent_agentNoNameTitle: string;
+    agent_agentJoinedName: string;
+    agent_agentJoinedNoName: string;
+    agent_youConnectedWarning: string;
+    agent_connectingMinutes: string;
+    agent_connectingQueue: string;
+    agent_ariaHumanAgentAvatar: string;
+    agent_ariaGenericAvatar: string;
+    agent_ariaGenericAssistantAvatar: string;
+    agent_youEndedChat: string;
+    agent_conversationWasEnded: string;
+    agent_disconnected: string;
+    agent_reconnected: string;
+    agent_agentLeftChat: string;
+    agent_agentLeftChatNoName: string;
+    agent_agentEndedChat: string;
+    agent_agentEndedChatNoName: string;
+    agent_transferring: string;
+    agent_transferringNoName: string;
+    agent_endChat: string;
+    agent_confirmSuspendedEndChatTitle: string;
+    agent_confirmSuspendedEndChatMessage: string;
+    agent_confirmCancelRequestTitle: string;
+    agent_confirmCancelRequestMessage: string;
+    agent_confirmCancelRequestNo: string;
+    agent_confirmCancelRequestYes: string;
+    agent_confirmEndChat: string;
+    agent_confirmEndChatNo: string;
+    agent_confirmEndChatYes: string;
+    agent_confirmEndSuspendedYes: string;
+    agent_assistantReturned: string;
+    agent_newMessage: string;
+    agent_cardButtonChatRequested: string;
+    agent_cardButtonConnected: string;
+    agent_cardButtonChatEnded: string;
+    agent_cardMessageChatEnded: string;
+    agent_cardMessageConnected: string;
+    agent_connectButtonCancel: string;
+    agent_connectedButtonEndChat: string;
+    agent_connectWaiting: string;
+    agent_defaultMessageToHumanAgent: string;
+    agent_inputPlaceholderConnecting: string;
+    agent_inputPlaceholderReconnecting: string;
+    agent_sharingStopSharingButton: string;
+    agent_sharingRequestTitle: string;
+    agent_sharingRequestMessage: string;
+    agent_sharingAcceptButton: string;
+    agent_sharingDeclineButton: string;
+    agent_sharingRequested: string;
+    agent_sharingAccepted: string;
+    agent_sharingDeclined: string;
+    agent_sharingCancelled: string;
+    agent_sharingEnded: string;
+    agent_suspendedWarning: string;
+    icon_ariaUnreadMessages: string;
+    showMore: string;
+    showMoreResults: string;
+    disclaimer_title: string;
+    disclaimer_accept: string;
+    general_ariaCloseInformationOverlay: string;
+    general_ariaAnnounceOpenedInformationOverlay: string;
+    general_ariaAnnounceClosedInformationOverlay: string;
+    general_ariaAnnounceEscapeOverlay: string;
+    general_returnToAssistant: string;
+    conversationalSearch_streamingIncomplete: string;
+    conversationalSearch_viewSourceDocument: string;
+    conversationalSearch_citationsLabel: string;
+    conversationalSearch_toggleCitations: string;
+    conversationalSearch_responseStopped: string;
+    launcher_chatNow: string;
+    iframe_ariaSourceLoaded: string;
+    iframe_ariaImageAltText: string;
+    iframe_ariaClosePanel: string;
+    iframe_ariaOpenedPanel: string;
+    iframe_ariaClosedPanel: string;
+    iframe_ariaClickPreviewCard: string;
+    datePicker_chooseDate: string;
+    datePicker_confirmDate: string;
+    fileSharing_fileTooLarge: string;
+    fileSharing_ariaAnnounceSuccess: string;
+    fileSharing_fileIcon: string;
+    fileSharing_removeButtonTitle: string;
+    fileSharing_statusUploading: string;
+    fileSharing_uploadFailed: string;
+    fileSharing_agentMessageText: string;
+    fileSharing_request: string;
+    carousel_prevNavButton: string;
+    carousel_nextNavButton: string;
+    input_completionsTagApp: string;
+    input_completionsTagAssistant: string;
+    table_filterPlaceholder: string;
+    table_previousPage: string;
+    table_nextPage: string;
+    table_itemsPerPage: string;
+    table_paginationSupplementalText: string;
+    table_paginationStatus: string;
+    feedback_positiveLabel: string;
+    feedback_negativeLabel: string;
+    feedback_defaultTitle: string;
+    feedback_defaultPrompt: string;
+    feedback_defaultPlaceholder: string;
+    feedback_submitLabel: string;
+    feedback_cancelLabel: string;
+    input_stopResponse: string;
+    messages_responseStopped: string;
+    chainOfThought_stepTitle: string;
+    chainOfThought_inputLabel: string;
+    chainOfThought_outputLabel: string;
+    chainOfThought_toolLabel: string;
+    chainOfThought_statusSucceededLabel: string;
+    chainOfThought_statusFailedLabel: string;
+    chainOfThought_statusProcessingLabel: string;
+    chainOfThought_explainabilityLabel: string;
+};
+/**
+ * A language pack represents the set of display strings for a particular language.
+ * It defines all the text strings that can be customized for different languages.
+ *
+ * @category Config
+ */
+type LanguagePack = typeof enLanguagePack;
+/**
+ * Configuration interface for Carbon AI Chat.
+ *
+ * @category Config
+ */
+interface PublicConfig {
+    /**
+     * This is a one-off listener for catastrophic errors. This is used instead of a normal event bus handler because this function can be
+     * defined and called before the event bus has been created.
+     */
+    onError?: (data: OnErrorData) => void;
+    /**
+     * By default, the chat window will be rendered in a "closed" state.
+     */
+    openChatByDefault?: boolean;
+    /**
+     * Disclaimer screen configuration.
+     *
+     * If `disclaimerHTML` changes after the disclaimer has been accepted, we request a user to accept again.
+     */
+    disclaimer?: DisclaimerPublicConfig;
+    /**
+     * This value is only used when a custom element is being used to render the widget. By default, a number of
+     * enhancements to the widget are activated on mobile devices which can interfere with a custom element. This
+     * value can be used to disable those enhancements while using a custom element.
+     */
+    disableCustomElementMobileEnhancements?: boolean;
+    /**
+     * Add a bunch of noisy console.log messages!
+     */
+    debug?: boolean;
+    /**
+     * Which Carbon theme tokens to inject. If unset (falsy), the chat inherits tokens from the host page.
+     * Set to a specific theme to force token injection.
+     */
+    injectCarbonTheme?: CarbonTheme;
+    /**
+     * Enables Carbon AI theme styling. Defaults to true.
+     */
+    aiEnabled?: boolean;
+    /**
+     * This is a factory for producing custom implementations of service desks. If this value is set, then this will
+     * be used to create an instance of a {@link ServiceDesk} when the user attempts to connect to an agent.
+     *
+     * If it is changed in the middle of a conversation (you should obviously avoid this) the conversation with the
+     * human agent will be restarted.
+     */
+    serviceDeskFactory?: (parameters: ServiceDeskFactoryParameters) => Promise<ServiceDesk>;
+    /**
+     * Any public config to apply to service desks.
+     *
+     * If it is changed in the middle of a conversation (you should obviously avoid this) the conversation with the
+     * human agent will be restarted.
+     */
+    serviceDesk?: ServiceDeskPublicConfig;
+    /**
+     * If the Carbon AI Chat should grab focus if the chat is open on page load.
+     */
+    shouldTakeFocusIfOpensAutomatically?: boolean;
+    /**
+     * An optional namespace that can be added to the Carbon AI Chat that must be 30 characters or under. This value is
+     * intended to enable multiple instances of the Carbon AI Chat to be used on the same page. The namespace for this web
+     * chat. This value is used to generate a value to append to anything unique (id, session keys, etc) to allow
+     * multiple Carbon AI Chats on the same page.
+     *
+     * Note: this value is used in the aria region label for the Carbon AI Chat. This means this value will be read out loud
+     * by users using a screen reader.
+     */
+    namespace?: string;
+    /**
+     * Indicates if Carbon AI Chat should sanitize HTML from the assistant.
+     */
+    shouldSanitizeHTML?: boolean;
+    /**
+     * Extra config for controlling the behavior of the header.
+     */
+    header?: HeaderConfig;
+    /**
+     * The config object for changing Carbon AI Chat's layout.
+     */
+    layout?: LayoutConfig;
+    /**
+     * Config options for controlling messaging.
+     */
+    messaging?: PublicConfigMessaging;
+    /**
+     * Sets the chat into a read only mode for displaying old conversations.
+     */
+    isReadonly?: boolean;
+    /**
+     * Sets the name of the assistant. Defaults to "watsonx". Used in screen reader announcements and error messages.
+     */
+    assistantName?: string;
+    /**
+     * The locale to use for the widget. This controls the language pack and regional formatting.
+     * Example values include: 'en', 'en-us', 'fr', 'es'.
+     */
+    locale?: string;
+    /**
+     * Configuration for the homescreen.
+     *
+     * If you change anything but `is_on` after the chat session has started, the chat will handle it gracefully.
+     *
+     * If you turn on the homescreen after the user has already started chatting, it will show up in the header as
+     * an icon, but the user won't be forced to go back to the homescreen (unlike turning on the disclaimer mid-chat).
+     */
+    homescreen?: HomeScreenConfig;
+    /**
+     * Configuration for the launcher.
+     */
+    launcher?: LauncherConfig;
+    /**
+     * Configuration for the main input field on the chat.
+     */
+    input?: InputConfig;
+    /**
+     * Optional partial language pack overrides. Values merge with defaults.
+     */
+    strings?: DeepPartial<LanguagePack>;
+}
+/**
+ * A single menu option.
+ *
+ * @category Config
+ */
+interface CustomMenuOption {
+    /**
+     * The text to display for the menu option.
+     */
+    text: string;
+    /**
+     * The callback handler to call when the option is selected. Provide this of "url".
+     */
+    handler: () => void;
+}
+/**
+ * @category Config
+ */
+declare enum MinimizeButtonIconType {
+    /**
+     * This shows an "X" icon.
+     */
+    CLOSE = "close",
+    /**
+     * This shows a "-" icon.
+     */
+    MINIMIZE = "minimize",
+    /**
+     * This shows an icon that indicates that the Carbon AI Chat can be collapsed into a side panel.
+     */
+    SIDE_PANEL_LEFT = "side-panel-left",
+    /**
+     * This shows an icon that indicates that the Carbon AI Chat can be collapsed into a side panel.
+     */
+    SIDE_PANEL_RIGHT = "side-panel-right"
+}
+/**
+ * Configuration for the input field in the main chat and homescreen.
+ *
+ * @category Config
+ */
+interface InputConfig {
+    /**
+     * The maximum number of characters allowed in the input field. Defaults to 10000.
+     */
+    maxInputCharacters?: number;
+}
+/**
+ * Configuration for the main header of the chat.
+ *
+ * @category Config
+ */
+interface HeaderConfig {
+    /**
+     * Indicates the icon to use for the close button in the header.
+     */
+    minimizeButtonIconType?: MinimizeButtonIconType;
+    /**
+     * Hide the ability to minimize the Carbon AI Chat.
+     */
+    hideMinimizeButton?: boolean;
+    /**
+     * If true, shows the restart conversation button in the header of home screen and main chat.
+     */
+    showRestartButton?: boolean;
+    /**
+     * The chat header title.
+     */
+    title?: string;
+    /**
+     * The name displayed after the title.
+     */
+    name?: string;
+    /**
+     * All the currently configured custom menu options.
+     */
+    menuOptions?: CustomMenuOption[];
+    /**
+     * Controls whether to show the AI label/slug in the header. Defaults to true.
+     *
+     * There is currently no version of this that does not include the AI theme
+     * blue gradients.
+     */
+    showAiLabel?: boolean;
+}
+/**
+ * @category Config
+ */
+interface LayoutConfig {
+    /**
+     * Indicates if the Carbon AI Chat widget should keep its border and box-shadow.
+     */
+    showFrame?: boolean;
+    /**
+     * Indicates if content inside the Carbon AI Chat widget should be constrained to a max-width.
+     *
+     * At larger widths the card, carousel, options and conversational search response types
+     * have pending issues.
+     */
+    hasContentMaxWidth?: boolean;
+    /**
+     * This flag is used to disable Carbon AI Chat's rounded corners.
+     */
+    corners?: CornersType;
+    /**
+     * CSS variable overrides for the chat UI.
+     *
+     * Keys correspond to values from `LayoutCustomProperties` (e.g. `LayoutCustomProperties.height`),
+     * which map to the underlying `--cds-aichat-…` custom properties.
+     * Values are raw CSS values such as `"420px"`, `"9999"`, etc.
+     *
+     * Example:
+     * { height: "560px", width: "420px" }
+     */
+    customProperties?: Partial<Record<LayoutCustomProperties, string>>;
+}
+/**
+ * Config options for controlling messaging.
+ *
+ * @category Config
+ */
+interface PublicConfigMessaging {
+    /**
+     * Indicates if Carbon AI Chat should make a request for the welcome message when a new conversation begins. If this is
+     * true, then Carbon AI Chat will start with an empty conversation.
+     *
+     * **Manual session management required**: Changes to this property after conversation has started have no effect.
+     * To apply new welcome behavior, call `instance.messaging.restartConversation()`.
+     */
+    skipWelcome?: boolean;
+    /**
+     * Changes the timeout used by the message service when making message calls. The timeout is in seconds. The
+     * default is 150 seconds. After this time, an error will be shown in the client and an Abort signal will be sent
+     * to customSendMessage. If set to 0, the chat will never timeout.
+     */
+    messageTimeoutSecs?: number;
+    /**
+     * Controls how long AI chat should wait before showing the loading indicator. If set to 0, the chat will never show
+     * the loading indicator. This is tied to either {@link ChatInstanceMessaging.addMessage} or
+     * {@link ChatInstanceMessaging.addMessageChunk} being called after this message was sent.
+     *
+     * If set to 0, the chat will never automatically show a loading indicator.
+     */
+    messageLoadingIndicatorTimeoutSecs?: number;
+    /**
+     * A callback for Carbon AI Chat to use to send messages to your assistant.
+     *
+     * Carbon AI Chat will queue up any additional user messages until the Promise from a previous call to customSendMessage
+     * has resolved. If you do not make customSendMessage async, it will be up to you to manage what happens when a message is
+     * sent when the previous is still processing. If the Promise rejects, an error indicator will be displayed next to the user's message.
+     *
+     * If the request takes longer than PublicConfigMessaging.messageTimeoutSecs than the AbortSignal will be sent.
+     */
+    customSendMessage?: (request: MessageRequest, requestOptions: CustomSendMessageOptions, instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This is a callback function that is used by Carbon AI Chat to retrieve history data for populating the Carbon AI Chat. If
+     * this function is defined, it will be used instead of any other mechanism for fetching history.
+     *
+     * If this function is mutated after it was initially called, the chat does not re-call it.
+     */
+    customLoadHistory?: (instance: ChatInstance) => Promise<HistoryItem[]>;
+}
+/**
+ * @category Config
+ */
+interface DisclaimerPublicConfig {
+    /**
+     * If the disclaimer is turned on.
+     */
+    isOn: boolean;
+    /**
+     * HTML content to show in disclaimer.
+     */
+    disclaimerHTML: string;
+}
+/**
+ * A string identifying what Carbon Theme we should base UI variables off of.
+ * Defaults to "inherit". If you are not hosting the chat on a website that is Carbon styles, you will want to choose
+ * once of the non-inherited values to inject the correct CSS custom property values into the code. See
+ * https://carbondesignsystem.com/guidelines/color/tokens.
+ *
+ * @category Config
+ */
+declare enum CarbonTheme {
+    /**
+     * Injects Carbon white theme tokens.
+     */
+    WHITE = "white",
+    /**
+     * Injects Carbon Gray 10 theme tokens.
+     */
+    G10 = "g10",
+    /**
+     * Injects Carbon Gray 90 theme tokens.
+     */
+    G90 = "g90",
+    /**
+     * Injects Carbon Gray 100 theme tokens.
+     */
+    G100 = "g100"
+}
+/**
+ * The different categories of errors that the system can record. These values are published for end user consumption.
+ *
+ * @category Config
+ */
+declare enum OnErrorType {
+    /**
+     * Indicates an error sending a message to the assistant. This error is only generated after all retries have
+     * failed and the system has given up.
+     */
+    MESSAGE_COMMUNICATION = "MESSAGE_COMMUNICATION",
+    /**
+     * This indicates an error in one of the components that occurs as part of rendering the UI.
+     */
+    RENDER = "RENDER",
+    /**
+     * This indicates a known error with the configuration for a service desk. Fired when a connect_to_agent
+     * response type is received, but none is configured.
+     */
+    INTEGRATION_ERROR = "INTEGRATION_ERROR",
+    /**
+     * This indicates that some error occurred while trying to hydrate the chat. This will prevent the chat from
+     * functioning.
+     */
+    HYDRATION = "HYDRATION"
+}
+/**
+ * Fired when a serious error in the chat occurs.
+ *
+ * @category Config
+ */
+interface OnErrorData {
+    /**
+     * The type of error that occurred.
+     */
+    errorType: OnErrorType;
+    /**
+     * A message associated with the error.
+     */
+    message: string;
+    /**
+     * An extra blob of data associated with the error. This may be a stack trace for thrown errors.
+     */
+    otherData?: unknown;
+    /**
+     * If the error is of the severity that requires a whole restart of Carbon AI Chat.
+     */
+    catastrophicErrorType?: boolean;
+}
+
+/**
+ * A TypeScript definition file for ObjectMap.
+ */
+/**
+ * This interface represents an object which behaves like a map. The object contains a set of properties representing
+ * keys in the map and the values of those properties are all of the same type (TPropertyType). The type of the keys
+ * defaults to any string but you can specify a type that is a string enum instead if you want a map that contains
+ * only keys for a given enum (or other similar type).
+ *
+ * @category Utilities
+ */
+type ObjectMap<TPropertyType, TKeyType extends string | number = string> = Partial<Record<TKeyType, TPropertyType>>;
+
+/**
+ * Items stored in sessionStorage.
+ *
+ * @category Instance
+ */
+interface PersistedState {
+    /**
+     * Indicates if this state was loaded from browser session storage or if was created as part of a new session.
+     */
+    wasLoadedFromBrowser: boolean;
+    /**
+     * The version of the Carbon AI Chat that this data is persisted for. If there are any breaking changes to the
+     * application state and a user reloads and gets a new version of the widget, bad things might happen so we'll
+     * just invalidate the persisted storage if we ever attempt to load an old version on Carbon AI Chat startup.
+     */
+    version: string;
+    /**
+     * Indicates which of the Carbon AI Chat views are visible and which are hidden.
+     */
+    viewState: ViewState;
+    /**
+     * Indicates if we should show an unread indicator on the launcher. This is set by
+     * {@link ChatInstance.updateAssistantUnreadIndicatorVisibility} and will display an empty circle on
+     * the launcher. This setting is overridden if there are any unread human agent messages in which case a circle
+     * with a number is displayed.
+     */
+    showUnreadIndicator: boolean;
+    /**
+     * Indicates if the mobile launcher should be in the extended state.
+     */
+    mobileLauncherIsExtended: boolean;
+    /**
+     * Determines if the mobile launcher already played the extended animation and was reduced.
+     */
+    mobileLauncherWasReduced: boolean;
+    /**
+     * Determines if the mobile launcher previously played the bounce animation and should no longer be able to.
+     */
+    mobileLauncherDisableBounce: boolean;
+    /**
+     * Indicates the desktop launcher is in its expanded state.
+     */
+    desktopLauncherIsExpanded: boolean;
+    /**
+     * Indicates the desktop launcher has been minimized.
+     */
+    desktopLauncherWasMinimized: boolean;
+    /**
+     * The bounce turn the user is currently on in the sequence of bounces so that user doesn't start over in the
+     * sequence. A turn is a full set of animations that are displayed when a bounce occurs and each turn of a bounce is
+     * when a different bounce occurs at a different point in time. This is used for both the desktop and mobile launcher.
+     */
+    bounceTurn: number;
+    /**
+     * If the user has received a message beyond the welcome node. We use this to mark if the chat has been interacted
+     * with. This flag is duplicated so the information is available before hydration and before the user is known.
+     * Note that this property reflects only the last user and should only be used when an approximate value is
+     * acceptable.
+     */
+    hasSentNonWelcomeMessage: boolean;
+    /**
+     * Map of if a disclaimer has been accepted on a given window.hostname value, keyed by hostname via
+     * {@link ObjectMap}.
+     */
+    disclaimersAccepted: ObjectMap<boolean>;
+    /**
+     * State of home screen.
+     */
+    homeScreenState: HomeScreenState;
+    /**
+     * The persisted subset of the human agent state.
+     */
+    humanAgentState: PersistedHumanAgentState;
+}
+
+/**
+ * @category Config
+ */
+interface ChatHeaderConfig {
+    /**
+     * The chat header title.
+     */
+    title?: string;
+    /**
+     * The name displayed after the title.
+     */
+    name?: string;
+}
+
+/**
+ * This component is mostly a pass-through. Its takes any properties passed into the ChatContainer
+ * custom element and then renders the React Carbon AI Chat application while passing in properties.
+ */
+
+declare class ChatContainerInternal extends LitElement {
+    /**
+     * The config to use to load Carbon AI Chat. Note that the "onLoad" property is overridden by this component. If you
+     * need to perform any actions after Carbon AI Chat been loaded, use the "onBeforeRender" or "onAfterRender" props.
+     */
+    config: PublicConfig;
+    /** Optional partial language pack overrides */
+    strings?: DeepPartial<LanguagePack>;
+    /** A factory for the {@link ServiceDesk} integration. */
+    serviceDeskFactory?: (parameters: ServiceDeskFactoryParameters) => Promise<ServiceDesk>;
+    /** Public configuration for the service desk integration. */
+    serviceDesk?: ServiceDeskPublicConfig;
+    /**
+     * The optional HTML element to mount the chat to.
+     */
+    element?: HTMLElement;
+    /**
+     * This function is called before the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onBeforeRender: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This function is called after the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onAfterRender: (instance: ChatInstance) => Promise<void> | void;
+    firstUpdated(): void;
+    updated(changedProperties: PropertyValues): void;
+    /**
+     * Track if a previous React 18+ root was already created so we don't create a memory leak on re-renders.
+     */
+    root: Root;
+    /**
+     * Cache the container we hand to React so we can reuse it between renders.
+     */
+    reactContainer?: HTMLDivElement;
+    renderReactApp(): Promise<void>;
+    private ensureReactRoot;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "cds-aichat-internal": ChatContainerInternal;
+    }
+}
+
+/**
+ * The cds-aichat-container managing creating slotted elements for user_defined responses and writable elements.
+ * It then passes that slotted content into cds-aichat-internal. That component will boot up the full chat application
+ * and pass the slotted elements into their slots.
+ */
+declare class ChatContainer extends LitElement {
+    config?: PublicConfig;
+    onError?: (data: OnErrorData) => void;
+    openChatByDefault?: boolean;
+    disclaimer?: DisclaimerPublicConfig;
+    disableCustomElementMobileEnhancements?: boolean;
+    debug?: boolean;
+    exposeServiceManagerForTesting?: boolean;
+    injectCarbonTheme?: CarbonTheme;
+    aiEnabled?: boolean;
+    aiDisabled?: boolean;
+    shouldTakeFocusIfOpensAutomatically?: boolean;
+    namespace?: string;
+    private enableFocusTrap?;
+    shouldSanitizeHTML?: boolean;
+    header?: HeaderConfig;
+    input?: InputConfig;
+    layout?: LayoutConfig;
+    messaging?: PublicConfigMessaging;
+    isReadonly?: boolean;
+    assistantName?: string;
+    locale?: string;
+    homescreen?: HomeScreenConfig;
+    launcher?: LauncherConfig;
+    /** Optional partial language pack overrides */
+    strings?: DeepPartial<LanguagePack>;
+    /**
+     * A factory to create a {@link ServiceDesk} integration instance.
+     */
+    serviceDeskFactory?: (parameters: ServiceDeskFactoryParameters) => Promise<ServiceDesk>;
+    /**
+     * Public configuration for the service desk integration.
+     */
+    serviceDesk?: ServiceDeskPublicConfig;
+    /**
+     * This function is called before the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onBeforeRender: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This function is called after the render function of Carbon AI Chat is called.
+     */
+    onAfterRender: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * The existing array of slot names for all user_defined components.
+     */
+    _userDefinedSlotNames: string[];
+    /**
+     * The existing array of slot names for all writeable elements.
+     */
+    _writeableElementSlots: string[];
+    /**
+     * The chat instance.
+     */
+    _instance: ChatInstance;
+    /**
+     * Adds the slot attribute to the element for the user_defined response type and then injects it into the component by
+     * updating this._userDefinedSlotNames;
+     */
+    userDefinedHandler: (event: BusEventUserDefinedResponse | BusEventChunkUserDefinedResponse) => void;
+    private get resolvedConfig();
+    onBeforeRenderOverride: (instance: ChatInstance) => Promise<void>;
+    addWriteableElementSlots(): void;
+    /**
+     * Renders the template while passing in class functionality
+     */
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "cds-aichat-container": ChatContainer;
+    }
+}
+/**
+ * Attributes interface for the cds-aichat-container web component.
+ * This interface extends {@link PublicConfig} with additional component-specific props,
+ * flattening all config properties as top-level properties for better TypeScript IntelliSense.
+ *
+ * @category Web component
+ */
+interface CdsAiChatContainerAttributes extends PublicConfig {
+    /**
+     * This function is called before the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onBeforeRender?: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This function is called after the render function of Carbon AI Chat is called.
+     */
+    onAfterRender?: (instance: ChatInstance) => Promise<void> | void;
+}
+
+/**
+ * Attributes interface for the cds-aichat-custom-element web component.
+ * This interface extends {@link CdsAiChatContainerAttributes} and {@link PublicConfig} with additional component-specific props,
+ * flattening all config properties as top-level properties for better TypeScript IntelliSense.
+ *
+ * @category Web component
+ */
+interface CdsAiChatCustomElementAttributes extends PublicConfig {
+    /**
+     * This function is called before the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onBeforeRender?: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This function is called after the render function of Carbon AI Chat is called.
+     */
+    onAfterRender?: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * An optional listener for "view:change" events. Such a listener is required when using a custom element in order
+     * to control the visibility of the Carbon AI Chat main window. If no callback is provided here, a default one will be
+     * used that injects styling into the app that will show and hide the Carbon AI Chat main window and also change the
+     * size of the custom element so it doesn't take up space when the main window is closed.
+     *
+     * You can provide a different callback here if you want custom behavior such as an animation when the main window
+     * is opened or closed.
+     *
+     * Note that this function can only be provided before Carbon AI Chat is loaded. After Carbon AI Chat is loaded, the event
+     * handler will not be updated.
+     */
+    onViewChange?: (event: BusEventViewChange, instance: ChatInstance) => void;
+}
+
+/**
+ * The user_defined message object passed into the renderUserDefinedResponse property on the main chat components.
+ *
+ * @category React
+ */
+interface RenderUserDefinedState {
+    /**
+     * The entire message object received when the entire message (not just the individual messageItem) has finished processing.
+     */
+    fullMessage?: Message;
+    /**
+     * The messageItem after all partial chunks are received. This will first be set to the value of the `complete_item`
+     * chunk.
+     * Once the fullMessage is resolved, this value will update to the value of the item in the fullMessage, which will
+     * be the same value unless you have done any post-processing mutations.
+     */
+    messageItem?: GenericItem;
+    /**
+     * An array of each user defined item partial chunk. Each chunk contains the new chunk information, they are not
+     * concatenated for you. When messageItem has been set an no more chunks are expected, this property is removed
+     * to avoid memory leaks.
+     */
+    partialItems?: DeepPartial<GenericItem>[];
+}
+/**
+ * The type of the render function that is used to render user defined responses. This function should return a
+ * component that renders the display for the message contained in the given event.
+ *
+ * @param state The BusEventUserDefinedResponse that was originally fired by Carbon AI Chat when the user defined response
+ * was first fired.
+ * @param instance The current instance of the Carbon AI Chat.
+ *
+ * @category React
+ */
+type RenderUserDefinedResponse = (state: RenderUserDefinedState, instance: ChatInstance) => ReactNode;
+/**
+ * A map of writeable element keys to a ReactNode to render to them.
+ *
+ * @category React
+ */
+type RenderWriteableElementResponse = {
+    [K in keyof WriteableElements]?: ReactNode;
+};
+/**
+ * Properties for the ChatContainer React component. This interface extends
+ * {@link PublicConfig} with additional component-specific props, flattening all
+ * config properties as top-level props for better TypeScript IntelliSense.
+ *
+ * @category React
+ */
+interface ChatContainerProps extends PublicConfig {
+    /**
+     * This function is called before the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onBeforeRender?: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This function is called after the render function of Carbon AI Chat is called. This function can return a Promise
+     * which will cause Carbon AI Chat to wait for it before rendering.
+     */
+    onAfterRender?: (instance: ChatInstance) => Promise<void> | void;
+    /**
+     * This is the function that this component will call when a user defined response should be rendered.
+     */
+    renderUserDefinedResponse?: RenderUserDefinedResponse;
+    /**
+     * This is the render function this component will call when it needs to render a writeable element.
+     */
+    renderWriteableElements?: RenderWriteableElementResponse;
+}
+
+/**
+ * An enum of all of our data-testid we use. For some elements (like INPUT) they can appear in multiple "panels"
+ * (e.g. on the home screen and in the main chat window). There are provided testids for "panels" as well so you
+ * can first select a panel and then select the correct child.
+ *
+ * @category Testing
+ *
+ * @experimental
+ */
+declare enum PageObjectId {
+    /**
+     * Minimize chat button in header.
+     */
+    CLOSE_CHAT = "close_chat",
+    /**
+     * The launcher button to open the chat. This id is maintained across desktop and mobile launchers.
+     */
+    LAUNCHER = "launcher_open_chat",
+    /**
+     * Input field.
+     */
+    INPUT = "input_field",
+    /**
+     * Input send button.
+     */
+    INPUT_SEND = "input_send",
+    /**
+     * The chat header title element.
+     */
+    HEADER_TITLE = "header_title",
+    /**
+     * The chat header name element.
+     */
+    HEADER_NAME = "header_name",
+    /**
+     * The main chat panel.
+     */
+    MAIN_PANEL = "main_panel",
+    /**
+     * Disclaimer panel.
+     */
+    DISCLAIMER_PANEL = "disclaimer_panel",
+    /**
+     * Disclaimer accept button.
+     */
+    DISCLAIMER_ACCEPT_BUTTON = "disclaimer_accept_button",
+    /**
+     * Homescreen Panel.
+     */
+    HOME_SCREEN_PANEL = "home_screen_panel",
+    /**
+     * Hydration/loading state panel.
+     */
+    HYDRATING_PANEL = "hydrating_panel",
+    /**
+     * Catastrophic error panel.
+     */
+    CATASTROPHIC_PANEL = "catastrophic_panel",
+    /**
+     * Iframe panel.
+     */
+    IFRAME_PANEL = "iframe_panel",
+    /**
+     * Conversational search panel.
+     */
+    CONVERSATIONAL_SEARCH_CITATION_PANEL = "conversational_search_citation_panel",
+    /**
+     * Custom panel.
+     */
+    CUSTOM_PANEL = "custom_panel",
+    /**
+     * A panel that opens from a button response.
+     */
+    BUTTON_RESPONSE_PANEL = "button_response_panel"
+}
+/**
+ * Ids used for data-testid.
+ *
+ * @category Testing
+ *
+ * @experimental
+ */
+type TestId = PageObjectId;
+
+export { LayoutCustomProperties as L, WriteableElementName as W, BusEventType as _, FeedbackInteractionType as a1, MessageSendSource as a2, ViewChangeReason as a3, CancellationReason as a8, ScreenShareState as aA, ButtonItemKind as aR, ButtonItemType as aS, CarbonTheme as ab, enLanguagePack as ae, MinimizeButtonIconType as aj, OnErrorType as al, HumanAgentsOnlineStatus as at, ErrorType as ax, FileStatusValue as ay, ViewType as b, IFrameItemDisplayOption as b8, ChainOfThoughtStepStatus as bA, UserType as bI, MessageErrorState as bK, PageObjectId as bS, MessageInputType as bf, MessageResponseTypes as bk, OptionItemPreference as bm, WidthOptions as bu, HumanAgentMessageType as by, CornersType as n };
+export type { BusEventUserDefinedResponse as $, BusEventCustomPanelClose as A, BusEventViewChange as B, ChatContainerProps as C, BusEventCustomPanelOpen as D, EventBusHandler as E, FileUploadCapabilities as F, BusEventCustomPanelPreClose as G, BusEventCustomPanelPreOpen as H, IncreaseOrDecrease as I, BusEventFeedback as J, BusEventHistoryBegin as K, BusEventHistoryEnd as M, NotificationMessage as N, BusEventMessageItemCustom as O, PersistedState as P, BusEventPreReceive as Q, BusEventPreReset as R, SendOptions as S, TypeAndHandler as T, BusEventPreSend as U, ViewState as V, BusEventReceive as X, BusEventReset as Y, BusEventSend as Z, ChatInstance as a, DateItem as a$, BusEventViewPreChange as a0, HomeScreenConfig as a4, HomeScreenStarterButton as a5, HomeScreenStarterButtons as a6, HomeScreenState as a7, ChatInstanceMessaging as a9, ServiceDesk as aB, ServiceDeskCallback as aC, ServiceDeskCapabilities as aD, ServiceDeskErrorInfo as aE, ServiceDeskFactoryParameters as aF, ServiceDeskPublicConfig as aG, StartChatOptions as aH, UserMessageErrorInfo as aI, BaseGenericItem as aJ, MessageResponseOptions as aK, MessageResponseHistory as aL, MessageRequestHistory as aM, ResponseUserProfile as aN, AudioItem as aO, BaseMessageInput as aP, ButtonItem as aQ, CardItem as aT, CarouselItem as aU, Chunk as aV, CompleteItemChunk as aW, ConnectToHumanAgentItem as aX, ConnectToHumanAgentItemTransferInfo as aY, ConversationalSearchItem as aZ, ConversationalSearchItemCitation as a_, CustomSendMessageOptions as aa, CustomMenuOption as ac, DisclaimerPublicConfig as ad, HeaderConfig as af, InputConfig as ag, LanguagePack as ah, LayoutConfig as ai, OnErrorData as ak, PublicConfig as am, PublicConfigMessaging as an, PersistedHumanAgentState as ao, DeepPartial as ap, ObjectMap as aq, AdditionalDataToAgent as ar, AgentAvailability as as, ConnectingErrorInfo as au, DisconnectedErrorInfo as av, EndChatInfo as aw, FileUpload as az, EventInput as b0, EventInputData as b1, FinalResponseChunk as b2, GenericItem as b3, GenericItemMessageFeedbackCategories as b4, GridItem as b5, HorizontalCellAlignment as b6, IFrameItem as b7, ImageItem as b9, GenericItemMessageFeedbackOptions as bB, GenericItemMessageOptions as bC, Message as bD, PartialOrCompleteItemChunk as bE, PartialResponse as bF, MessageHistoryFeedback as bG, SearchResult as bH, HistoryItem as bJ, LauncherCallToActionConfig as bL, LauncherConfig as bM, CdsAiChatContainerAttributes as bN, CdsAiChatCustomElementAttributes as bO, RenderUserDefinedResponse as bP, RenderUserDefinedState as bQ, RenderWriteableElementResponse as bR, TestId as bT, InlineErrorItem as ba, ItemStreamingMetadata as bb, MediaItem as bc, MediaItemDimensions as bd, MessageInput as be, MessageItemPanelInfo as bg, MessageOutput as bh, MessageRequest as bi, MessageResponse as bj, OptionItem as bl, PartialItemChunk as bn, PauseItem as bo, StreamChunk as bp, TextItem as bq, UserDefinedItem as br, VerticalCellAlignment as bs, VideoItem as bt, WithBodyAndFooter as bv, WithWidthOptions as bw, SingleOption as bx, ChainOfThoughtStep as bz, ChatHeaderConfig as c, CustomPanelConfigOptions as d, CustomPanelInstance as e, CustomPanels as f, ChangeFunction as g, ChatInstanceNotifications as h, ChatInstanceServiceDeskActions as i, EventHandlers as j, PublicChatHumanAgentState as k, PublicChatState as l, WriteableElements as m, BusEvent as o, BusEventHumanAgentAreAnyAgentsOnline as p, BusEventHumanAgentEndChat as q, BusEventHumanAgentPreEndChat as r, BusEventHumanAgentPreReceive as s, BusEventHumanAgentPreSend as t, BusEventHumanAgentPreStartChat as u, BusEventHumanAgentReceive as v, BusEventHumanAgentSend as w, BusEventChatReady as x, BusEventChunkUserDefinedResponse as y, BusEventClosePanelButtonClicked as z };