@carbon/ai-chat 0.1.0-alpha-2 → 0.1.0-alpha-3

package/dist/cjs.aiChatEntry.d.ts

@@ -0,0 +1,4107 @@
+/**
+ *
+ * (C) Copyright IBM Corp. 2017, 2024. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ * */
+
+import React, { ReactNode } from 'react';
+import { IntlShape } from 'react-intl';
+import { DeepPartial } from 'ts-essentials';
+
+declare enum TagType {
+  RED = 'red',
+  MAGENTA = 'magenta',
+  PURPLE = 'purple',
+  BLUE = 'blue',
+  CYAN = 'cyan',
+  TEAL = 'teal',
+  GREEN = 'green',
+  GRAY = 'gray',
+  COOL_GRAY = 'cool-gray',
+  WARM_GRAY = 'warm-gray',
+  HIGH_CONTRAST = 'high-contrast',
+  OUTLINE = 'outline',
+}
+
+/**
+ * Constants for the Carbon FileStatus type because they weren't kind enough to include their own enum.
+ */
+declare enum FileStatusValue {
+  COMPLETE = 'complete',
+  EDIT = 'edit',
+  UPLOADING = 'uploading',
+  SUCCESS = 'success',
+}
+
+/**
+ * An interface that represents a file to upload and it's current upload status.
+ */
+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;
+}
+
+/**
+ * Whether a particular web chat view is visible or not.
+ */
+interface ViewState {
+  /**
+   * Whether the launcher is visible or not.
+   */
+  launcher: boolean;
+
+  /**
+   * Whether the main window is visible or not.
+   */
+  mainWindow: boolean;
+
+  /**
+   * Whether a tour is visible or not.
+   */
+  tour: boolean;
+}
+
+/**
+ * A record of a notification to be shown in the UI.
+ */
+interface NotificationMessage {
+  kind: 'error' | 'info' | 'info-square' | 'success' | 'warning' | 'warning-alt';
+
+  /**
+   * 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;
+}
+
+/**
+ * A language pack represent the set of display strings for a particular language.
+ */
+interface LanguagePack {
+  [key: string]: string;
+}
+
+/**
+ * The different views that can be shown by web chat.
+ */
+declare enum ViewType {
+  /**
+   * The launcher view is used to open the main window or tour.
+   */
+  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, both of which are used by the
+   * {@link ChatActions.changeView} function.
+   */
+  MAIN_WINDOW = 'mainWindow',
+
+  /**
+   * The tour view is used to guide the end user through a task.
+   */
+  TOUR = 'tour',
+}
+
+/**
+ * The different variations of the launcher that can exist.
+ */
+declare enum LauncherType {
+  /**
+   * The launcher that expands to a "complex" variation on desktop.
+   */
+  DESKTOP = 'desktop',
+
+  /**
+   * The launcher that expands to an "extended" variation on mobile.
+   */
+  MOBILE = 'mobile',
+}
+
+/**
+ * This manager handles fetching an instance for manipulating the custom panel.
+ */
+interface CustomPanels {
+  /**
+   * Gets a custom panel instance.
+   */
+  getPanel: () => CustomPanelInstance;
+}
+
+/**
+ * The custom panel instance for controlling and manipulating a custom panel in web chat.
+ */
+interface CustomPanelInstance {
+  /**
+   * The custom panel hostElement.
+   */
+  hostElement: HTMLDivElement;
+
+  /**
+   * 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 web 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.
+ */
+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 close-and-restart (X) button in the custom panel should be hidden. This value only applies if
+   * the close-and-restart button is enabled.
+   */
+  hideCloseAndRestartButton?: 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;
+
+  /**
+   * This callback is called when the close-and-restart button is clicked. This is called even if {@link disableDefaultCloseAction}
+   * is set to true.
+   */
+  onClickCloseAndRestart?: () => 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.
+ */
+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 or close-and-restart buttons are clicked. The default
+   * action closes web chat and disabling this will cause the button to not do anything. You can override the button
+   * behavior by using the {@link onClickClose} or {@link onClickCloseAndRestart} callback.
+   */
+  disableDefaultCloseAction?: boolean;
+}
+
+/**
+ * A single menu option.
+ */
+interface CustomMenuOption {
+  /**
+   * The text to display for the menu option.
+   */
+  text: string;
+
+  /**
+   * The callback handler to call when the option is selected.
+   */
+  handler: () => void;
+}
+
+/**
+ * This represents the callback function that is called when an input field wants to determine if any completions
+ * should be displayed. This function is called every time the text in an input field changes. It is passed the text
+ * in the input field and the position of the cursor in the field.
+ *
+ * This function should return the list of completions that should be displayed to the user or null if no
+ * completions should be displayed.
+ */
+type OnGetCompletions = (inputText: string, cursorPosition: number) => Promise<InputCompletionResult>;
+
+/**
+ * This represents the callback that is called when a completion is selected from a completions popup on an input
+ * field. It is passed the completion that was selected which will one of the same object instances returned from the
+ * {@link OnGetCompletions} function.
+ */
+type OnCompletionSelected = (completion: InputCompletion) => void;
+interface InputCompletionResult {
+  /**
+   * The character position where the completion target begins.
+   */
+  completionStart: number;
+
+  /**
+   * The character position where the completion target ends.
+   */
+  completionEnd: number;
+
+  /**
+   * This list of possible completions.
+   */
+  completions: InputCompletion[];
+}
+interface InputCompletion {
+  /**
+   * The display text for the completion.
+   */
+  label: string;
+
+  /**
+   * The value to replace the completion target with.
+   */
+  targetValue: string;
+
+  /**
+   * An object that describes the tag to render beside the mention option.
+   */
+  tag?: {
+    /**
+     * The tag text.
+     */
+    label: string;
+
+    /**
+     * The tag color.
+     */
+    type: TagType;
+  };
+}
+
+/**
+ * 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 a back-end.
+ */
+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 will 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 that was used in making the request.
+   */
+  history?: MessageHistory;
+
+  /**
+   * The input data to the back-end to make in this request.
+   */
+  input: TInputType;
+
+  /**
+   * Optional context which is added from external resources.
+   */
+  context?: MessageContext;
+}
+
+/**
+ * The set of possible message input types in a request.
+ */
+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',
+}
+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.
+ */
+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").
+ */
+interface EventInputData<TNameType extends string = string> {
+  /**
+   * The name of the event.
+   */
+  name: TNameType;
+}
+
+/**
+ * The default interface for message input that is sent to a back-end in a message request. This represents basic text
+ * input.
+ */
+interface MessageInput extends BaseMessageInput {
+  /**
+   * 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?: AgentMessageType;
+
+  /**
+   * The text of the user input to send to the back-end.
+   */
+  text?: string;
+}
+
+/**
+ * This interface represents the main response content that is received by a client from a back-end. It is generally
+ * in response to a previous message request.
+ */
+interface MessageResponse<TGenericType = GenericItem[]> {
+  /**
+   * A unique identifier for this response object. This value is assigned by the service when the request is generated.
+   */
+  id?: string;
+
+  /**
+   * The id of the request that this is the response of. It is expected that bot responses will match a specific request, however
+   * human agent responses may not be attached to a specific user request.
+   */
+  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?: MessageContext;
+}
+
+/**
+ * The output context for a message response from a back-end.
+ */
+interface MessageOutput<TGenericType = GenericItem[]> {
+  /**
+   * Responses intended to be processed by a generic channel. This will be an array of message response items.
+   */
+  generic?: TGenericType;
+}
+
+/**
+ * Contextual information gathered by the service.
+ */
+interface MessageContext {
+  /**
+   * Global context.
+   */
+  global?: MessageGlobalContext;
+
+  /**
+   * Contains the context data for a message. The context data is divided into object for different skills that may
+   * be involved with the message.
+   */
+  skills?: {
+    /**
+     * The context associated with each skill. Note that "main skill" and "actions skill" are reserved skill names
+     * and should not be used outside of watsonx Assistant or watsonx Orchestrate.
+     */
+    [skill_name: string]: MessageSkillContext;
+  };
+}
+interface MessageGlobalContext {
+  /**
+   * Global system context
+   */
+  system?: MessageSystemContext;
+}
+interface MessageSystemContext {
+  /**
+   * The current timezone of the client.
+   */
+  timezone?: string;
+
+  /**
+   * The current system locale. Example: "en-US".
+   */
+  locale?: string;
+}
+
+/**
+ * The base interface for the content of a message context. The content of this will vary by which skill is involved
+ * in the message.
+ */
+interface MessageSkillContext {}
+
+/**
+ * The set of possible message types in a response from IBM watsonx Assistant.
+ */
+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_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 table of data to the user.
+   */
+  TABLE = 'table',
+
+  /**
+   * Displays a general error message to the user and include developer info to be logged and to debug.
+   */
+  INLINE_ERROR = 'inline_error',
+}
+
+/**
+ * The basic class for items returned from a back-end as part of a message response. These are the items contained
+ * in the {@link MessageOutput.generic} array.
+ */
+interface GenericItem<TUserDefinedType = Record<string, unknown>> {
+  /**
+   * 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?: AgentMessageType;
+
+  /**
+   * The response type of this message item.
+   */
+  response_type: MessageResponseTypes;
+
+  /**
+   * Metadata used 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;
+}
+
+/**
+ * A user defined item returned in a message response from a back-end.
+ */
+interface UserDefinedItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {}
+
+/**
+ * A text item returned in a message response from a back-end.
+ */
+interface TextItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {
+  /**
+   * The text of the response.
+   */
+  text?: string;
+
+  /**
+   * The optional formatting for the text response.
+   */
+  format?: {
+    /**
+     * If this is true, it means we are not going to get `<br />` to manage spacing and should add margin/padding
+     * to elements as required with CSS.
+     */
+    use_padding?: boolean;
+  };
+}
+
+/**
+ * A "connect to agent" item returned in a message response from a back-end. This is used when the back-end
+ * indicates that a user's conversation should be escalated to a human agent.
+ */
+interface ConnectToAgentItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<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 fullfill the request. This
+   * additional information typically is added by the channel integration and cannot be deduced from the dialog
+   * itself.
+   */
+  transfer_info?: ConnectToAgentItemTransferInfo;
+}
+
+/**
+ * Additional information as part of a {@link ConnectToAgentItem} that may be need to perform a transfer to an agent.
+ */
+interface ConnectToAgentItemTransferInfo {
+  /**
+   * A key used by the service desk to securely load the session history.
+   */
+  session_history_key?: string;
+
+  /**
+   * 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 a back-end. This indicates that the client should pause before
+ * displaying additional response items.
+ */
+interface PauseItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<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 a back-end. 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.
+ */
+interface OptionItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {
+  /**
+   * An array of objects describing the options from which the user can choose.
+   */
+  options: Option[];
+
+  /**
+   * 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.
+   */
+  preference?: OptionItemPreference;
+}
+
+/**
+ * The set of possible response preferences for an options response.
+ */
+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.
+ */
+interface Option {
+  /**
+   * 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;
+  };
+}
+interface IFrameItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<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.
+ */
+interface MediaItemDimensions {
+  /**
+   * This property's value is used to calculate a responsive height for web 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.
+ */
+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.
+ */
+interface MediaItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<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.
+ */
+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 zero index based integer indicating where in `text` the citation starts from.
+   */
+  range_start?: number;
+
+  /**
+   * Optional zero index based integer indicating where in `text`` the citation ends at. Exclusive.
+   * So the word "hi", would have the range_start of 0 and range_end of 2.
+   */
+  range_end?: number;
+
+  /**
+   * A number corresponding to the index of the matching search result. This can be used to gather extra info about a
+   * specific citation from the matching search result.
+   */
+  search_result_idx?: number;
+}
+
+/**
+ * A text response generated by AI with an optional list of citations for where the information came from.
+ */
+interface ConversationalSearchItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {
+  /**
+   * The returned conversational text. Any HTML/Markdown will be ignored.
+   */
+  text: string;
+
+  /**
+   * A title to display above the citation list, default set to "How do we know?".
+   */
+  citations_title: string;
+
+  /**
+   * A string to explain that these results are generated, default set to "Accuracy of generated answers may vary.".
+   */
+  disclaimer: string;
+
+  /**
+   * Citations are used to connect specific text within a conversational search response with the relevant documents
+   * returned by the backend.
+   */
+  citations?: ConversationalSearchItemCitation[];
+}
+
+/**
+ * The image response type definition. This is currently the same as {@link MediaItem}.
+ */
+type ImageItem = MediaItem;
+
+/**
+ * The video response type definition for future reuse. This is currently the same as {@link MediaItem}.
+ */
+type VideoItem = MediaItem;
+
+/**
+ * The audio response type definition for future reuse. This is currently the same as {@link MediaItem}.
+ */
+type AudioItem = MediaItem;
+
+/**
+ * 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.
+ */
+type DateItem = GenericItem;
+
+/**
+ * Additional metadata associated with a specific message item (response type) inside of a message response.
+ */
+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;
+}
+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;
+  };
+}
+
+/**
+ * The interface for a chunk that represents a partial update (or first time chunk) to a message item.
+ */
+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>;
+}
+
+/**
+ * The interface for a chunk that represents a complete update to a message item. 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.
+ */
+interface CompleteItemChunk extends Chunk {
+  complete_item: GenericItem;
+}
+
+/**
+ * The interface for a chunk that represents the entire completed message response. 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.
+ *
+ * The ID of the message should match the ID that was previously provided by {@link PartialItemChunk.streaming_metadata.id}.
+ */
+interface FinalResponseChunk {
+  final_response: MessageResponse;
+}
+type StreamChunk = PartialItemChunk | CompleteItemChunk | FinalResponseChunk;
+
+/**
+ * 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/bot agent.
+ */
+interface AgentProfile {
+  /**
+   * Indicates if the agent's profile information should be hidden. This will hide the entire avatar line
+   * including the agent name, avatar and timestamp.
+   */
+  hidden?: boolean;
+
+  /**
+   * A unique identifier for this agent.
+   */
+  id: string;
+
+  /**
+   * The visible name for the agent. Can be the full name or just a first name.
+   */
+  nickname: string;
+
+  /**
+   * An url pointing to an avatar for the agent.
+   */
+  profile_picture_url?: string;
+}
+
+/**
+ * A general type to indicate any message.
+ */
+type Message = MessageRequest<MessageInput> | MessageRequest<EventInput> | MessageResponse;
+
+/**
+ * TODO TOUR: If we end up supporting this user_defined approach longer term, instead of something officially supported
+ * by the backend, then we need to add this to the types repo.
+ */
+interface TourStepGenericItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {
+  /**
+   * A way for the authors to label steps so they can use the {@link TourFunctions.goToStep} function to change to a
+   * specific tour step.
+   */
+  step_id: string;
+}
+declare enum ButtonItemKind {
+  DEFAULT = 'default',
+  SECONDARY = 'secondary',
+  TERTIARY = 'tertiary',
+  DANGER = 'danger',
+  LINK = 'link',
+}
+declare enum ButtonItemType {
+  POST_BACK = 'post_back',
+  CUSTOM_EVENT = 'custom_event',
+  SHOW_PANEL = 'show_panel',
+  URL = 'url',
+}
+interface WithBodyAndFooter {
+  /**
+   * A list of message items to render in a web chat panel.
+   */
+  body?: GenericItem[];
+
+  /**
+   * A list of button items that are rendered under the panel body.
+   */
+  footer?: ButtonItem[];
+}
+interface MessageItemPanelInfo extends WithBodyAndFooter {
+  /**
+   * The title to give the panel in web 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;
+}
+
+/**
+ * This message item represents a link to a downloadable file.
+ */
+interface ButtonItem<TUserDefinedType = Record<string, unknown>> extends GenericItem<TUserDefinedType> {
+  /**
+   * The style of button to display.
+   */
+  kind?: ButtonItemKind;
+
+  /**
+   * 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 web 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;
+}
+type PartialOrCompleteItemChunk = PartialItemChunk | CompleteItemChunk;
+
+/**
+ * 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 file
+ * is the same as wa-types-chat.ts except that contains extensions beyond the watsonx Assistant store API.
+ */
+declare const EVENT_NAME_UPDATE_HISTORY = 'update_history';
+
+/**
+ * This interface contains information about the history of a given message. This information will eventually be
+ * saved in the history store.
+ */
+interface MessageHistory {
+  /**
+   * The time at which this message occurred.
+   */
+  timestamp?: number;
+
+  /**
+   * For session history the data passed to instance.updateHistoryUserDefined() is returned to the user here (on page
+   * change/refresh).
+   */
+  user_defined?: unknown;
+
+  /**
+   * 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.
+   */
+  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.
+   */
+  relatedMessageID?: string;
+}
+
+/**
+ * An event that is fired when a messageResponse is updated. This is triggered either by the end user updating messages in the pre:receive or customResponse
+ * events, or by us (internal) when we want to save state of a response type (ex. connect to agent).
+ */
+interface UpdateHistoryEvent<TMessageType = MessageResponse | MessageRequest>
+  extends EventInputData<typeof EVENT_NAME_UPDATE_HISTORY> {
+  /**
+   * The messageID of the original message that we're saving the update in history for.
+   */
+  messageID: string;
+
+  /**
+   * The partial message response to be saved to the backend and used on session history reload to update the state of a
+   * previous message.
+   */
+  partial_message?: DeepPartial<TMessageType>;
+}
+
+/**
+ * A single interaction in the Session History.
+ */
+interface HistoryItem {
+  /**
+   * The message represented by this history item.
+   */
+  message: MessageRequest<BaseMessageInput> | MessageRequest<EventInput> | MessageResponse;
+
+  /**
+   * Time this message occurred. ISO Format (e.g. 2020-03-15T08:59:56.952Z).
+   */
+  time: string;
+}
+
+/**
+ * The types of home screen backgrounds supported.
+ */
+declare enum HomeScreenBackgroundType {
+  NONE = 'none', // The home screen background is the same color as the chat background.
+  SOLID = 'solid', // All solid color for home screen.
+  TOP_CORNER_OUT = 'top_corner_out', // A top corner outward gradient color.
+  BOTTOM_UP = 'bottom_up',
+}
+
+/**
+ * A conversation starter button on the home screen. Currently, only label is provided by tooling.
+ */
+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.
+ */
+interface HomeScreenStarterButtons {
+  is_on?: boolean;
+  buttons?: HomeScreenStarterButton[];
+}
+
+/**
+ * Configuration for the optional home screen that appears before the bot chat window.
+ */
+interface HomeScreenConfig {
+  /**
+   * If the home page is turned on via config or remote config.
+   */
+  is_on?: 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;
+
+  /**
+   * An image url that will override the bot avatar displayed in home screen.
+   */
+  bot_avatar_url?: string;
+
+  /**
+   * Do not show the greeting, starters, or avatar url.
+   */
+  custom_content_only?: boolean;
+
+  /**
+   * The type of home screen background to render.
+   */
+  background?: HomeScreenBackgroundType;
+}
+
+/**
+ * The interface represents the API contract with the chat widget and contains all the public methods and properties
+ * that can be used with web chat.
+ */
+interface ChatInstance extends EventHandlers, ChatActions {
+  /**
+   * This function will be called customer code after 'loadWatsonAssistantChat' has been called and after any login or
+   * subscription operations have been performed that are required before the user's history can be loaded and the
+   * widget rendered. When called, this will load the history and then render the widget.
+   */
+  render: () => Promise<ChatInstance>;
+
+  /**
+   * Destroy the chat widget and return initial content to the DOM.
+   */
+  destroy: () => void;
+
+  /**
+   * Returns the version number of code the widget is running.
+   */
+  getWidgetVersion: () => string;
+
+  /**
+   * Returns state information of the web chat that could be useful.
+   */
+  getState: () => PublicWebChatState;
+
+  /**
+   * Returns an instance of the intl object that is used for generating translated text. Note that the object
+   * returned from this function changes each time the locale or language pack is changed.
+   */
+  getIntl: () => IntlShape;
+}
+
+/**
+ * This is the state made available by calling getState. This is a public method that returns immutable values.
+ */
+interface PublicWebChatState {
+  /**
+   * Is the web chat currently in an open state.
+   */
+  isWebChatOpen: boolean;
+
+  /**
+   * Is the web chat currently connected with a human agent.
+   */
+  isConnectedWithHumanAgent: boolean;
+
+  /**
+   * Indicates if web chat has requested to be connected to a human agent but an agent has not yet joined the
+   * conversation.
+   */
+  isConnectingWithHumanAgent: boolean;
+
+  /**
+   * Is the home screen open.
+   */
+  isHomeScreenOpen: boolean;
+
+  /**
+   * Indicates if debugging is enabled.
+   */
+  isDebugEnabled: boolean;
+
+  /**
+   * Has the user sent a message that isn't requesting the welcome node.
+   */
+  hasUserSentMessage: boolean;
+
+  /**
+   * Whether there is an active tour currently.
+   */
+  isTourActive: boolean;
+
+  /**
+   * The current viewState of the web chat.
+   */
+  viewState: ViewState;
+
+  /**
+   * State regarding service desks.
+   */
+  serviceDesk: PublicWebChatServiceDeskState;
+}
+interface PublicWebChatServiceDeskState {
+  /**
+   * Is the web chat currently connected with a human agent.
+   */
+  isConnected: boolean;
+
+  /**
+   * Indicates if web chat has requested to be connected to a human agent but an agent has not yet joined the
+   * conversation.
+   */
+  isConnecting: boolean;
+
+  /**
+   * Indicates if a conversation with a human agent has been suspended.
+   */
+  isSuspended: 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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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>;
+
+  /**
+   * Updates the current locale. This will override the default values of the language pack. You can use
+   * {@link getLocale} to identify the current locale if you need to make an update based on the user's locale.
+   */
+  updateLocale: (newLocale: string) => Promise<void>;
+
+  /**
+   * Updates the current language pack using the values from the provided language pack. This language pack does
+   * not need to be complete; only the strings contained in it will be updated. Any strings that are missing will be
+   * ignored and the current values will remain unchanged. You can use {@link getLocale} to identify the current
+   * locale if you need to make an update based on the user's locale.
+   */
+  updateLanguagePack: (newPack: DeepPartial<LanguagePack>) => void;
+
+  /**
+   * Returns the current locale in use by the widget. This may not match the locale that was provided in the
+   * original public configuration if that value was invalid or if the locale has been changed since then.
+   *
+   * @returns A string containing the language and possibly a region code. Example values include: 'en' and 'en-us'.
+   */
+  getLocale: () => string;
+
+  /**
+   * Clears the current state and removes all references to the current session. Does not start a new session unless a
+   * new message is subsequently sent.
+   */
+  destroySession: () => Promise<void>;
+
+  /**
+   * If the messageID provided is the id of a response then save the data provided within history.user_defined so it can
+   * be used to repopulate a message upon reload/page change with session history.
+   */
+  updateHistoryUserDefined: (messageID: string, data: unknown) => Promise<void>;
+
+  /**
+   * This updates the map that can be used to override the values for CSS variables in the application. Each key of the
+   * map is the name of a variable (without the "--cds-chat-" prefix) and the value is whatever the value of
+   * the variable should be set at. This function may only be called if publicConfig.__ibm__.allowPrivateMethods has
+   * been set. The values in the provided map will be merged with any variables that may already be defined in
+   * the public config which allows this function to update only the specific variables desired.
+   *
+   * @param publicVars A map of CSS variables. Each key of the map is the name of a variable (without the
+   * "--cds-chat-" prefix) and the value is whatever the value of the variable should be set at.
+   */
+  updateCSSVariables: (publicVars: Record<string, string>) => void;
+
+  /**
+   * Fire the view:pre:change and view:change events and change the view of the web 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 elements that Deb can write content to. This object is indirectly exposed to Deb using a proxy returned
+   * from {@link createWriteableElementsProxy}.
+   */
+  writeableElements: WriteableElements;
+
+  /**
+   * The elements of web chat that need to be exposed for customers to manipulate. Unlike writeable elements, these
+   * elements have existing content
+   */
+  elements: InstanceElements;
+
+  /**
+   * Methods provided to developers to interact with the tour feature.
+   */
+  tours: ChatInstanceTours;
+
+  /**
+   * Allow being able to set the input field to be invisible on assistant facing (not agent) views. Helpful for when
+   * you want to force input into a button, etc.
+   */
+  updateAssistantInputFieldVisibility: (isVisible: boolean) => void;
+
+  /**
+   * Changes the state of web 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.
+   */
+  updateBotUnreadIndicatorVisibility: (isVisible: boolean) => void;
+
+  /**
+   * Updates the currently active homeScreenConfig. Currently only used in tooling to show live updates when editing web
+   * chat configuration.
+   */
+  updateHomeScreenConfig: (homeScreenConfig: HomeScreenConfig) => 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;
+
+  /**
+   * Set the greeting message text for the launcher. Optionally specify which launcher, desktop or mobile, that the
+   * greeting message is being set for.
+   */
+  updateLauncherGreetingMessage: (
+    greetingMessage: string,
+    launcherType?: LauncherType.DESKTOP | LauncherType.MOBILE,
+  ) => void;
+
+  /**
+   * Control when the greeting message should appear. The default time is 0s which will cause it to appear immediately.
+   * Optionally specify which launcher, desktop or mobile, that the time should be set for.
+   */
+  showLauncherGreetingMessage: (time: number, launcherType?: LauncherType.DESKTOP | LauncherType.MOBILE) => void;
+
+  /**
+   * An instance of the custom panel with methods to manipulate the behavior of the custom panels.
+   */
+  customPanels: CustomPanels;
+
+  /**
+   * Updates the custom menu options.
+   */
+  updateCustomMenuOptions: (options: CustomMenuOption[]) => 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 bot 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>;
+
+  /**
+   * Initiates a {@link Chat#doAutoScroll} on the currently visible chat panel.
+   */
+  doAutoScroll: () => void;
+
+  /**
+   * 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.AGENT_PRE_END_CHAT} and {@link BusEventType.AGENT_END_CHAT} events have been fired and
+   * resolved.
+   */
+  agentEndConversation: () => Promise<void>;
+
+  /**
+   * Either increases or decreases the internal counter that indicates whether the "bot is typing" 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 with log an error. Currently, this is the same as the loading
+   * indicator.
+   */
+  updateIsTypingCounter: (direction: IncreaseOrDecrease) => void;
+
+  /**
+   * Either increases or decreases the internal counter that indicates whether the "bot 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 with log an error. Currently, this is the same as the typing
+   * indicator.
+   */
+  updateIsLoadingCounter: (direction: string) => void;
+
+  /**
+   * Updates the title of the bot panel. This value defaults to the bot name with the AI theme turned off and defaults
+   * to nothing when the AI theme is turned on.
+   */
+  updateMainHeaderTitle: (title?: null | string) => void;
+
+  /**
+   * Add a system level notification to the list of system notifications.
+   * @deprecated
+   */
+  addNotification: (notification: NotificationMessage) => void;
+
+  /**
+   * The state of notifications in the chat.
+   */
+  notifications: ChatInstanceNotifications;
+
+  /**
+   * Actions that are related to a service desk integration.
+   */
+  serviceDesk: ChatInstanceServiceDeskActions;
+}
+type IncreaseOrDecrease = 'increase' | 'decrease';
+
+/**
+ * This interface represents the options for when a MessageRequest is sent to the server with the send method.
+ */
+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;
+
+  /**
+   * Indicates if the forced pause displayed with the response should be skipped. By default, web chat will insert a
+   * pause to produce a delay of 2 seconds after the response has been received. This is to give the bot a more
+   * natural, conversational feeling to it.
+   */
+  skipPause?: boolean;
+}
+
+/**
+ * An object of elements we expose to developers to write to. Currently, this only encompasses above the welcome node,
+ * but may grow to include portions of home page, etc.
+ */
+type WriteableElements = Record<WriteableElementName, HTMLElement>;
+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 bot.
+   */
+  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',
+}
+
+/**
+ * The interface represents the elements that web chat provides access to.
+ */
+interface InstanceElements {
+  /**
+   * Returns the element that represents the main window.
+   */
+  getMainWindow: () => HasAddRemoveClassName;
+
+  /**
+   * Returns the element that represents the input field (text area) on the main message area.
+   */
+  getMessageInput: () => InstanceInputElement;
+
+  /**
+   * Returns the element that represents the input field (text area) on the home screen.
+   */
+  getHomeScreenInput: () => InstanceInputElement;
+}
+
+/**
+ * Represents one of the input elements that web chat provides access to custom code.
+ */
+interface InstanceInputElement {
+  /**
+   * The raw HTML element for the element.
+   */
+  getHTMLElement: () => HTMLTextAreaElement;
+
+  /**
+   * Sets the current text value inside the input.
+   */
+  setValue: (value: string) => void;
+
+  /**
+   * Enables or disables the handling of the enter key by the input field.
+   */
+  setEnableEnterKey: (isEnabled: boolean) => void;
+
+  /**
+   * Adds a listener that will fire whenever the value in the input field is changed. This fires immediately like an
+   * "input" event and not only when focus is lost like a "change".
+   */
+  addChangeListener: (listener: ChangeFunction) => void;
+
+  /**
+   * Removes a change listener that was previously added.
+   */
+  removeChangeListener: (listener: ChangeFunction) => void;
+
+  /**
+   * Sets the callback listener that is called before input is sent. This is called before the input field is
+   * cleared after that send occurs.
+   *
+   * @param onBeforeSend The callback to call before the input is sent. The return value of this function will be passed
+   * to the subsequent "pre:send" and "send" events that get fired with the actual message request.
+   */
+  setOnBeforeSend: (onBeforeSend: () => unknown) => void;
+
+  /**
+   * Sets the callback to call to fetch a list of matching completions for entered text. This function is called
+   * whenever the input in the input field is changed. This function may be asynchronous but it will be called again
+   * if the user changes the input before the previous call is complete. In that case, the previous call is ignored.
+   *
+   * Also note that additional actions taken by the user (such as moving the cursor position) will cancel
+   * completions resulting in any outstanding asynchronous calls being ignored.
+   */
+  setOnGetCompletions: (onGetCompletions: OnGetCompletions) => void;
+
+  /**
+   * Sets the callback that is called when a completion is selected from the completions popup.
+   */
+  setOnCompletionSelected: (onCompletionSelected: OnCompletionSelected) => void;
+}
+
+/**
+ * Methods provided to developers to interact with the tour feature.
+ */
+interface ChatInstanceTours {
+  /**
+   * Sends the given message to the backend with the skipTourCard option set to true. When a tour response is received,
+   * this method automatically starts the tour and skips the tour card. If a response other than a tour is received,
+   * then an error is logged.
+   */
+  startTour: (message: string) => void;
+
+  /**
+   * Clears all tour data, closes the tour, and switches to the launcher.
+   */
+  endTour: () => void;
+
+  /**
+   * Moves forward one step in the tour.
+   */
+  goToNextStep: () => void;
+
+  /**
+   * Looks for the provided stepId string within the tour step items. If a step with a matching step_id is found then
+   * moves to that step within the tour.
+   */
+  goToStep: (stepId: string) => void;
+}
+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;
+}
+type ChangeFunction = (text: string) => void;
+
+/**
+ * Represents an item that can add or remove class names.
+ */
+interface HasAddRemoveClassName {
+  /**
+   * Adds the given class name to the element.
+   */
+  addClassName(name: string): void;
+
+  /**
+   * Removes the given class name from the element.
+   */
+  removeClassName(name: string): void;
+}
+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;
+}
+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.AGENT_PRE_END_CHAT} and {@link BusEventType.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 section of the public config that contains configuration options for service desk integrations.
+ */
+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 web 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.
+   */
+  skipConnectAgentCard?: 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 whether the conversation between a user and a service desk should be stored in session history.
+   */
+  disableAgentSessionHistory?: boolean;
+
+  /**
+   * This indicates which of the client-only service desk integrations to use.
+   */
+  integrationType?: string;
+
+  /**
+   * Configuration data for the Genesys Web Messenger integration
+   */
+  genesysMessenger?: GenesysMessengerConfig;
+
+  /**
+   * Configuration data for the Nice DFO integration
+   */
+  niceDFO?: NiceDFOConfig;
+}
+
+/**
+ * The configuration in the main config that is needed to initialize the SDK.
+ */
+interface NiceDFOConfig {
+  /**
+   * The channel ID from the Nice embed code.
+   */
+  channelID: string;
+
+  /**
+   * The brand ID from the Nice embed code.
+   */
+  brandID: number;
+
+  /**
+   * The Nice environment where the account is hosted.
+   */
+  environment: string;
+
+  /**
+   * Indicates if the web chat user ID should be used. By default, if web chat is using a web chat generated
+   * anonymous ID, then a new unique ID is generated for the user on each interaction with Nice. If web chat is
+   * using a user ID provided by the host page, then that ID will be used instead. This value can be used to
+   * override that behavior. If this value is true, then the web chat user ID will be used even if it's for an
+   * anonymous user. If this value is false, then a new unique ID will be generated instead.
+   */
+  useWebChatUserID?: boolean;
+}
+
+/**
+ * The configuration needed to connect to Genesys for a Web Messenger deployment.
+ */
+interface GenesysMessengerConfig {
+  /**
+   * The environment to connect to.
+   */
+  environment: string;
+
+  /**
+   * The deployment ID for the deployment.
+   */
+  deploymentID: string;
+
+  /**
+   * The script URL for the SDK to use.
+   */
+  scriptURL: string;
+}
+
+/**
+ * Represents the different states for the availability of a human agent from a service desk.
+ */
+declare enum AgentsOnlineStatus {
+  /**
+   * 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.
+ */
+interface ServiceDeskFactoryParameters {
+  /**
+   * The callback used by the service desk to communicate with the widget.
+   */
+  callback: ServiceDeskCallback;
+
+  /**
+   * The instance of web 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 web chat when it wants web
+ * chat to do something. When a service desk integration instance is created, web chat will provide an
+ * implementation of this interface to the integration for it to use.
+ */
+interface ServiceDeskCallback<TPersistedStateType = unknown> {
+  /**
+   * Updates web 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 position_in_queue and estimated_wait_time can be
+   * rendered in the widget. If both fields are provided, estimated_wait_time will take priority and the
+   * position_in_queue 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: AgentProfile): 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 web 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
+   * web chat 6.7.0. Earlier versions of web 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?: AgentProfile): 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 web 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 web 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 web 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 web 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.
+ */
+interface ServiceDeskCapabilities extends FileUploadCapabilities {}
+
+/**
+ * The possible state changes for a screen sharing request.
+ */
+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 web 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 web chat if more than one has been assigned a value. Priority
+ * first goes to estimated_wait_time, then position_in_queue, and then message.
+ */
+interface AgentAvailability {
+  /**
+   * The current position of the user in a queue. E.g. "You are number 2 in line."
+   */
+  position_in_queue?: number;
+
+  /**
+   * The estimated wait time for the user in minutes. E.g. "Current wait time is 2 minutes."
+   */
+  estimated_wait_time?: number;
+
+  /**
+   * A custom message to display to the user containing the updated status. This may contain markdown.
+   *
+   * @since Web chat 6.7.0. This value will be ignored if used with earlier versions of web chat.
+   */
+  message?: string;
+}
+
+/**
+ * The possible events that may have some form of error status.
+ */
+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 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.
+ */
+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).
+ */
+interface ConnectingErrorInfo extends BaseErrorInfo {
+  /**
+   * The discriminating value for this type.
+   */
+  type: ErrorType.CONNECTING;
+
+  /**
+   * An optional message that is displayed to the user in the bot view. If this value is not provided, a default
+   * message will be shown instead.
+   *
+   * Note that support for this field was added in web 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 CONNECTING} error instead.
+ */
+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. {
+ */
+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 {@link #type} property is the discriminating value that determines which child interface is to be used.
+ */
+type ServiceDeskErrorInfo = ConnectingErrorInfo | DisconnectedErrorInfo | UserMessageErrorInfo;
+
+/**
+ * Additional options that may be passed to the service desk when a chat is started.
+ */
+interface StartChatOptions<TPayloadType = unknown> {
+  /**
+   * Information necessary for loading an agent app version of web chat.
+   */
+  agentAppInfo?: AgentAppInfo;
+
+  /**
+   * Some arbitrary payload of data that was provided as part of the "agent:pre:startChat" event.
+   */
+  preStartChatPayload: TPayloadType;
+}
+
+/**
+ * This data is used to configure a read only web chat inside the service desk.
+ */
+interface AgentAppInfo {
+  /**
+   * A string that is separated by AGENT_APP_KEY_SEPARATOR that can be used to create a PublicConfig. It includes base
+   * connect info like integrationID, etc., and by pass JWT security with a one time auth code.
+   *
+   * @see ConnectToAgentItemTransferInfo.session_history_key
+   */
+  sessionHistoryKey: string;
+}
+
+/**
+ * Additional info that may be provided when a chat is ended.
+ */
+interface EndChatInfo<TPayloadType = unknown> {
+  /**
+   * Before a chat is ended, a {@link BusEventType.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 web chat.
+   */
+  endedByAgent: boolean;
+}
+
+/**
+ * This is a set of additional data that may be included when the user sends a message to an agent.
+ */
+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.
+ */
+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 web 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 web chat when an agent joins or messages are received.
+   *
+   * This may be called multiple times by web 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 web 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) => 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>;
+
+  /**
+   * Informs the service desk of a change in the state of the web chat that is relevant to the service desks. These
+   * values may change at any time.
+   */
+  updateState?: (state: ServiceDeskStateFromWAC) => 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 #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 interface represents the pieces of web chat state that can be provided to the service desks. Any of these
+ * bits of state may be updated at any time and the service desks need to be prepared to handle the changes to these
+ * values.
+ */
+interface ServiceDeskStateFromWAC {
+  /**
+   * The current session ID. This may change at any point if the user's session times out and a new session is created.
+   */
+  sessionID: string;
+
+  /**
+   * The ID of the current user. This can be changed when a user becomes authenticated.
+   */
+  userID: string;
+
+  /**
+   * The current locale.
+   */
+  locale: string;
+}
+
+/**
+ * These are the human agent specific message types.
+ */
+declare enum AgentMessageType {
+  INLINE_ERROR = 'inline_error',
+  FROM_AGENT = 'from_agent',
+  FROM_USER = 'from_user',
+  AGENT_LEFT_CHAT = 'agent_left_chat',
+  AGENT_ENDED_CHAT = 'agent_ended_chat',
+  AGENT_JOINED = 'agent_joined',
+  RELOAD_WARNING = 'user_connected_warning',
+  TRANSFER_TO_AGENT = 'transfer_to_agent',
+  USER_ENDED_CHAT = 'user_ended_chat',
+  CHAT_WAS_ENDED = 'chat_was_ended',
+  DISCONNECTED = 'disconnected',
+  RECONNECTED = 'reconnected',
+  SHARING_REQUESTED = 'sharing_requested',
+  SHARING_ACCEPTED = 'sharing_accepted',
+  SHARING_DECLINED = 'sharing_declined',
+  SHARING_CANCELLED = 'sharing_cancelled',
+  SHARING_ENDED = 'sharing_ended',
+  SYSTEM = 'system',
+}
+
+/**
+ * This file contains the type definitions for the event bus.
+ */
+
+declare const enum BusEventType {
+  CLOSE_PANEL_BUTTON_TOGGLED = 'closePanelButton:toggled',
+  PRE_RECEIVE = 'pre:receive',
+  RECEIVE = 'receive',
+  PRE_SEND = 'pre:send',
+  SEND = 'send',
+  VIEW_PRE_CHANGE = 'view:pre:change',
+  VIEW_CHANGE = 'view:change',
+  MESSAGE_ITEM_CUSTOM = 'messageItemCustom',
+  CUSTOM_RESPONSE = 'customResponse',
+  USER_DEFINED_RESPONSE = 'userDefinedResponse',
+  PROCESS_OPEN = 'process:open',
+  PROCESS_CLOSE = 'process:close',
+  PROCESS_CANCEL = 'process:cancel',
+  HISTORY_BEGIN = 'history:begin',
+  HISTORY_END = 'history:end',
+  IDENTITY_EXPIRED = 'identityTokenExpired',
+  PRE_RESTART_CONVERSATION = 'pre:restartConversation',
+  RESTART_CONVERSATION = 'restartConversation',
+  CHAT_READY = 'chat:ready',
+  CUSTOM_PANEL_PRE_OPEN = 'customPanel:pre:open',
+  CUSTOM_PANEL_OPEN = 'customPanel:open',
+  CUSTOM_PANEL_PRE_CLOSE = 'customPanel:pre:close',
+  CUSTOM_PANEL_CLOSE = 'customPanel:close',
+  SESSION_EXPIRED = 'sessionExpired',
+  TOUR_START = 'tour:start',
+  TOUR_END = 'tour:end',
+  TOUR_STEP = 'tour:step',
+
+  /**
+   * This event is fired before web chat processes a message received from a human agent from a service desk.
+   */
+  AGENT_PRE_RECEIVE = 'agent:pre:receive',
+
+  /**
+   * This event is fired after web chat processes a message received from a human agent from a service desk.
+   */
+  AGENT_RECEIVE = 'agent:receive',
+
+  /**
+   * This event is fired before web chat sends a message to a human agent from a service desk.
+   */
+  AGENT_PRE_SEND = 'agent:pre:send',
+
+  /**
+   * This event is fired after web chat sends a message to a human agent from a service desk.
+   */
+  AGENT_SEND = '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.
+   */
+  AGENT_PRE_START_CHAT = '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 agent:endChat event however is fired in that case.
+   */
+  AGENT_PRE_END_CHAT = 'agent:pre:endChat',
+
+  /**
+   * This event is fired after a chat with an agent has ended. This is fired after {@link AGENT_PRE_END_CHAT} but
+   * can be fired both from the user leaving the chat or the agent ending the chat.
+   */
+  AGENT_END_CHAT = 'agent:endChat',
+
+  /**
+   * This event is fired after web 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.
+   */
+  AGENT_ARE_ANY_AGENTS_ONLINE = 'agent:areAnyAgentsOnline',
+
+  /**
+   * This event is fired before a message between the user and a live agent is added to session history. It allows
+   * the customer to modify the message in order to do things like remove PII from being stored by IBM watsonx
+   * Assistant.
+   */
+  AGENT_PRE_SESSION_HISTORY = 'agent:pre:sessionHistory',
+  GENESYS_MESSENGER_AUTH_PROVIDER = 'agent:genesysMessenger:AuthProvider',
+  GENESYS_MESSENGER_GET_AUTH_CODE = 'agent:genesysMessenger:getAuthCode',
+  GENESYS_MESSENGER_REAUTHENTICATE = 'agent:genesysMessenger:reAuthenticate',
+  GENESYS_MESSENGER_LOGGED_OUT = 'agent:genesysMessenger:loggedOut',
+  GENESYS_MESSENGER_AUTH_ERROR = 'agent:genesysMessenger:authError',
+  NICE_DFO_GET_AUTH_CODE = 'agent:niceDFO:getAuthCode',
+  CHUNK_USER_DEFINED_RESPONSE = 'chunk:userDefinedResponse',
+  ALL_EVENTS = '*',
+}
+
+/**
+ * The possible reasons why the view may be changed.
+ */
+declare enum ViewChangeReason {
+  /**
+   * Indicates the web chat has loaded for the first time and a view is trying to open. If {@link 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 either a tour or the main window.
+   */
+  LAUNCHER_CLICKED = 'launcherClicked',
+
+  /**
+   * Indicates the view is trying to change after loading session history.
+   */
+  SESSION_HISTORY = 'sessionHistory',
+
+  /**
+   * Indicates the main window was opened by a call to {@link ChatInstance.openWindow} or
+   * {@link ChatInstance.toggleOpen}.
+   */
+  CALLED_OPEN_WINDOW = 'calledOpenWindow',
+
+  /**
+   * Indicates the main window was opened because a link ID was found that started a specific conversation.
+   */
+  LINK_ID = 'linkID',
+
+  /**
+   * Indicates the main window was opened from a tour.
+   */
+  TOUR_OPENED_OTHER_VIEW = 'tourOpenedOtherView',
+
+  /**
+   * Indicates the {@link ChatInstance.restartConversation} method was used while a tour was visible.
+   */
+  CALLED_RESTART_CONVERSATION = 'calledRestartConversation',
+
+  /**
+   * Indicates the main window is being opened as a result of a channel transfer.
+   */
+  CHANNEL_TRANSFER = 'channelTransfer',
+
+  /**
+   * Indicates the user clicked on our built-in minimize button that closed to either the launcher or a tour.
+   */
+  MAIN_WINDOW_MINIMIZED = 'mainWindowMinimized',
+
+  /**
+   * Indicates the main window was closed by a call to {@link ChatInstance.closeWindow} or
+   * {@link ChatInstance.toggleOpen}.
+   */
+  CALLED_CLOSE_WINDOW = 'calledCloseWindow',
+
+  /**
+   * Indicates a tour was started by the start tour button in the main window.
+   */
+  TOUR_CARD_STARTED_TOUR = 'tourCardStartedTour',
+
+  /**
+   * Indicates a tour was resumed by the resume button in the main window.
+   */
+  TOUR_CARD_RESUMED_TOUR = 'tourCardResumedTour',
+
+  /**
+   * Indicates a tour was restarted by the restart button in the main window.
+   */
+  TOUR_CARD_RESTARTED_TOUR = 'tourCardRestartedTour',
+
+  /**
+   * Indicates a tour was started by the {@link startTour} instance method.
+   */
+  CALLED_START_TOUR = 'calledStartTour',
+
+  /**
+   * Indicates a tour was started by a tour response type that included the 'skip_card' flag.
+   */
+  TOUR_SKIP_CARD = 'tourSkipCard',
+
+  /**
+   * Indicates the user clicked the close and restart button that minimized to the launcher.
+   */
+  MAIN_WINDOW_CLOSED_AND_RESTARTED = 'mainWindowClosedAndRestarted',
+
+  /**
+   * Indicates the user clicked on the minimize button within the tour to close to the launcher.
+   */
+  TOUR_MINIMIZED = 'tourMinimized',
+
+  /**
+   * Indicates the close button was used to close a tour.
+   */
+  TOUR_CLOSED = 'tourClosed',
+
+  /**
+   * Indicates the done button was used to close a tour.
+   */
+  TOUR_DONE = 'tourDone',
+
+  /**
+   * Indicates the view was changed by a call to {@link ChatInstance.changeView}.
+   */
+  CALLED_CHANGE_VIEW = 'calledChangeView',
+
+  /**
+   * Indicates the {@link ChatInstance.tours.endTour} method was used to close a tour.
+   */
+  CALLED_END_TOUR = 'calledEndTour',
+}
+
+/**
+ * The different sources that can cause a send event to occur.
+ */
+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 automatic follow-up message that occurs after a skip-user-input response.
+   */
+  SKIP_USER_INPUT = 'skipUserInput',
+
+  /**
+   * The message was sent as an automatic re-send when web chat is loaded. This occurs when web 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',
+
+  /**
+   * A link ID was detected on the page and an automatic "welcome request" was sent.
+   */
+  LINK_ID = 'linkID',
+
+  /**
+   * The user clicked a starter from the home screen.
+   */
+  HOME_SCREEN_STARTER = 'homeScreenStarter',
+
+  /**
+   * The user made a choice from a disambiguation response.
+   */
+  DISAMBIGUATION = 'disambiguation',
+
+  /**
+   * The startTour method has called.
+   */
+  START_TOUR_METHOD = 'startTourMethod',
+
+  /**
+   * 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 user chose an alternate response message from the suggestions menu.
+   */
+  SUGGESTIONS_MESSAGE = 'suggestionsMessage',
+
+  /**
+   * The user chose a home screen starter from the suggestions menu.
+   */
+  SUGGESTIONS_STARTER = 'suggestionsStarter',
+
+  /**
+   * The user chose the contact option from the suggestions menu.
+   */
+  SUGGESTIONS_CONTACT = 'suggestionsContact',
+
+  /**
+   * A 3rd strike occurred and an automatic suggestions contact message was sent.
+   */
+  SUGGESTIONS_3RD_STRIKE = 'suggestions3rdStrike',
+}
+
+/**
+ * The possible reasons why a tour could be started. Purposefully not firing this event when the restart button is
+ * clicked.
+ */
+declare enum TourStartReason {
+  /**
+   * If the {@link startTour} instance method was used to start the tour.
+   */
+  START_TOUR_METHOD = 'start_tour_method',
+
+  /**
+   * If the skip_card property was true within the tour json.
+   */
+  SKIP_CARD = 'skip_card',
+
+  /**
+   * If the user clicked the tour card's start button.
+   */
+  START_TOUR_CLICKED = 'start_tour_clicked',
+}
+
+/**
+ * The possible reasons why a tour could have ended. Purposefully not firing this event when the close button is clicked
+ * or the {@link endTour} instance method is used.
+ */
+declare enum TourEndReason {
+  /**
+   * If the user clicked the done button.
+   */
+  DONE_CLICKED = 'done_clicked',
+}
+interface BusEvent {
+  /**
+   * The type of this event.
+   */
+  type: BusEventType;
+}
+
+/**
+ * This event is for the
+ */
+interface BusEventClosePanelButtonClicked extends BusEvent {
+  type: BusEventType.CLOSE_PANEL_BUTTON_TOGGLED;
+}
+interface BusEventPreReceive extends BusEvent {
+  type: BusEventType.PRE_RECEIVE;
+  data: MessageResponse;
+
+  /**
+   * Defaulted to true. If true then changes made to the message object in pre:receive will be saved in the session
+   * history for the length of the session. If the changes are saved then the message will look the same to the end user
+   * before and after page change/reload as long as the session history feature is enabled. If updateHistory is false
+   * the changes will not be saved in the history. While the message will still initially update successfully if this is
+   * false, the changes won't be preserved and the end user will see the original message (that was received before the
+   * pre:receive changes) when a page change/reload occurs.
+   */
+  updateHistory: boolean;
+}
+interface BusEventReceive extends BusEvent {
+  type: BusEventType.RECEIVE;
+  data: MessageResponse;
+}
+interface BusEventPreSend extends BusEvent {
+  type: BusEventType.PRE_SEND;
+  data: MessageRequest;
+
+  /**
+   * The source of the message being sent.
+   */
+  source: MessageSendSource;
+
+  /**
+   * An optional payload object that was provided as part of the "onBeforeSend" callback from an input field.
+   */
+  beforeSendPayload?: unknown;
+}
+interface BusEventSend extends BusEvent {
+  type: BusEventType.SEND;
+  data: MessageRequest;
+
+  /**
+   * The source of the message being sent.
+   */
+  source: MessageSendSource;
+
+  /**
+   * An optional payload object that was provided as part of the "onBeforeSend" callback from an input field.
+   */
+  beforeSendPayload?: unknown;
+}
+interface BusEventAgentPreReceive extends BusEvent {
+  type: BusEventType.AGENT_PRE_RECEIVE;
+  data: MessageResponse;
+  agentProfile?: AgentProfile;
+}
+interface BusEventAgentReceive extends BusEvent {
+  type: BusEventType.AGENT_RECEIVE;
+  data: MessageResponse;
+  agentProfile?: AgentProfile;
+}
+interface BusEventAgentPreSend extends BusEvent {
+  type: BusEventType.AGENT_PRE_SEND;
+  data: MessageRequest;
+  files: FileUpload[];
+}
+interface BusEventAgentSend extends BusEvent {
+  type: BusEventType.AGENT_SEND;
+  data: MessageRequest;
+  files: FileUpload[];
+}
+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 web 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 web chat's view should
+   * not be changed.
+   */
+  cancelViewChange: boolean;
+}
+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 web 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 web 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;
+}
+interface BusEventReset extends BusEvent {
+  type: BusEventType.RESTART_CONVERSATION;
+}
+interface BusEventChatReady extends BusEvent {
+  type: BusEventType.CHAT_READY;
+}
+interface BusEventPreReset extends BusEvent {
+  type: BusEventType.PRE_RESTART_CONVERSATION;
+}
+
+/**
+ * A list of custom event types that can trigger a custom event.
+ */
+declare enum CustomEventType {
+  BUTTON_ITEM_CLICKED = 'buttonItemClicked',
+}
+
+/**
+ * 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.
+ */
+interface BusEventMessageItemCustom extends BusEvent {
+  type: BusEventType.MESSAGE_ITEM_CUSTOM;
+
+  /**
+   * The event type that triggered the custom event.
+   */
+  customEventType: CustomEventType;
+
+  /**
+   * 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;
+}
+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 element to which customers can add the custom code to render for the custom response.
+     */
+    element?: HTMLElement;
+
+    /**
+     * An assignable property that the event listener can assign that will indicate if the response is supposed to
+     * be full width.
+     */
+    fullWidth?: boolean;
+  };
+}
+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 element to which customers can add the custom code to render for the custom response.
+     */
+    element?: HTMLElement;
+
+    /**
+     * An assignable property that the event listener can assign that will indicate if the response is supposed to
+     * be full width.
+     */
+    fullWidth?: boolean;
+  };
+}
+
+/**
+ * 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.
+ */
+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[];
+}
+
+/**
+ * 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.
+ */
+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[];
+}
+interface BusEventCustomPanelPreOpen extends BusEvent {
+  type: BusEventType.CUSTOM_PANEL_PRE_OPEN;
+}
+interface BusEventCustomPanelOpen extends BusEvent {
+  type: BusEventType.CUSTOM_PANEL_OPEN;
+}
+interface BusEventCustomPanelPreClose extends BusEvent {
+  type: BusEventType.CUSTOM_PANEL_PRE_CLOSE;
+}
+interface BusEventCustomPanelClose extends BusEvent {
+  type: BusEventType.CUSTOM_PANEL_CLOSE;
+}
+
+/**
+ * Fired when a tour is started. The tour could be started upon receipt of a tour message with skip_card true, when a
+ * developer used the {@link startTour} instance method, or when the start tour card is clicked by the user.
+ * Purposefully not firing this event when the restart button is clicked.
+ */
+interface BusEventTourStart extends BusEvent {
+  type: BusEventType.TOUR_START;
+
+  /**
+   * The reason for the tour starting.
+   */
+  reason: TourStartReason;
+}
+
+/**
+ * Fired when the tour is ended by clicking the done button at the end of the tour. Purposefully not firing this event
+ * when the close button is clicked or the {@link endTour} instance method is used.
+ */
+interface BusEventTourEnd extends BusEvent {
+  type: BusEventType.TOUR_END;
+
+  /**
+   * The reason for the tour ending.
+   */
+  reason: TourEndReason;
+}
+
+/**
+ * Fired when a new step is shown to the user. This could be caused by a tour starting/restarting, the user clicking the
+ * next or previous buttons within the tour, or by a developer calling the {@link goToNextStep} or {@link goToStep}
+ * instance methods. Purposefully not firing this event when a tour is resumed.
+ */
+interface BusEventTourStep extends BusEvent {
+  type: BusEventType.TOUR_STEP;
+
+  /**
+   * The details of the new step item.
+   */
+  step: TourStepGenericItem;
+}
+
+/**
+ * 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.
+ */
+interface BusEventAgentPreStartChat<TPayloadType = unknown> extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.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;
+
+  /**
+   * The key that can be provided for the agent app configuration to load an agent app version of web chat.
+   */
+  sessionHistoryKey: string;
+}
+
+/**
+ * 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.
+ */
+interface BusEventAgentPreEndChat<TPayloadType = unknown> extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.AGENT_PRE_END_CHAT;
+
+  /**
+   * Indicates if the chat was ended by the agent.
+   */
+  endedByAgent: boolean;
+
+  /**
+   * An arbitrary payload object that a listener may set. This payload will be passed to the service desk
+   * {@link 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 AGENT_PRE_END_CHAT} but
+ * can be fired both from the user leaving the chat or the agent ending the chat.
+ */
+interface BusEventAgentEndChat extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.AGENT_END_CHAT;
+
+  /**
+   * Indicates if the chat was ended by the agent.
+   */
+  endedByAgent: 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 web 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.
+ */
+interface BusEventAgentAreAnyAgentsOnline extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.AGENT_ARE_ANY_AGENTS_ONLINE;
+
+  /**
+   * The result that was returned from "areAnyAgentsOnline". If an error occurred, this will be
+   * {@link AgentsOnlineStatus.OFFLINE}.
+   */
+  areAnyAgentsOnline: AgentsOnlineStatus;
+}
+
+/**
+ * This event is fired before a message from a live agent or the user (to an agent) is added to session history. It
+ * gives the customer the opportunity to filter out PII from the messages so they are not stored by IBM watsonx
+ * Assistant.
+ */
+interface BusEventAgentPreSessionHistory extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.AGENT_PRE_SESSION_HISTORY;
+
+  /**
+   * The message that is to be saved in session history.
+   */
+  message: MessageRequest | MessageResponse;
+}
+interface BusEventGenesysMessengerAuthProvider extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.GENESYS_MESSENGER_AUTH_PROVIDER;
+
+  /**
+   * The AuthProvider plugin that was created.
+   */
+  authProvider: unknown;
+}
+interface BusEventGenesysMessengerGetAuthCode extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.GENESYS_MESSENGER_GET_AUTH_CODE;
+
+  /**
+   * The event provided by Genesys.
+   */
+  genesysEvent: unknown;
+}
+interface BusEventGenesysMessengerAuthError extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.GENESYS_MESSENGER_AUTH_ERROR;
+
+  /**
+   * The error provided by Genesys.
+   */
+  genesysError: unknown;
+}
+interface BusEventGenesysMessengerLoggedOut extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.GENESYS_MESSENGER_LOGGED_OUT;
+
+  /**
+   * The event provided by Genesys.
+   */
+  genesysEvent: unknown;
+}
+interface BusEventGenesysMessengerReauthenticate extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.GENESYS_MESSENGER_REAUTHENTICATE;
+
+  /**
+   * The event provided by Genesys.
+   */
+  genesysEvent: unknown;
+}
+interface BusEventNiceDFOGetAuthCode extends BusEvent {
+  /**
+   * The type of the event.
+   */
+  type: BusEventType.NICE_DFO_GET_AUTH_CODE;
+
+  /**
+   * The authentication code set by the event handler. This code will be provided to Nice.
+   */
+  authCode: string;
+
+  /**
+   * The visitor ID code set by the event handler. This code will be provided to Nice.
+   */
+  visitorID?: string;
+}
+
+/**
+ * Messaging actions for a chat instance.
+ */
+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 v2 message API Response 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>;
+}
+interface CustomSendMessageOptions {
+  /**
+   * A signal to let customSendMessage to cancel a request if it has exceeded web chat's timeout.
+   */
+  signal: AbortSignal;
+}
+
+/**
+ * This file contains the definition for the public application configuration operations that are provided by the
+ * host page.
+ */
+interface PublicConfig {
+  /**
+   * The callback function that is called by the loadWatsonAssistantChat script once it is loaded. This is optional;
+   * to use web chat without this requires using the "window.loadWatsonAssistantChat" function instead.
+   */
+  onLoad?: (instance: ChatInstance) => void;
+
+  /**
+   * This is a one-off listener for errors. This value may be provided in the initial page config as a hook for
+   * customers to listen for errors. We use this instead of a normal event bus handler because this function can be
+   * defined and called before the event bus has been created which allows it to be used in loadWatsonAssistantChat.
+   */
+  onError?: (data: OnErrorData) => void;
+
+  /**
+   * An optional element the page can use as a custom in to which to render the widget.
+   */
+  element?: Element;
+
+  /**
+   * Render the chat launcher element used to open and close the chat window. If you elect to not show our built in
+   * chat launcher, you will be responsible for firing the launcher:toggle, launcher:open or launcher:close events
+   * from your own chat launcher. Or, you can use options.openChatByDefault to just have the chat interface be open
+   * at initialization.
+   */
+  showLauncher?: boolean;
+
+  /**
+   * By default, the chat window will be rendered in a "closed" state.
+   */
+  openChatByDefault?: boolean;
+
+  /**
+   * Beta version of disclaimer screen. No tooling for this.
+   */
+  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;
+  themeConfig?: ThemeConfig;
+
+  /**
+   * A nonce value to set on restricted elements to allow them to satisfy a Content-Security-Policy. If a website is
+   * using a Content-Security-Policy along with a nonce to whitelist which style and script elements are allowed,
+   * the site can provide this nonce value here which will then be added to the dynamic script and style tags
+   * generated by the widget which will allow them to run.
+   */
+  cspNonce?: string;
+
+  /**
+   * 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.
+   */
+  serviceDeskFactory?: (parameters: ServiceDeskFactoryParameters) => Promise<ServiceDesk>;
+
+  /**
+   * Agent app is a mode of web chat used in service desk UIs to show the chat history to the agent. Setting this flag
+   * will adjust the way web chat renders and behaves, e.g. with no input field, opens by default, etc
+   */
+  agentAppConfig?: AgentAppConfig;
+
+  /**
+   * Any public config to apply to service desks.
+   */
+  serviceDesk?: ServiceDeskPublicConfig;
+
+  /**
+   * If the web chat should grab focus if the web chat is open on page load. This applies to session history open
+   * states as well as openByChatByDefault. This should be set to false if the web chat is embedded in the tooling, for
+   * instance.
+   */
+  shouldTakeFocusIfOpensAutomatically?: boolean;
+
+  /**
+   * An optional namespace that can be added to the web chat that must be 30 characters or under. This value is
+   * intended to enable multiple instances of the web 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 web chats on the same page.
+   *
+   * Note: this value is used in the aria region label for the web chat. This means this value will be read out loud
+   * by users using a screen reader.
+   */
+  namespace?: string;
+
+  /**
+   * Indicates if a focus trap should be enabled when the web chat is open.
+   */
+  enableFocusTrap?: boolean;
+
+  /**
+   * The configuration that defines how web chat responds to link page requests (where there's a link reference in the
+   * URL).
+   */
+  pageLinkConfig?: PageLinkConfig;
+
+  /**
+   * If true, disables functionality in web chat that changes the window title.
+   */
+  disableWindowTitleChanges?: boolean;
+
+  /**
+   * Indicates if web chat should sanitize HTML from a user or from the assistant.
+   */
+  shouldSanitizeHTML?: boolean;
+
+  /**
+   * Indicates if the internal web chat PDF viewer should be disabled. If true, web chat will present links to PDFs
+   * as actual links that will open in the user's web browser using the browser's native viewer instead of the web chat
+   * viewer.
+   */
+  disablePDFViewer?: boolean;
+
+  /**
+   * A config object to modify tours.
+   */
+  tourConfig?: {
+    /**
+     * Indicates if the minimize button should be hidden.
+     */
+    hideMinimizeButton?: boolean;
+
+    /**
+     * Indicates if the chat button should be hidden.
+     */
+    hideChatButton?: boolean;
+  };
+
+  /**
+   * Configuration to control how streaming works.
+   */
+  streaming?: {
+    /**
+     * Indicates if streaming is disabled or not. Streaming is disabled by default but can be enabled through this
+     * configuration or tooling. When streaming is enabled, the assistant may return a text/event-stream response for a
+     * message request.
+     */
+    disabled?: boolean;
+  };
+
+  /**
+   * Extra config for controlling the behavior of the header.
+   */
+  headerConfig?: HeaderConfig;
+
+  /**
+   * The config object for changing web chat's layout.
+   */
+  layout?: LayoutConfig;
+
+  /**
+   * Config options for controlling messaging.
+   */
+  messaging?: PublicConfigMessaging;
+}
+declare enum MinimizeButtonIconType {
+  /**
+   * This shows an "X" icon.
+   */
+  CLOSE = 'close',
+
+  /**
+   * This shows a "-" icon.
+   */
+  MINIMIZE = 'minimize',
+
+  /**
+   * This shows an icon that indicates that the web chat can be collapsed into a side panel.
+   */
+  SIDE_PANEL_LEFT = 'side-panel-left',
+
+  /**
+   * This shows an icon that indicates that the web chat can be collapsed into a side panel.
+   */
+  SIDE_PANEL_RIGHT = 'side-panel-right',
+}
+interface HeaderConfig {
+  /**
+   * Indicates the icon to use for the close button in the header.
+   */
+  minimizeButtonIconType?: MinimizeButtonIconType;
+
+  /**
+   * Hide the ability to minimize the web chat.
+   */
+  hideMinimizeButton?: boolean;
+
+  /**
+   * If true, shows the restart conversation button in the header of home screen and main chat.
+   */
+  showRestartButton?: boolean;
+
+  /**
+   * Indicates if the close and restart (X) button should be rendered.
+   *
+   */
+  showCloseAndRestartButton?: boolean;
+}
+
+/**
+ * When web chat is being used as the view for the human agent.
+ */
+interface AgentAppConfig {
+  /**
+   * Sets chat to be in "agent app" mode. This means no user input is allowed and an "auth_code" will be included in the
+   * request to fetch the conversation history.
+   */
+  is_on: boolean;
+
+  /**
+   * The auth_code passed from the connect_to_agent response type used to authenticate the session. This can be used to
+   * embed a web chat into an agent application as an iframe and load the conversation history for the agent to see.
+   */
+  auth_code?: string;
+}
+
+/**
+ * The configuration that defines how web chat responds to link page requests (where there's a link reference in the
+ * URL).
+ */
+interface PageLinkConfig {
+  /**
+   * The configuration for all the link IDs. The keys are the link IDs and the values are the configurations
+   * specific to each link ID.
+   */
+  linkIDs: Record<string, PageLinkIDConfig>;
+}
+
+/**
+ * The link configuration for a specific link ID.
+ */
+interface PageLinkIDConfig {
+  /**
+   * The text of the utterance that will be sent to the assistant when the page is loaded and the given link ID is
+   * found.
+   */
+  text: string;
+}
+interface LayoutConfig {
+  /**
+   * Indicates if the web chat widget should keep its border and box-shadow.
+   */
+  showFrame?: boolean;
+}
+
+/**
+ * Config options for controlling messaging.
+ */
+interface PublicConfigMessaging {
+  /**
+   * A callback for web chat to use to send messages to the assistant. When this is provided, this will be used as
+   * an alternative for its built-in message service. Note that this is not used for human agent communication
+   * (except for the event messages to update history).
+   *
+   * Web chat will queue up any additional user messages until the Promise from a previous call to customSendMessage
+   * has resolved. This does not include event messages. 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 web chat to retrieve history data for populating the web chat. If
+   * this function is defined, it will be used instead of any other mechanism for fetching history.
+   */
+  customLoadHistory?: (instance: ChatInstance) => Promise<HistoryItem[]>;
+
+  /**
+   * Indicates if web chat should make a request for the welcome message when a new conversation begins. If this is
+   * true, then web chat will start with an empty conversation.
+   */
+  skipWelcome?: boolean;
+
+  /**
+   * Changes the timeout used by the message service when making message calls. The timeout is in seconds. The
+   * default is 40 seconds. After this time, an error will be shown in the client and an Abort signal will be sent
+   * to customSendMessage.
+   */
+  messageTimeoutSecs?: number;
+
+  /**
+   * Indicates if the context from the previous response should be copied on the next request. This is true by default.
+   */
+  copyPreviousContextOnRequest?: boolean;
+}
+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 'g10'. See
+ * https://carbondesignsystem.com/guidelines/color/tokens.
+ */
+declare enum CarbonTheme {
+  WHITE = 'white',
+  G10 = 'g10',
+  G90 = 'g90',
+  G100 = 'g100',
+}
+
+/**
+ * The types of corners web chat can have.
+ */
+declare enum CornersType {
+  ROUND = 'round',
+  SQUARE = 'square',
+}
+
+/**
+ * The different categories of errors that the system can record. These values are published for end user consumption.
+ */
+declare enum OnErrorType {
+  /**
+   * Indicates an error loading the remote init config.
+   */
+  INITIAL_CONFIG = 'INITIAL_CONFIG',
+
+  /**
+   * Indicates an error loading the main config.
+   */
+  OPEN_CONFIG = 'OPEN_CONFIG',
+
+  /**
+   * 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 React components that occurs as part of rendering the UI.
+   */
+  RENDER = 'RENDER',
+
+  /**
+   * This indicates an error with the identity token.
+   */
+  IDENTITY_TOKEN = 'IDENTITY_TOKEN',
+
+  /**
+   * This indicates an error with the MCSP identity token.
+   */
+  MCSP_IDENTITY_TOKEN = 'MCSP_IDENTITY_TOKEN',
+
+  /**
+   * This indicates a known error with the configuration for the integration or assistant. The only current case
+   * is when the web chat receives a connect_to_agent response and no service desk has been configured. These are
+   * generally user errors.
+   */
+  INTEGRATION_ERROR = 'INTEGRATION_ERROR',
+
+  /**
+   * The agent in the service desk waited too long to pick up the request and the session has expired so history cannot
+   * be fetched.
+   */
+  AGENT_APP_EXPIRED_SESSION = 'AGENT_APP_EXPIRED_SESSION',
+
+  /**
+   * This indicates that some error occurred while trying to hydrate web chat. This will prevent web chat from
+   * functioning.
+   */
+  HYDRATION = 'HYDRATION',
+
+  /**
+   * Indicates that an attempt to load the preview link was made but security was enabled.
+   */
+  PREVIEW_LINK_SECURITY = 'PREVIEW_LINK_SECURITY',
+}
+
+/**
+ * The possible reasons that loading the web chat may fail.
+ */
+declare enum CatastrophicErrorType {
+  /**
+   * Indicates it failed for some other reason.
+   */
+  FAILED = 'FAILED',
+
+  /**
+   * Indicates it failed because there was no skill attached to the assistant.
+   */
+  NO_SKILL = 'NO_SKILL',
+
+  /**
+   * Indicates it failed because the welcome node was throttled by the service.
+   */
+  THROTTLED = 'THROTTLED',
+
+  /**
+   * The agent in the service desk waited too long to pick up the request and the session has expired so history cannot
+   * be fetched.
+   */
+  AGENT_APP_EXPIRED_SESSION = 'AGENT_APP_EXPIRED_SESSION',
+}
+interface OnErrorData {
+  /**
+   * The type of error that occurred.
+   */
+  errorType: OnErrorType;
+
+  /**
+   * A message associated with the error.
+   */
+  message: string;
+
+  /**
+   * A possible error code associated with this error. The meaning of this value may vary based on the error type.
+   */
+  errorCode?: number;
+
+  /**
+   * An optional transaction ID to associate with the error.
+   */
+  transactionID?: 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 web chat.
+   */
+  catastrophicErrorType?: CatastrophicErrorType;
+}
+interface ThemeConfig {
+  /**
+   * A string identifying what Carbon Theme we should base UI variables off of. Defaults to 'g10'. See
+   * https://carbondesignsystem.com/guidelines/color/tokens.
+   */
+  carbonTheme?: CarbonTheme;
+
+  /**
+   * This flag is used to disable web chat's rounded corners.
+   */
+  corners?: CornersType;
+}
+
+/**
+ * The type of the render function that is used to render user defined responses and chunks. This function should return a
+ * component that renders the display for the message contained in the given event.
+ *
+ * @param event The BusEventUserDefinedResponse that was originally fired by web chat when the user defined response
+ * was first fired.
+ * @param instance The current instance of the web chat.
+ */
+type RenderUserDefinedResponse = (event: BusEventUserDefinedResponse, instance: ChatInstance) => ReactNode;
+interface ChatContainerProps {
+  /**
+   * The config to use to load web chat. Note that the "onLoad" property is overridden by this component. If you
+   * need to perform any actions after web chat been loaded, use the "onBeforeRender" or "onAfterRender" props.
+   */
+  config: PublicConfig;
+
+  /**
+   * This function is called before the render function of web chat is called. This function can return a Promise
+   * which will cause web chat to wait for it before rendering.
+   */
+  onBeforeRender?: (instance: ChatInstance) => Promise<void> | void;
+
+  /**
+   * This function is called after the render function of web chat is called. This function can return a Promise
+   * which will cause web 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;
+
+  /**
+   * ReactDOM.render and createRoot can't be used together in the same application.
+   * Web chat detects if ReactDOM is React 18 or React 17, but they could be using React 18 in React 17 mode.
+   */
+  forceReact17Mode?: boolean;
+}
+
+declare function ChatContainer({
+  config,
+  onBeforeRender,
+  onAfterRender,
+  renderUserDefinedResponse,
+  forceReact17Mode,
+}: ChatContainerProps): React.JSX.Element;
+
+/**
+ * This is the React component for people injecting a web chat with a custom element.
+ *
+ * It provides said element any class or id defined on itself for styling.
+ *
+ */
+interface ChatCustomElementProps extends ChatContainerProps {
+  /**
+   * An optional classname that will be added to the custom element.
+   */
+  className?: string;
+
+  /**
+   * An optional id that will be added to the custom element.
+   */
+  id?: string;
+
+  /**
+   * 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 web 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 web 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 web chat is loaded. After web chat is loaded, the event
+   * handler will not be updated.
+   */
+  onViewChange?: (event: BusEventViewChange, instance: ChatInstance) => void;
+}
+declare function ChatCustomElement({
+  config,
+  onBeforeRender,
+  onAfterRender,
+  renderUserDefinedResponse,
+  className,
+  id,
+  onViewChange,
+}: ChatCustomElementProps): React.JSX.Element;
+
+export {
+  type AgentAppConfig,
+  type AudioItem,
+  type BaseMessageInput,
+  type BusEventAgentAreAnyAgentsOnline,
+  type BusEventAgentEndChat,
+  type BusEventAgentPreEndChat,
+  type BusEventAgentPreReceive,
+  type BusEventAgentPreSend,
+  type BusEventAgentPreSessionHistory,
+  type BusEventAgentPreStartChat,
+  type BusEventAgentReceive,
+  type BusEventAgentSend,
+  type BusEventChatReady,
+  type BusEventChunkUserDefinedResponse,
+  type BusEventClosePanelButtonClicked,
+  type BusEventCustomPanelClose,
+  type BusEventCustomPanelOpen,
+  type BusEventCustomPanelPreClose,
+  type BusEventCustomPanelPreOpen,
+  type BusEventGenesysMessengerAuthError,
+  type BusEventGenesysMessengerAuthProvider,
+  type BusEventGenesysMessengerGetAuthCode,
+  type BusEventGenesysMessengerLoggedOut,
+  type BusEventGenesysMessengerReauthenticate,
+  type BusEventHistoryBegin,
+  type BusEventHistoryEnd,
+  type BusEventMessageItemCustom,
+  type BusEventNiceDFOGetAuthCode,
+  type BusEventPreReceive,
+  type BusEventPreReset,
+  type BusEventPreSend,
+  type BusEventReceive,
+  type BusEventReset,
+  type BusEventSend,
+  type BusEventTourEnd,
+  type BusEventTourStart,
+  type BusEventTourStep,
+  BusEventType,
+  type BusEventUserDefinedResponse,
+  type BusEventViewChange,
+  type BusEventViewPreChange,
+  CarbonTheme,
+  ChatContainer,
+  type ChatContainerProps,
+  ChatCustomElement,
+  type ChatCustomElementProps,
+  type ChatInstance,
+  type Chunk,
+  type CompleteItemChunk,
+  type ConnectToAgentItem,
+  type ConversationalSearchItem,
+  type ConversationalSearchItemCitation,
+  CornersType,
+  type CustomSendMessageOptions,
+  type DateItem,
+  type DisclaimerPublicConfig,
+  type EventInput,
+  type EventInputData,
+  type FinalResponseChunk,
+  type GenericItem,
+  type HeaderConfig,
+  type HistoryItem,
+  type IFrameItem,
+  IFrameItemDisplayOption,
+  type ImageItem,
+  type ItemStreamingMetadata,
+  type LayoutConfig,
+  type MediaItem,
+  type MediaItemDimensions,
+  type MessageContext,
+  type MessageGlobalContext,
+  type MessageHistory,
+  type MessageInput,
+  MessageInputType,
+  type MessageOutput,
+  type MessageRequest,
+  type MessageResponse,
+  MessageResponseTypes,
+  type MessageSkillContext,
+  MinimizeButtonIconType,
+  type OnErrorData,
+  type Option,
+  type OptionItem,
+  OptionItemPreference,
+  type PageLinkConfig,
+  type PageLinkIDConfig,
+  type PartialItemChunk,
+  type PauseItem,
+  type PublicConfig,
+  type PublicConfigMessaging,
+  type StreamChunk,
+  type TextItem,
+  type ThemeConfig,
+  type UpdateHistoryEvent,
+  type UserDefinedItem,
+  type VideoItem,
+  type ViewState,
+  ViewType,
+};