botframework-webchat-component 4.17.1 → 4.18.1-hotfix.20260127.b53acdf

package/dist/botframework-webchat-component.d.ts

@@ -0,0 +1,2920 @@
+import * as valibot from 'valibot';
+import { InferInput } from 'valibot';
+import * as react from 'react';
+import react__default, { ReactNode, MutableRefObject, ComponentType, ChangeEvent, FocusEvent, KeyboardEvent, SyntheticEvent, Context as Context$1 } from 'react';
+import * as botframework_webchat_api from 'botframework-webchat-api';
+import { ActivityMiddleware, ActivityStatusMiddleware, AttachmentForScreenReaderMiddleware, AttachmentMiddleware, AvatarMiddleware, CardActionMiddleware, GroupActivitiesMiddleware, ScrollToEndButtonMiddleware, SendBoxMiddleware, SendBoxToolbarMiddleware, StyleOptions, ToastMiddleware, TypingIndicatorMiddleware, ComposerProps as ComposerProps$1, WebSpeechPonyfillFactory, StrictStyleOptions, WebSpeechPonyfill, hooks as hooks$1 } from 'botframework-webchat-api';
+export { concatMiddleware, localize } from 'botframework-webchat-api';
+import * as PropTypes from 'prop-types';
+import PropTypes__default from 'prop-types';
+import * as botframework_webchat_core from 'botframework-webchat-core';
+import { WebChatActivity, SendBoxAttachment } from 'botframework-webchat-core';
+export { WebChatActivity } from 'botframework-webchat-core';
+import { DecoratorMiddleware } from 'botframework-webchat-api/decorator';
+import { EmptyObject } from 'type-fest';
+
+type AttributeSetter = false | string | ((value?: string) => string);
+type LinkOptions = {
+    /** Value of "aria-label" attribute of the link. If set to `false`, remove existing attribute. */
+    ariaLabel?: AttributeSetter;
+    /** Turns this link into a <button> with "value" attribute instead of "href". */
+    asButton?: boolean;
+    /** Value of "class" attribute of the link. If set to `false`, remove existing attribute. */
+    className?: AttributeSetter;
+    /** Alternate text of the image icon appended to the link. */
+    iconAlt?: string;
+    /** Class name of the image icon appended to the link. */
+    iconClassName?: string;
+    /** Value of "rel" attribute of the link. If set to `false`, remove existing attribute. */
+    rel?: AttributeSetter;
+    /** Value of "target" attribute of the link. If set to `false`, remove existing attribute. */
+    target?: AttributeSetter;
+    /** Value of "title" attribute of the link. If set to `false`, remove existing attribute. */
+    title?: AttributeSetter;
+    /** Wraps the link with zero-width space. */
+    wrapZeroWidthSpace?: boolean;
+};
+
+declare const uploadButtonPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    className: string;
+}>]>;
+type UploadButtonProps = InferInput<typeof uploadButtonPropsSchema>;
+
+declare const dictationInterimsPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    className?: string;
+}>]>;
+type DictationInterimsProps = InferInput<typeof dictationInterimsPropsSchema>;
+
+declare const timestampPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly timestamp: valibot.UnionSchema<[valibot.DateSchema<undefined>, valibot.NumberSchema<undefined>, valibot.StringSchema<undefined>], undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    timestamp: string | number | Date;
+}>]>;
+type TimestampProps = InferInput<typeof timestampPropsSchema>;
+
+declare const speakPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly activity: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+        readonly attachments: valibot.OptionalSchema<valibot.SchemaWithPipe<readonly [valibot.ArraySchema<valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+            readonly content: valibot.OptionalSchema<valibot.AnySchema, undefined>;
+            readonly contentType: valibot.StringSchema<undefined>;
+            readonly speak: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+            readonly subtitle: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+            readonly text: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+            readonly title: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+        }, undefined>, valibot.ReadonlyAction<{
+            content?: any;
+            contentType: string;
+            speak?: string;
+            subtitle?: string;
+            text?: string;
+            title?: string;
+        }>]>, undefined>, valibot.ReadonlyAction<Readonly<{
+            content?: any;
+            contentType: string;
+            speak?: string;
+            subtitle?: string;
+            text?: string;
+            title?: string;
+        }>[]>]>, undefined>;
+        readonly channelData: valibot.OptionalSchema<valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+            readonly speechSynthesisUtterance: valibot.OptionalSchema<valibot.AnySchema, undefined>;
+        }, undefined>, valibot.ReadonlyAction<{
+            speechSynthesisUtterance?: any;
+        }>]>, undefined>;
+        readonly speak: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+        readonly text: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+        readonly type: valibot.StringSchema<undefined>;
+    }, undefined>, valibot.ReadonlyAction<{
+        attachments?: readonly Readonly<{
+            content?: any;
+            contentType: string;
+            speak?: string;
+            subtitle?: string;
+            text?: string;
+            title?: string;
+        }>[];
+        channelData?: Readonly<{
+            speechSynthesisUtterance?: any;
+        }>;
+        speak?: string;
+        text?: string;
+        type: string;
+    }>]>;
+}, undefined>, valibot.ReadonlyAction<{
+    readonly activity: Readonly<{
+        attachments?: readonly Readonly<{
+            content?: any;
+            contentType: string;
+            speak?: string;
+            subtitle?: string;
+            text?: string;
+            title?: string;
+        }>[];
+        channelData?: Readonly<{
+            speechSynthesisUtterance?: any;
+        }>;
+        speak?: string;
+        text?: string;
+        type: string;
+    }>;
+}>]>;
+type SpeakProps = InferInput<typeof speakPropsSchema>;
+
+declare const sendStatusPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly activity: valibot.AnySchema;
+    readonly sendStatus: valibot.UnionSchema<[valibot.LiteralSchema<"sending", undefined>, valibot.LiteralSchema<"send failed", undefined>, valibot.LiteralSchema<"sent", undefined>], undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    activity: any;
+    sendStatus: "send failed" | "sending" | "sent";
+}>]>;
+type SendStatusProps = InferInput<typeof sendStatusPropsSchema>;
+
+declare const errorBoxPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly error: valibot.InstanceSchema<ErrorConstructor, undefined>;
+    readonly type: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    error: Error;
+    type?: string;
+}>]>;
+type ErrorBoxProps = InferInput<typeof errorBoxPropsSchema>;
+
+declare const bubblePropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly 'aria-hidden': valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly children: valibot.OptionalSchema<valibot.CustomSchema<react__default.ReactNode, undefined>, undefined>;
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly fromUser: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly nub: valibot.OptionalSchema<valibot.UnionSchema<[valibot.BooleanSchema<undefined>, valibot.LiteralSchema<"hidden", undefined>], undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    'aria-hidden'?: boolean;
+    children?: react__default.ReactNode;
+    className?: string;
+    fromUser?: boolean;
+    nub?: boolean | "hidden";
+}>]>;
+type BubbleProps = InferInput<typeof bubblePropsSchema>;
+
+declare const avatarPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly 'aria-hidden': valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly fromUser: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    'aria-hidden'?: boolean;
+    className?: string;
+    fromUser?: boolean;
+}>]>;
+type AvatarProps = InferInput<typeof avatarPropsSchema>;
+
+declare const youTubeContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly alt: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly autoPlay: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly embedID: valibot.StringSchema<undefined>;
+    readonly loop: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    alt?: string;
+    autoPlay?: boolean;
+    embedID: string;
+    loop?: boolean;
+}>]>;
+type YouTubeContentProps = InferInput<typeof youTubeContentPropsSchema>;
+
+declare const vimeoContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly alt: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly autoPlay: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly embedID: valibot.StringSchema<undefined>;
+    readonly loop: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    alt?: string;
+    autoPlay?: boolean;
+    embedID: string;
+    loop?: boolean;
+}>]>;
+type VimeoContentProps = InferInput<typeof vimeoContentPropsSchema>;
+
+declare const videoContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly alt: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly autoPlay: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly loop: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly poster: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly src: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    alt?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    poster?: string;
+    src: string;
+}>]>;
+type VideoContentProps = InferInput<typeof videoContentPropsSchema>;
+
+declare const textContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly activity: valibot.AnySchema;
+    readonly contentType: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly text: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    activity: any;
+    contentType?: string;
+    text: string;
+}>]>;
+type TextContentProps = InferInput<typeof textContentPropsSchema>;
+
+declare const htmlVideoContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly alt: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly autoPlay: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly loop: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly poster: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly src: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    alt?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    poster?: string;
+    src: string;
+}>]>;
+type HTMLVideoContentProps = InferInput<typeof htmlVideoContentPropsSchema>;
+
+type FileContentProps = InferInput<typeof fileContentPropsSchema>;
+declare const fileContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly fileName: valibot.StringSchema<undefined>;
+    readonly href: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly size: valibot.OptionalSchema<valibot.NumberSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    className?: string;
+    fileName: string;
+    href?: string;
+    size?: number;
+}>]>;
+
+declare const audioContentPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly alt: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly autoPlay: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly loop: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, undefined>;
+    readonly poster: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly src: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    alt?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    poster?: string;
+    src: string;
+}>]>;
+type AudioContentProps = InferInput<typeof audioContentPropsSchema>;
+
+declare function useSendBoxSpeechInterimsVisible(): [boolean];
+declare const basicSendBoxPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    className?: string;
+}>]>;
+type BasicSendBoxProps = InferInput<typeof basicSendBoxPropsSchema>;
+
+type ThemeContextType = {
+    activityMiddleware: readonly ActivityMiddleware[];
+    activityStatusMiddleware: readonly ActivityStatusMiddleware[];
+    attachmentForScreenReaderMiddleware: readonly AttachmentForScreenReaderMiddleware[];
+    attachmentMiddleware: readonly AttachmentMiddleware[];
+    avatarMiddleware: readonly AvatarMiddleware[];
+    cardActionMiddleware: readonly CardActionMiddleware[];
+    groupActivitiesMiddleware: readonly GroupActivitiesMiddleware[];
+    scrollToEndButtonMiddleware: readonly ScrollToEndButtonMiddleware[];
+    sendBoxMiddleware: readonly SendBoxMiddleware[];
+    sendBoxToolbarMiddleware: readonly SendBoxToolbarMiddleware[];
+    styleOptions: StyleOptions;
+    styles: readonly (HTMLStyleElement | HTMLLinkElement)[];
+    toastMiddleware: readonly ToastMiddleware[];
+    typingIndicatorMiddleware: readonly TypingIndicatorMiddleware[];
+};
+
+type HTMLContentTransformRequest = Readonly<{
+    allowedTags: ReadonlyMap<string, Readonly<{
+        attributes: ReadonlySet<string>;
+    }>>;
+    codeBlockTagName: string;
+    documentFragment: DocumentFragment;
+    externalLinkAlt: string;
+}>;
+type HTMLContentTransformFunction = (request: HTMLContentTransformRequest) => DocumentFragment;
+type HTMLContentTransformEnhancer = (next: HTMLContentTransformFunction) => HTMLContentTransformFunction;
+type HTMLContentTransformMiddleware = () => HTMLContentTransformEnhancer;
+
+type ComposerCoreProps = Readonly<{
+    children?: ReactNode;
+    decoratorMiddleware?: readonly DecoratorMiddleware[] | undefined;
+    extraStyleSet?: any;
+    htmlContentTransformMiddleware?: readonly HTMLContentTransformMiddleware[] | undefined;
+    nonce?: string;
+    renderMarkdown?: (markdown: string, newLineOptions: {
+        markdownRespectCRLF: boolean;
+    }, linkOptions: {
+        externalLinkAlt: string;
+    }) => string;
+    styleSet?: any;
+    styles?: readonly HTMLStyleElement[];
+    suggestedActionsAccessKey?: boolean | string;
+    webSpeechPonyfillFactory?: WebSpeechPonyfillFactory;
+}>;
+type ComposerProps = ComposerProps$1 & ComposerCoreProps;
+
+type ReactWebChatProps = Readonly<Omit<ComposerProps, 'children'> & {
+    className?: string;
+    role?: 'complementary' | 'contentinfo' | 'form' | 'main' | 'region';
+}>;
+declare const ReactWebChat: {
+    ({ className, role, ...composerProps }: ReactWebChatProps): react__default.JSX.Element;
+    defaultProps: {
+        children: any;
+        extraStyleSet: any;
+        nonce: any;
+        renderMarkdown: any;
+        styleSet: any;
+        suggestedActionsAccessKey: string;
+        webSpeechPonyfillFactory: any;
+        internalRenderErrorBox: any;
+        onTelemetry: any;
+        ponyfill: any;
+        store: any;
+        className: any;
+        role: any;
+    };
+    propTypes: {
+        extraStyleSet: PropTypes__default.Requireable<any>;
+        nonce: PropTypes__default.Requireable<string>;
+        renderMarkdown: PropTypes__default.Requireable<(...args: any[]) => any>;
+        styleSet: PropTypes__default.Requireable<any>;
+        suggestedActionsAccessKey: PropTypes__default.Requireable<NonNullable<string | boolean>>;
+        webSpeechPonyfillFactory: PropTypes__default.Requireable<(...args: any[]) => any>;
+        internalRenderErrorBox: PropTypes__default.Requireable<any>;
+        onTelemetry: PropTypes__default.Requireable<(...args: any[]) => any>;
+        ponyfill: PropTypes__default.Requireable<any>;
+        store: PropTypes__default.Requireable<any>;
+        className: PropTypes__default.Requireable<string>;
+        role: PropTypes__default.Requireable<string>;
+    };
+};
+
+declare const basicWebChatPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+    readonly role: valibot.SchemaWithFallback<valibot.OptionalSchema<valibot.UnionSchema<[valibot.LiteralSchema<"complementary", undefined>, valibot.LiteralSchema<"contentinfo", undefined>, valibot.LiteralSchema<"form", undefined>, valibot.LiteralSchema<"main", undefined>, valibot.LiteralSchema<"region", undefined>], undefined>, undefined>, "complementary">;
+}, undefined>, valibot.ReadonlyAction<{
+    className?: string;
+    role?: "form" | "main" | "complementary" | "contentinfo" | "region";
+}>]>;
+type BasicWebChatProps = InferInput<typeof basicWebChatPropsSchema>;
+
+declare const sendButtonPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    className?: string;
+}>]>;
+type SendButtonProps = InferInput<typeof sendButtonPropsSchema>;
+declare function SendButton(props: SendButtonProps): react__default.JSX.Element;
+
+declare function createCoreMiddleware$2(): AttachmentMiddleware[];
+
+declare function createCoreMiddleware$1(): ActivityMiddleware[];
+
+declare function createCoreMiddleware(): ActivityStatusMiddleware[];
+
+declare function createStyleSet(styleOptions: StyleOptions): Readonly<{
+    readonly activities: {
+        margin: number;
+        padding: number;
+    };
+    readonly activityButton: {
+        '&.webchat__activity-button': {
+            alignItems: string;
+            appearance: string;
+            background: string;
+            borderRadius: string;
+            border: string;
+            color: string;
+            display: string;
+            gap: string;
+            justifyContent: string;
+            padding: string;
+            '&:hover': {
+                background: string;
+                border: string;
+                color: string;
+            };
+            '&:active': {
+                background: string;
+                border: string;
+                color: string;
+            };
+            '&:focus-visible': {
+                background: string;
+                outline: string;
+                outlineOffset: string;
+            };
+            '&[aria-disabled="true"]': {
+                background: string;
+                border: string;
+                color: string;
+                cursor: string;
+            };
+            '& .webchat__activity-button__icon': {
+                height: string;
+                width: string;
+            };
+        };
+    };
+    readonly activityCopyButton: {
+        '&.webchat__activity-copy-button': {
+            overflow: string[];
+            position: string;
+            '& .webchat__activity-copy-button__copied-text': {
+                alignItems: string;
+                backgroundColor: string;
+                display: string;
+                height: string;
+                justifyContent: string;
+                position: string;
+                visibility: string;
+                width: string;
+            };
+            '&.webchat__activity-copy-button--copied': {
+                '.webchat__activity-copy-button__copied-text': {
+                    animation: string;
+                };
+                '.webchat__activity-button__icon, .webchat__activity-button__text': {
+                    visibility: string;
+                };
+            };
+            '@keyframes webchat__activity-copy-button__copied-animation': {
+                '0%': {
+                    visibility: string;
+                };
+                '100%': {
+                    visibility: string;
+                };
+            };
+        };
+    };
+    readonly audioAttachment: {
+        display: string;
+        minHeight: "var(--webchat__size--avatar)";
+    };
+    readonly audioContent: {
+        width: string;
+    };
+    readonly autoResizeTextArea: {
+        '&.webchat__auto-resize-textarea': {
+            fontFamily: string;
+            overflow: string;
+            position: string;
+            '& .webchat__auto-resize-textarea__doppelganger': {
+                color: string;
+                height: string;
+                overflowY: string;
+                userSelect: string;
+                width: string;
+                whiteSpace: string;
+                wordBreak: string;
+            };
+            '& .webchat__auto-resize-textarea__textarea': {
+                appearance: string;
+                backgroundColor: string;
+                border: number;
+                color: string;
+                fontFamily: string;
+                fontSize: string;
+                height: string;
+                left: number;
+                margin: number;
+                outline: number;
+                overflowY: string;
+                padding: number;
+                position: string;
+                resize: string;
+                top: number;
+                width: string;
+                wordBreak: string;
+            };
+        };
+    };
+    readonly avatar: {
+        '&.webchat__defaultAvatar': {
+            borderRadius: string | number;
+            height: "var(--webchat__size--avatar)";
+            width: "var(--webchat__size--avatar)";
+        };
+    };
+    readonly basicTranscript: {
+        '&.webchat__basic-transcript': {
+            '&:focus': {
+                outline: number;
+                '& .webchat__basic-transcript__activity-indicator.webchat__basic-transcript__activity-indicator--focus': {
+                    borderColor: string;
+                    borderStyle: string;
+                    borderWidth: string | number;
+                    boxSizing: string;
+                    height: string;
+                    left: number;
+                    marginBottom: number;
+                    marginLeft: number;
+                    marginRight: number;
+                    marginTop: number;
+                    pointerEvents: string;
+                    position: string;
+                    top: number;
+                    width: string;
+                };
+            };
+            '&:focus-visible .webchat__basic-transcript__focus-indicator, .webchat__basic-transcript__terminator:focus-visible + .webchat__basic-transcript__focus-indicator': {
+                height: string;
+                borderColor: string;
+                borderStyle: string;
+                borderWidth: string | number;
+                boxSizing: string;
+                pointerEvents: string;
+                position: string;
+                top: number;
+                width: string;
+            };
+            '& .webchat__basic-transcript__activity': {
+                paddingTop: number;
+                position: string;
+                '&:first-child': {
+                    marginTop: number;
+                };
+                '&:not(:first-child)': {
+                    marginTop: number;
+                };
+            };
+            '& .webchat__basic-transcript__activity-active-descendant': {
+                height: string;
+                left: number;
+                marginTop: number;
+                paddingBottom: number;
+                pointerEvents: string;
+                position: string;
+                top: number;
+                width: string;
+            };
+            '& .webchat__basic-transcript__activity-body:not(:empty)': {
+                paddingBottom: number;
+            };
+            '& .webchat__basic-transcript__terminator': {
+                bottom: number;
+                height: number;
+                outline: number;
+                position: string;
+                width: string;
+            };
+            '& .webchat__basic-transcript__terminator-body': {
+                bottom: number;
+                display: string;
+                justifyContent: string;
+                position: string;
+                width: string;
+            };
+            '& .webchat__basic-transcript__terminator:not(:focus) .webchat__basic-transcript__terminator-body': {
+                display: string;
+            };
+            '& .webchat__basic-transcript__terminator-text': {
+                backgroundColor: string;
+                borderRadius: string | number;
+                color: string;
+                fontFamily: string;
+                fontSize: string | number;
+                margin: number;
+                padding: number;
+            };
+        };
+    };
+    readonly bubble: {
+        '&.webchat__bubble': any;
+    };
+    readonly carouselFilmStrip: {
+        '&.webchat__carousel-filmstrip': any;
+    };
+    readonly carouselFilmStripAttachment: any;
+    readonly carouselFlipper: {
+        '&.webchat__carousel-layout': {
+            '& .react-film__flipper': {
+                '& .react-film__flipper__body': {
+                    backgroundColor: string;
+                    color: string;
+                    outline: number;
+                };
+                '&:disabled, &[aria-disabled="true"]': {
+                    '& .react-film__flipper__body': {
+                        backgroundColor: string;
+                        color: string;
+                    };
+                };
+                '&:focus .react-film__flipper__body': {
+                    backgroundColor: string;
+                    color: string;
+                };
+                '&:hover .react-film__flipper__body': {
+                    backgroundColor: string;
+                    color: string;
+                };
+            };
+        };
+    };
+    readonly codeBlock: {
+        '&.webchat__code-block': {
+            background: string;
+            border: string;
+            borderRadius: string;
+            color: string;
+            display: string;
+            margin: string;
+            overflow: string;
+            padding: string;
+            ':has(> .webchat__code-block__theme--github-dark-default)': {
+                background: string;
+                color: string;
+            };
+            ':has(> .webchat__code-block__theme--github-light-default)': {
+                background: string;
+                color: string;
+            };
+            ':has(.webchat__code-block__body:focus-visible):focus-within': {
+                outline: string;
+                outlineOffset: string;
+            };
+            '.webchat__code-block__body': {
+                display: string;
+                lineHeight: string;
+                margin: string;
+                outline: string;
+                whiteSpace: string;
+            };
+        };
+    };
+    readonly codeBlockCopyButton: {
+        '&.webchat__code-block-copy-button': {
+            '--webchat__code-block-copy-button--icon-url': string;
+            alignItems: string;
+            appearance: string;
+            background: string;
+            borderRadius: string;
+            border: string;
+            color: string;
+            display: string;
+            float: string;
+            gap: string;
+            justifyContent: string;
+            marginInlineStart: "var(--webchat__padding--regular)";
+            padding: string;
+            '&:hover': {
+                background: string;
+                border: string;
+                color: string;
+            };
+            '&:active': {
+                background: string;
+                border: string;
+                color: string;
+            };
+            '&:focus-visible': {
+                background: string;
+                outline: string;
+                outlineOffset: string;
+            };
+            '&[aria-disabled="true"]': {
+                background: string;
+                border: string;
+                color: string;
+                cursor: string;
+            };
+            '&.webchat__code-block-copy-button--copied': {
+                '--webchat__code-block-copy-button--icon-url': string;
+            };
+            '& .webchat__code-block-copy-button__icon': {
+                backgroundColor: string;
+                height: string;
+                gridColumn: number;
+                gridRow: number;
+                maskImage: string;
+                maskRepeat: string;
+                WebkitMaskImage: string;
+                WebkitMaskRepeat: string;
+                width: string;
+            };
+            '& .webchat__code-block-copy-button__icon--copied': {
+                opacity: number;
+            };
+            '&.webchat__code-block-copy-button--copied .webchat__code-block-copy-button__icon': {
+                animation: string;
+            };
+            '@keyframes webchat__code-block-copy-button__copied-animation': {
+                '0%': {
+                    opacity: string;
+                };
+                '100%': {
+                    opacity: string;
+                };
+            };
+        };
+    };
+    readonly connectivityNotification: {
+        alignItems: string;
+        color: string;
+        display: string;
+        fontFamily: string;
+        fontSize: string | number;
+        marginBottom: number;
+        marginLeft: number;
+        marginRight: number;
+        marginTop: number;
+    };
+    readonly dictationInterims: {
+        fontFamily: string;
+        margin: number;
+        paddingBottom: number;
+        paddingLeft: number;
+        paddingRight: number;
+        paddingTop: number;
+        '&.dictating > span:not(:first-child), &.status': {
+            opacity: number;
+        };
+    };
+    readonly errorBox: {
+        display: string;
+        flexDirection: string;
+        fontFamily: string;
+        margin: number;
+        minHeight: number;
+        maxHeight: number;
+        overflowY: string;
+        WebkitOverflowScrolling: string;
+        '& > :first-child': {
+            backgroundColor: string;
+            color: string;
+            padding: string;
+        };
+        '& > :last-child': {
+            borderColor: string;
+            borderStyle: string;
+            borderBottomWidth: number;
+            borderLeftWidth: number;
+            borderRightWidth: number;
+            borderTopWidth: number;
+            margin: number;
+            overflowY: string;
+            padding: number;
+            '& > pre': {
+                fontFamily: string;
+                fontSize: string;
+                margin: number;
+            };
+        };
+    };
+    readonly errorNotification: {
+        alignItems: string;
+        color: string | number;
+        display: string;
+        fontFamily: string;
+        fontSize: string | number;
+        fontWeight: string;
+        marginBottom: number;
+        marginLeft: number;
+        marginRight: number;
+        marginTop: number;
+        '& > svg': {
+            fill: string | number;
+            '&:not(.webchat__error--rtl)': {
+                paddingRight: number;
+            };
+            '&.webchat__error--rtl': {
+                paddingLeft: number;
+            };
+        };
+    };
+    readonly fileContent: {
+        color: string;
+        display: string;
+        fontFamily: string;
+        padding: number;
+        '& .webchat__fileContent__badge': {
+            justifyContent: string;
+        };
+        '& .webchat__fileContent__buttonLink': {
+            alignItems: string;
+            color: string;
+            textDecoration: string;
+            '&:focus': {
+                backgroundColor: string;
+            };
+        };
+        '& .webchat__fileContent__downloadIcon': {
+            fill: string;
+            padding: number;
+            '&:not(.webchat__fileContent__downloadIcon--rtl)': {
+                marginLeft: number;
+            };
+            '&.webchat__fileContent__downloadIcon--rtl': {
+                marginRight: number;
+            };
+        };
+        '& .webchat__fileContent__fileName': {
+            color: string;
+        };
+    };
+    readonly imageAvatar: {
+        alignItems: string;
+        display: string;
+        height: "var(--webchat__size--avatar)";
+        justifyContent: string;
+        overflow: string[];
+        width: "var(--webchat__size--avatar)";
+    };
+    readonly initialsAvatar: {
+        '&.webchat__initialsAvatar': {
+            alignItems: string;
+            color: string;
+            fontFamily: "var(--webchat__font--primary)";
+            height: "var(--webchat__size--avatar)";
+            justifyContent: string;
+            overflow: string;
+            width: "var(--webchat__size--avatar)";
+            '&.webchat__initialsAvatar--fromUser': {
+                backgroundColor: string;
+            };
+            '&:not(.webchat__initialsAvatar--fromUser)': {
+                backgroundColor: string;
+            };
+        };
+    };
+    readonly microphoneButton: {
+        '&.webchat__microphone-button': {
+            '&.webchat__microphone-button--dictating .webchat__microphone-button__button': {
+                '&, &:focus, &:hover': {
+                    '& .webchat__microphone-button__icon': {
+                        fill: string;
+                    };
+                };
+            };
+        };
+    };
+    readonly monochromeImageMasker: {
+        '&.webchat__monochrome-image-masker': {
+            backgroundColor: string;
+            mask: string;
+            WebkitMask: string;
+        };
+    };
+    readonly options: {
+        readonly accent: string;
+        readonly backgroundColor: string;
+        readonly subtle: string;
+        readonly paddingRegular: number;
+        readonly paddingWide: number;
+        readonly transitionDuration: string;
+        readonly fontSizeSmall: number | string;
+        readonly monospaceFont: string;
+        readonly primaryFont: string;
+        readonly rootHeight: number | string;
+        readonly rootWidth: number | string;
+        readonly rootZIndex: number;
+        readonly avatarBorderRadius: number | string;
+        readonly avatarSize: number;
+        readonly botAvatarBackgroundColor: string;
+        readonly botAvatarImage: string;
+        readonly botAvatarInitials: string;
+        readonly userAvatarBackgroundColor: string;
+        readonly userAvatarImage: string;
+        readonly userAvatarInitials: string;
+        readonly showAvatarInGroup: true | "sender" | "status";
+        readonly bubbleBackground: string;
+        readonly bubbleBorderColor: string;
+        readonly bubbleBorderRadius: number;
+        readonly bubbleBorderStyle: string;
+        readonly bubbleBorderWidth: number;
+        readonly bubbleFromUserBackground: string;
+        readonly bubbleFromUserBorderColor: string;
+        readonly bubbleFromUserBorderRadius: number;
+        readonly bubbleFromUserBorderStyle: string;
+        readonly bubbleFromUserBorderWidth: number;
+        readonly bubbleFromUserNubOffset: number;
+        readonly bubbleFromUserNubSize: number;
+        readonly bubbleFromUserTextColor: string;
+        readonly bubbleImageMaxHeight: number | undefined;
+        readonly bubbleImageMinHeight: number | undefined;
+        readonly bubbleAttachmentMaxWidth: number | undefined;
+        readonly bubbleAttachmentMinWidth: number | undefined;
+        readonly bubbleMessageMaxWidth: number | undefined;
+        readonly bubbleMessageMinWidth: number | undefined;
+        readonly bubbleMinHeight: number;
+        readonly bubbleNubOffset: number;
+        readonly bubbleNubSize: number;
+        readonly bubbleTextColor: string;
+        readonly messageActivityWordBreak: "normal" | "break-all" | "break-word" | "keep-all";
+        readonly connectivityIconPadding: number;
+        readonly connectivityMarginLeftRight: number;
+        readonly connectivityMarginTopBottom: number;
+        readonly connectivityTextSize: number | string;
+        readonly failedConnectivity: number | string;
+        readonly slowConnectivity: string;
+        readonly notificationText: string;
+        readonly slowConnectionAfter: number;
+        readonly emojiSet: (boolean | Record<string, string>) & (false | Record<string, string>);
+        readonly internalLiveRegionFadeAfter: number;
+        readonly markdownRespectCRLF: boolean;
+        readonly markdownRenderHTML: boolean;
+        readonly markdownExternalLinkIconImage: string;
+        readonly autoScrollSnapOnActivity: boolean | number;
+        readonly autoScrollSnapOnActivityOffset: number;
+        readonly autoScrollSnapOnPage: boolean | number;
+        readonly autoScrollSnapOnPageOffset: number;
+        readonly hideSendBox: boolean;
+        readonly hideUploadButton: boolean;
+        readonly hideTelephoneKeypadButton: boolean | undefined;
+        readonly microphoneButtonColorOnDictate: string;
+        readonly sendBoxBackground: string;
+        readonly uploadAccept: string;
+        readonly uploadMultiple: boolean;
+        readonly sendAttachmentOn: "attach" | "send";
+        readonly sendBoxButtonColor: string;
+        readonly sendBoxButtonShadeBorderRadius: number;
+        readonly sendBoxButtonShadeColor: string;
+        readonly sendBoxButtonShadeInset: number;
+        readonly sendBoxButtonColorOnActive: string;
+        readonly sendBoxButtonShadeColorOnActive: string;
+        readonly sendBoxButtonColorOnDisabled: string;
+        readonly sendBoxButtonShadeColorOnDisabled: string;
+        readonly sendBoxButtonColorOnFocus: string;
+        readonly sendBoxButtonShadeColorOnFocus: string;
+        readonly sendBoxButtonColorOnHover: string;
+        readonly sendBoxButtonShadeColorOnHover: string;
+        readonly sendBoxButtonKeyboardFocusIndicatorBorderColor: string;
+        readonly sendBoxButtonKeyboardFocusIndicatorBorderRadius: number | string;
+        readonly sendBoxButtonKeyboardFocusIndicatorBorderStyle: string;
+        readonly sendBoxButtonKeyboardFocusIndicatorBorderWidth: number;
+        readonly sendBoxButtonKeyboardFocusIndicatorInset: number;
+        readonly sendBoxDisabledTextColor: string;
+        readonly sendBoxHeight: number | string;
+        readonly sendBoxMaxHeight: number | string;
+        readonly sendBoxTextColor: string;
+        readonly sendBoxBorderBottom: number | string;
+        readonly sendBoxBorderLeft: number | string;
+        readonly sendBoxBorderRight: number | string;
+        readonly sendBoxBorderTop: number | string;
+        readonly sendBoxPlaceholderColor: string;
+        readonly sendBoxTextWrap: boolean;
+        readonly sendBoxButtonAlignment: "bottom" | "stretch" | "top";
+        readonly showSpokenText: boolean;
+        readonly spinnerAnimationBackgroundImage: string;
+        readonly spinnerAnimationHeight: number | string;
+        readonly spinnerAnimationWidth: number | string;
+        readonly spinnerAnimationPadding: number | string;
+        readonly suggestedActionBorderRadius: number | string;
+        readonly suggestedActionBackground: string;
+        readonly suggestedActionBackgroundColor: string;
+        readonly suggestedActionBorderColor: string;
+        readonly suggestedActionBorderStyle: string;
+        readonly suggestedActionBorderWidth: number;
+        readonly suggestedActionTextColor: string;
+        readonly suggestedActionBackgroundColorOnDisabled: string;
+        readonly suggestedActionBorderColorOnDisabled: string;
+        readonly suggestedActionBorderStyleOnDisabled: string;
+        readonly suggestedActionBorderWidthOnDisabled: number;
+        readonly suggestedActionTextColorOnDisabled: string;
+        readonly suggestedActionBackgroundColorOnActive: string;
+        readonly suggestedActionBorderColorOnActive: string;
+        readonly suggestedActionBorderStyleOnActive: string;
+        readonly suggestedActionBorderWidthOnActive: number;
+        readonly suggestedActionTextColorOnActive: string;
+        readonly suggestedActionBackgroundColorOnFocus: string;
+        readonly suggestedActionBorderColorOnFocus: string;
+        readonly suggestedActionBorderStyleOnFocus: string;
+        readonly suggestedActionBorderWidthOnFocus: number;
+        readonly suggestedActionTextColorOnFocus: string;
+        readonly suggestedActionBackgroundColorOnHover: string;
+        readonly suggestedActionBorderColorOnHover: string;
+        readonly suggestedActionBorderStyleOnHover: string;
+        readonly suggestedActionBorderWidthOnHover: number;
+        readonly suggestedActionTextColorOnHover: string;
+        readonly suggestedActionDisabledBackground: string;
+        readonly suggestedActionDisabledBorderColor: string;
+        readonly suggestedActionDisabledBorderStyle: string;
+        readonly suggestedActionDisabledBorderWidth: number;
+        readonly suggestedActionDisabledTextColor: string;
+        readonly suggestedActionHeight: number | string;
+        readonly suggestedActionImageHeight: number | string;
+        readonly suggestedActionLayout: "carousel" | "flow" | "stacked";
+        readonly suggestedActionKeyboardFocusIndicatorBorderColor: string;
+        readonly suggestedActionKeyboardFocusIndicatorBorderRadius: number | string;
+        readonly suggestedActionKeyboardFocusIndicatorBorderStyle: string;
+        readonly suggestedActionKeyboardFocusIndicatorBorderWidth: number;
+        readonly suggestedActionKeyboardFocusIndicatorInset: number;
+        readonly suggestedActionActiveBackground: string;
+        readonly suggestedActionFocusBackground: string;
+        readonly suggestedActionHoverBackground: string;
+        readonly suggestedActionsCarouselFlipperCursor: string;
+        readonly suggestedActionsCarouselFlipperBoxWidth: number;
+        readonly suggestedActionsCarouselFlipperSize: number;
+        readonly suggestedActionsFlowMaxHeight: undefined;
+        readonly suggestedActionsStackedHeight: number | "auto";
+        readonly suggestedActionsStackedOverflow: "auto" | "hidden" | "scroll" | "visible";
+        readonly suggestedActionsStackedLayoutButtonMaxHeight: number | string;
+        readonly suggestedActionsStackedLayoutButtonTextWrap: boolean;
+        readonly suggestedActionsVisualKeyboardIndicatorColor: string;
+        readonly suggestedActionsVisualKeyboardIndicatorStyle: string;
+        readonly suggestedActionsVisualKeyboardIndicatorWidth: number;
+        readonly groupTimestamp: boolean | number;
+        readonly sendTimeout: number | ((activity: botframework_webchat_core.WebChatActivity) => number);
+        readonly sendTimeoutForAttachments: number;
+        readonly timestampColor: string;
+        readonly timestampFormat: "absolute" | "relative";
+        readonly transcriptTerminatorBackgroundColor: string;
+        readonly transcriptTerminatorBorderRadius: number | string;
+        readonly transcriptTerminatorColor: string;
+        readonly transcriptTerminatorFontSize: number | string;
+        readonly transcriptActivityVisualKeyboardIndicatorColor: string;
+        readonly transcriptActivityVisualKeyboardIndicatorStyle: string;
+        readonly transcriptActivityVisualKeyboardIndicatorWidth: number | string;
+        readonly transcriptVisualKeyboardIndicatorColor: string;
+        readonly transcriptVisualKeyboardIndicatorStyle: string;
+        readonly transcriptVisualKeyboardIndicatorWidth: number | string;
+        readonly scrollToEndButtonBehavior: false | "any" | "unread";
+        readonly scrollToEndButtonFontSize: number | string;
+        readonly transcriptOverlayButtonBackground: string;
+        readonly transcriptOverlayButtonBackgroundOnDisabled: string;
+        readonly transcriptOverlayButtonBackgroundOnFocus: string;
+        readonly transcriptOverlayButtonBackgroundOnHover: string;
+        readonly transcriptOverlayButtonColor: string;
+        readonly transcriptOverlayButtonColorOnDisabled: string;
+        readonly transcriptOverlayButtonColorOnFocus: string;
+        readonly transcriptOverlayButtonColorOnHover: string;
+        readonly notificationDebounceTimeout: number;
+        readonly hideToaster: boolean;
+        readonly toasterHeight: number | string;
+        readonly toasterMaxHeight: number | string;
+        readonly toasterSingularMaxHeight: number | string;
+        readonly toastFontSize: number | string;
+        readonly toastIconWidth: number | string;
+        readonly toastSeparatorColor: string;
+        readonly toastTextPadding: number | string;
+        readonly toastErrorBackgroundColor: string;
+        readonly toastErrorColor: string;
+        readonly toastInfoBackgroundColor: string;
+        readonly toastInfoColor: string;
+        readonly toastSuccessBackgroundColor: string;
+        readonly toastSuccessColor: string;
+        readonly toastWarnBackgroundColor: string;
+        readonly toastWarnColor: string;
+        readonly typingAnimationBackgroundImage: string;
+        readonly typingAnimationDuration: number;
+        readonly typingAnimationHeight: number | string;
+        readonly typingAnimationWidth: number | string;
+        readonly enableUploadThumbnail: boolean;
+        readonly uploadThumbnailContentType: string;
+        readonly uploadThumbnailHeight: number;
+        readonly uploadThumbnailQuality: number;
+        readonly uploadThumbnailWidth: number;
+        readonly videoHeight: number | string;
+        readonly maxMessageLength: number;
+        readonly stylesRoot: Node;
+        readonly borderAnimationColor1: string;
+        readonly borderAnimationColor2: string;
+        readonly borderAnimationColor3: string;
+        readonly codeBlockTheme: "github-light-default" | "github-dark-default";
+        readonly feedbackActionsPlacement: "activity-actions" | "activity-status";
+        readonly speechRecognitionContinuous: boolean | undefined;
+        readonly groupActivitiesBy: readonly string[] | undefined;
+    };
+    readonly root: {
+        backgroundColor: string;
+        height: string | number;
+        width: string | number;
+        zIndex: number;
+    };
+    readonly scrollToEndButton: {
+        '&.webchat__scroll-to-end-button': {
+            '@media screen and (forced-colors: active)': {
+                borderWidth: string;
+                outline: string;
+            };
+            appearance: string;
+            backgroundColor: string;
+            borderRadius: number;
+            borderWidth: number;
+            color: string;
+            fontFamily: string;
+            fontSize: string | number;
+            outline: number;
+            padding: number;
+            '&:hover': {
+                backgroundColor: string;
+                color: string;
+            };
+            '&:focus': {
+                backgroundColor: string;
+                color: string;
+            };
+        };
+    };
+    readonly sendBox: {
+        '&.webchat__send-box': {
+            '& .webchat__send-box__button--align-bottom': {
+                alignSelf: string;
+            };
+            '& .webchat__send-box__button--align-stretch': {
+                alignSelf: string;
+            };
+            '& .webchat__send-box__button--align-top': {
+                alignSelf: string;
+            };
+            '& .webchat__send-box__main': {
+                alignItems: string;
+                backgroundColor: string;
+                borderBottom: string | number;
+                borderLeft: string | number;
+                borderRight: string | number;
+                borderTop: string | number;
+                minHeight: string | number;
+            };
+        };
+    };
+    readonly sendBoxButton: {
+        '&.webchat__icon-button': {
+            alignItems: string;
+            appearance: string;
+            backgroundColor: string;
+            border: number;
+            display: string;
+            fill: string;
+            justifyContent: string;
+            outline: number;
+            padding: number;
+            position: string;
+            width: string | number;
+            '&:not(.webchat__icon-button--stretch)': {
+                height: string | number;
+            };
+            '&:disabled, &[aria-disabled="true"]': {
+                fill: string;
+                '& .webchat__icon-button__shade': {
+                    backgroundColor: string;
+                };
+            };
+            '&:not(:disabled):not([aria-disabled="true"])': {
+                '&:active': {
+                    fill: string;
+                    '& .webchat__icon-button__shade': {
+                        backgroundColor: string;
+                    };
+                };
+                '&:not(:active)': {
+                    '&:hover': {
+                        fill: string;
+                        '& .webchat__icon-button__shade': {
+                            backgroundColor: string;
+                        };
+                    };
+                    '&:not(:hover)': {
+                        '&:focus': {
+                            fill: string;
+                            '& .webchat__icon-button__shade': {
+                                backgroundColor: string;
+                            };
+                        };
+                    };
+                };
+            };
+            '&:not(:focus-visible) .webchat__icon-button__keyboard-focus-indicator': {
+                display: string;
+            };
+            '&:not(.webchat__icon-button--focus-visible) .webchat__icon-button__keyboard-focus-indicator': {
+                display: string;
+            };
+            '& > *': {
+                position: string;
+            };
+            '& .webchat__icon-button__shade': {
+                backgroundColor: string;
+                borderRadius: number;
+                bottom: number;
+                left: number;
+                position: string;
+                right: number;
+                top: number;
+            };
+            '& .webchat__icon-button__keyboard-focus-indicator': {
+                borderColor: string;
+                borderRadius: string | number;
+                borderStyle: string;
+                borderWidth: number;
+                bottom: number;
+                left: number;
+                position: string;
+                right: number;
+                top: number;
+            };
+        };
+    };
+    readonly sendBoxTextBox: {
+        '&.webchat__send-box-text-box': {
+            alignItems: string;
+            fontFamily: string;
+            padding: number;
+            position: string;
+            '& .webchat__send-box-text-box__input': {
+                border: number;
+                fontFamily: string;
+                fontSize: string;
+                height: string;
+                outline: number;
+                padding: number;
+            };
+            '& .webchat__send-box-text-box__input, & .webchat__send-box-text-box__html-text-area': {
+                backgroundColor: string;
+                '&:not(:disabled):not([aria-disabled="true"])': {
+                    color: string;
+                };
+                '&:disabled, &[aria-disabled="true"]': {
+                    color: string;
+                };
+                '&::placeholder': {
+                    color: string;
+                };
+            };
+            '& .webchat__send-box-text-box__input, & .webchat__send-box-text-box__text-area': {
+                maxHeight: string | number;
+            };
+            '& .webchat__send-box-text-box__glass': {
+                height: string;
+                left: number;
+                position: string;
+                top: number;
+                userSelect: number;
+                width: string;
+            };
+        };
+    };
+    readonly spinnerAnimation: {
+        backgroundImage: string;
+        backgroundRepeat: string;
+        backgroundSize: string;
+        height: string | number;
+        width: string | number;
+        ':not(.webchat__spinner--rtl)': {
+            marginRight: string | number;
+        };
+        '.webchat__spinner--rtl': {
+            marginLeft: string | number;
+        };
+    };
+    readonly stackedLayout: {
+        '&.webchat__stacked-layout': {
+            marginLeft: number;
+            marginRight: number;
+            '& .webchat__stacked-layout__alignment-pad': {
+                transitionDuration: string;
+                transitionProperty: string;
+                width: number;
+            };
+            '&.webchat__stacked-layout--extra-trailing .webchat__stacked-layout__alignment-pad': {
+                width: number;
+            };
+            '& .webchat__stacked-layout__avatar-gutter': {
+                transitionDuration: string;
+                transitionProperty: string;
+                width: number;
+            };
+            '& .webchat__stacked-layout__attachment': {
+                maxWidth: "var(--webchat__max-width--attachment-bubble)";
+                minWidth: "var(--webchat__min-width--attachment-bubble)";
+                transitionDuration: string;
+                transitionProperty: string;
+            };
+            '& .webchat__stacked-layout__attachment-row': {
+                marginTop: number;
+                width: string;
+            };
+            '&.webchat__stacked-layout--no-message .webchat__stacked-layout__attachment-row.webchat__stacked-layout__attachment-row--first': {
+                marginTop: number;
+            };
+            '& .webchat__stacked-layout__message': {
+                maxWidth: "var(--webchat__max-width--message-bubble)";
+                minWidth: "var(--webchat__min-width--message-bubble)";
+                overflow: string;
+                transitionDuration: string;
+                transitionProperty: string;
+            };
+            '& .webchat__stacked-layout__nub-pad': {
+                transitionDuration: string;
+                transitionProperty: string;
+                width: number;
+            };
+            '&.webchat__stacked-layout--hide-avatar, &.webchat__stacked-layout--show-avatar': {
+                '& .webchat__stacked-layout__avatar-gutter': {
+                    width: "var(--webchat__size--avatar)";
+                };
+            };
+            '&.webchat__stacked-layout--hide-avatar, &.webchat__stacked-layout--show-avatar, &.webchat__stacked-layout--hide-nub, &.webchat__stacked-layout--show-nub': {
+                '& .webchat__stacked-layout__attachment': {
+                    maxWidth: number;
+                    minWidth: number;
+                };
+                '& .webchat__stacked-layout__message': {
+                    maxWidth: number;
+                    minWidth: number;
+                };
+                '& .webchat__stacked-layout__nub-pad': {
+                    width: number;
+                };
+            };
+            '&:not(.webchat__stacked-layout--top-callout)': {
+                '& .webchat__stacked-layout__avatar-gutter, & .webchat__stacked-layout__content': {
+                    justifyContent: string;
+                };
+            };
+        };
+    };
+    readonly suggestedAction: {
+        '&.webchat__suggested-action': {
+            alignItems: string;
+            background: string;
+            backgroundColor: string;
+            borderColor: string;
+            borderRadius: string | number;
+            borderStyle: string;
+            borderWidth: number;
+            color: string;
+            fontFamily: string;
+            fontSize: string;
+            height: string | number;
+            justifyContent: string;
+            maxWidth: string;
+            outline: number;
+            paddingLeft: number;
+            paddingRight: number;
+            position: string;
+            whiteSpace: string;
+            width: string;
+            '&:disabled, &[aria-disabled="true"]': {
+                background: string;
+                backgroundColor: string;
+                borderColor: string;
+                borderStyle: string;
+                borderWidth: number;
+                color: string;
+            };
+            '&:not(:disabled):not([aria-disabled="true"])': {
+                '&:active': {
+                    background: string;
+                    backgroundColor: string;
+                    borderColor: string;
+                    borderStyle: string;
+                    borderWidth: number;
+                    color: string;
+                };
+                '&:not(:active)': {
+                    '&:hover': {
+                        background: string;
+                        backgroundColor: string;
+                        borderColor: string;
+                        borderStyle: string;
+                        borderWidth: number;
+                        color: string;
+                    };
+                    '&:not(:hover)': {
+                        '&:focus': {
+                            background: string;
+                            backgroundColor: string;
+                            borderColor: string;
+                            borderStyle: string;
+                            borderWidth: number;
+                            color: string;
+                        };
+                    };
+                };
+            };
+            '&:not(:focus-visible) .webchat__suggested-action__keyboard-focus-indicator': {
+                display: string;
+            };
+            '&:not(.webchat__suggested-action--focus-visible) .webchat__suggested-action__keyboard-focus-indicator': {
+                display: string;
+            };
+            '&:not(.webchat__suggested-action--rtl) .webchat__suggested-action__image + .webchat__suggested-action__text': {
+                paddingLeft: number;
+            };
+            '&.webchat__suggested-action--rtl .webchat__suggested-action__image + .webchat__suggested-action__text': {
+                paddingRight: number;
+            };
+            '&.webchat__suggested-action--wrapping': {
+                height: string;
+                maxHeight: string | number;
+                minHeight: string | number;
+            };
+            '& .webchat__suggested-action__image': {
+                height: string | number;
+            };
+            '& .webchat__suggested-action__keyboard-focus-indicator': {
+                borderColor: string;
+                borderRadius: string | number;
+                borderStyle: string;
+                borderWidth: number;
+                bottom: number;
+                left: number;
+                position: string;
+                right: number;
+                top: number;
+            };
+        };
+    };
+    readonly suggestedActions: {
+        '&.webchat__suggested-actions': {
+            position: string;
+            '&.webchat__suggested-actions--carousel-layout': {
+                '& .webchat__suggested-actions__carousel': {
+                    paddingBottom: number;
+                    paddingTop: number;
+                    '& .webchat__suggested-actions__item-box': {
+                        paddingBottom: number;
+                        paddingLeft: number;
+                        paddingRight: number;
+                        paddingTop: number;
+                    };
+                    '& .react-film__filmstrip': {
+                        scrollbarWidth: string;
+                    };
+                    '& .react-film__flipper': {
+                        '&:disabled, &[aria-disabled="true"]': {
+                            '& .react-film__flipper__body': {
+                                backgroundColor: string;
+                                color: string;
+                            };
+                        };
+                        '&:focus .react-film__flipper__body': {
+                            backgroundColor: string;
+                            color: string;
+                        };
+                        '&:hover .react-film__flipper__body': {
+                            backgroundColor: string;
+                            color: string;
+                        };
+                        '& .react-film__flipper__body': {
+                            background: string;
+                            color: string;
+                            outline: number;
+                        };
+                    };
+                };
+                '&:not(.webchat__suggested-actions--rtl)': {
+                    '& .react-film__filmstrip__item:first-child': {
+                        paddingLeft: number;
+                    };
+                    '& .react-film__filmstrip__item:last-child': {
+                        paddingRight: number;
+                    };
+                    '& .react-film__flipper + .react-film__filmstrip': {
+                        '& .react-film__filmstrip__item:first-child': {
+                            paddingLeft: number;
+                        };
+                        '& .react-film__filmstrip__item:last-child': {
+                            paddingRight: number;
+                        };
+                    };
+                };
+                '&.webchat__suggested-actions--rtl': {
+                    '& .react-film__filmstrip__item:first-child': {
+                        paddingRight: number;
+                    };
+                    '& .react-film__filmstrip__item:last-child': {
+                        paddingLeft: number;
+                    };
+                    '& .react-film__flipper + .react-film__filmstrip': {
+                        '& .react-film__filmstrip__item:first-child': {
+                            paddingRight: number;
+                        };
+                        '& .react-film__filmstrip__item:last-child': {
+                            paddingLeft: number;
+                        };
+                    };
+                };
+            };
+            '&.webchat__suggested-actions--flow-layout': {
+                '& .webchat__suggested-actions__flow-box': {
+                    maxHeight: undefined;
+                    overflowY: string;
+                    paddingBottom: number;
+                    paddingLeft: number;
+                    paddingRight: number;
+                    paddingTop: number;
+                };
+                '& .webchat__suggested-actions__flow-item-box': {
+                    maxWidth: string;
+                    overflow: string;
+                };
+                '& .webchat__suggested-actions__item-box': {
+                    paddingBottom: number;
+                    paddingLeft: number;
+                    paddingRight: number;
+                    paddingTop: number;
+                };
+            };
+            '&.webchat__suggested-actions--stacked-layout': {
+                '& .webchat__suggested-actions__stack': {
+                    maxHeight: number | "auto";
+                    overflowY: "visible" | "hidden" | "auto" | "scroll";
+                    paddingBottom: number;
+                    paddingLeft: number;
+                    paddingRight: number;
+                    paddingTop: number;
+                };
+                '& .webchat__suggested-actions__item-box': {
+                    paddingBottom: number;
+                    paddingLeft: number;
+                    paddingRight: number;
+                    paddingTop: number;
+                };
+            };
+            '&.webchat__suggested-actions--flow-layout, &.webchat__suggested-actions--stacked-layout': {
+                '& .webchat__suggested-actions__button-text': {
+                    overflow: string;
+                    textOverflow: string;
+                };
+                '& .webchat__suggested-actions__button-text-stacked-text-wrap': {
+                    alignItems: string;
+                    display: string;
+                    whiteSpace: string;
+                };
+            };
+            '& .webchat__suggested-actions__item-box': {
+                display: string;
+                maxWidth: string;
+            };
+            '&.webchat__suggested-actions--focus-within, &:focus-within': {
+                '& .webchat__suggested-actions__focus-indicator': {
+                    borderColor: string;
+                    borderStyle: string;
+                    borderWidth: number;
+                    boxSizing: string;
+                    height: string;
+                    pointerEvents: string;
+                    position: string;
+                    top: number;
+                    width: string;
+                };
+            };
+        };
+    };
+    readonly toast: {
+        fontFamily: string;
+        fontSize: string | number;
+        minHeight: string | number;
+        '&.webchat__toast--error': {
+            color: string;
+            fill: string;
+        };
+        '&.webchat__toast--info': {
+            color: string;
+            fill: string;
+        };
+        '&.webchat__toast--success': {
+            color: string;
+            fill: string;
+        };
+        '&.webchat__toast--warn': {
+            color: string;
+            fill: string;
+        };
+        '& .webchat__toast__iconBox': {
+            alignItems: string;
+            display: string;
+            flexShrink: number;
+            height: string | number;
+            justifyContent: string;
+            width: string | number;
+        };
+        '& .webchat__toast__dismissButton': {
+            alignItems: string;
+            appearance: string;
+            backgroundColor: string;
+            border: number;
+            display: string;
+            height: string | number;
+            justifyContent: string;
+            outline: number;
+            padding: number;
+            width: string | number;
+            '&:focus .webchat__toast__dismissButtonFocus': {
+                borderColor: string;
+            };
+            '&:hover .webchat__toast__dismissButtonFocus': {
+                backgroundColor: string;
+            };
+        };
+        '& .webchat__toast__dismissButtonFocus': {
+            alignItems: string;
+            borderColor: string;
+            borderStyle: string;
+            borderWidth: number;
+            borderRadius: number;
+            display: string;
+            height: number;
+            justifyContent: string;
+            width: number;
+        };
+        '& .webchat__toast__text': {
+            alignSelf: string;
+            paddingBottom: string | number;
+            paddingTop: string | number;
+        };
+    };
+    readonly toaster: {
+        overflowY: string;
+        '&:not(.webchat__toaster--expandable)': {
+            maxHeight: string | number;
+        };
+        '&.webchat__toaster--expandable:not(.webchat__toaster--expanded) > ul': {
+            height: number;
+        };
+        '&.webchat__toaster--expandable.webchat__toaster--expanded': {
+            maxHeight: string | number;
+        };
+        '& .webchat__toaster__header': {
+            alignItems: string;
+            alignSelf: string;
+            appearance: string;
+            backgroundColor: string;
+            border: number;
+            display: string;
+            fontFamily: string;
+            fontSize: string | number;
+            minHeight: string | number;
+            outline: number;
+            padding: number;
+            textAlign: string;
+            '&:focus .webchat__toaster__expandIconFocus': {
+                borderColor: string;
+            };
+            '&:hover .webchat__toaster__expandIconFocus': {
+                backgroundColor: string;
+            };
+        };
+        '& .webchat__toaster__expandIconFocus': {
+            alignItems: string;
+            borderColor: string;
+            borderStyle: string;
+            borderWidth: number;
+            borderRadius: number;
+            display: string;
+            height: number;
+            justifyContent: string;
+            width: number;
+        };
+        '&.webchat__toaster--error': {
+            '&:not(.webchat__toaster--expandable), & .webchat__toaster__header': {
+                backgroundColor: string;
+            };
+            '& .webchat__toaster__header': {
+                color: string;
+                fill: string;
+            };
+        };
+        '&.webchat__toaster--info': {
+            '&:not(.webchat__toaster--expandable), & .webchat__toaster__header': {
+                backgroundColor: string;
+            };
+            '& .webchat__toaster__header': {
+                color: string;
+                fill: string;
+            };
+        };
+        '&.webchat__toaster--success': {
+            '&:not(.webchat__toaster--expandable), & .webchat__toaster__header': {
+                backgroundColor: string;
+            };
+            '& .webchat__toaster__header': {
+                color: string;
+                fill: string;
+            };
+        };
+        '&.webchat__toaster--warn': {
+            '&:not(.webchat__toaster--expandable), & .webchat__toaster__header': {
+                backgroundColor: string;
+            };
+            '& .webchat__toaster__header': {
+                color: string;
+                fill: string;
+            };
+        };
+        '& .webchat__toaster__expandLevelIconBox': {
+            height: string | number;
+            width: string | number;
+        };
+        '& .webchat__toaster__expandIcon': {
+            height: string | number;
+            width: string | number;
+        };
+        '& .webchat__toaster__expandText': {
+            padding: string;
+        };
+        '& .webchat__toaster__expandLevelIconBox, & .webchat__toaster__expandIcon': {
+            alignItems: string;
+            display: string;
+            justifyContent: string;
+        };
+        '& .webchat__toaster__list': {
+            margin: number;
+            overflowY: string;
+            padding: number;
+        };
+        '& .webchat__toaster__listItem:first-child:last-child': {
+            overflow: string;
+        };
+        '& .webchat__toaster__listItem:not(:first-child), & .webchat__toaster__listItem:not(:last-child)': {
+            borderBottomColor: string;
+            borderBottomStyle: string;
+            borderBottomWidth: number;
+            minHeight: number;
+        };
+    };
+    readonly typingAnimation: {
+        backgroundImage: string;
+        backgroundRepeat: string;
+        height: string | number;
+        width: string | number;
+    };
+    readonly typingIndicator: {
+        paddingBottom: number;
+        '&:not(.webchat__typing-indicator--rtl)': {
+            paddingLeft: number;
+        };
+        '&.webchat__typing-indicator--rtl': {
+            paddingRight: number;
+        };
+    };
+    readonly uploadButton: {
+        width: string | number;
+        '& > .icon > svg': {
+            fill: string;
+        };
+        '& > input:hover + .icon > svg': {
+            fill: string;
+        };
+        '& > input:focus + .icon > svg': {
+            fill: string;
+        };
+    };
+    readonly videoAttachment: {};
+    readonly videoContent: {
+        height: string | number;
+        width: string;
+    };
+    readonly vimeoContent: {
+        border: number;
+        height: string | number;
+        width: string;
+    };
+    readonly warningNotification: {
+        alignItems: string;
+        color: string;
+        display: string;
+        fontFamily: string;
+        fontSize: string | number;
+        marginBottom: number;
+        marginLeft: number;
+        marginRight: number;
+        marginTop: number;
+        '& > svg': {
+            fill: string;
+            '&:not(webchat__warning--rtl)': {
+                paddingRight: number;
+            };
+            '&.webchat__warning--rtl': {
+                paddingLeft: number;
+            };
+        };
+    };
+    readonly youTubeContent: {
+        border: number;
+        height: string | number;
+        width: string;
+    };
+    readonly chatHistoryBox: {
+        '&.webchat__chat-history-box': {
+            display: string;
+            flex: string;
+            overflow: string[];
+            position: string;
+        };
+        '.webchat__chat-history-box__toolbar': {
+            bottom: string;
+            isolation: string;
+            position: string;
+            right: string;
+            zIndex: number;
+            '&.webchat__chat-history-box__toolbar--rtl': {
+                left: string;
+            };
+        };
+    };
+    readonly citationModalDialog: {
+        '&.webchat__citation-modal-dialog': {
+            '& .webchat__citation-modal-dialog__body': {
+                lineHeight: string;
+            };
+        };
+    };
+    readonly feedbackForm: {
+        '&.webchat__feedback-form__root-container': {
+            display: string;
+            flexDirection: string;
+            gap: string;
+            width: string;
+        };
+        '.webchat__feedback-form__root-child': {
+            display: string;
+        };
+        '.webchat__feedback-form': {
+            display: string;
+            flexDirection: string;
+            gap: string;
+            position: string;
+        };
+        '.webchat__feedback-form__body': {
+            fontFamily: "var(--webchat__font--primary)";
+            fontStyle: string;
+            fontWeight: number;
+            fontSize: string;
+            lineHeight: string;
+            color: string;
+        };
+        '.webchat__feedback-form__caption': {
+            fontFamily: "var(--webchat__font--primary)";
+            fontStyle: string;
+            fontWeight: number;
+            fontSize: string;
+            lineHeight: string;
+            color: "var(--webchat__color--subtle)";
+        };
+        '.webchat__feedback-form__container': {
+            display: string;
+            gap: string;
+            marginTop: string;
+        };
+        '.webchat__feedback-form__submit-button': {
+            backgroundColor: "var(--webchat__color--accent)";
+            border: string;
+            borderRadius: string;
+            color: string;
+            cursor: string;
+            fontSize: string;
+            fontFamily: "var(--webchat__font--primary)";
+            height: string;
+            padding: string;
+        };
+        '.webchat__feedback-form__submit-button:hover': {
+            backgroundColor: string;
+            border: string;
+            color: string;
+        };
+        '.webchat__feedback-form__submit-button:active': {
+            backgroundColor: string;
+            border: string;
+            color: string;
+        };
+        '.webchat__feedback-form__cancel-button': {
+            backgroundColor: string;
+            borderRadius: string;
+            cursor: string;
+            fontSize: string;
+            border: string;
+            color: "var(--webchat__color--subtle)";
+            fontFamily: "var(--webchat__font--primary)";
+            height: string;
+            padding: string;
+        };
+        '.webchat__feedback-form__cancel-button:hover': {
+            backgroundColor: "var(--webchat__color--subtle)";
+            color: string;
+        };
+    };
+    readonly feedbackTextArea: {
+        '&.webchat__feedback-form-text-area': {
+            display: string;
+            gridTemplateAreas: string;
+            maxHeight: string;
+            overflow: string;
+            backgroundColor: string;
+            borderRadius: string;
+            border: string;
+            fontFamily: "var(--webchat__font--primary)";
+            fontSize: string;
+            gap: string;
+            lineHeight: string;
+            padding: string;
+            position: string;
+            '&::after': {
+                borderBottomLeftRadius: string;
+                borderBottomRightRadius: string;
+                borderBottom: string;
+                bottom: string;
+                clipPath: string;
+                content: string;
+                height: string;
+                left: string;
+                position: string;
+                right: string;
+                transition: string;
+            };
+            '&:focus-within': {
+                border: string;
+            };
+            '&:focus-within::after': {
+                clipPath: string;
+                transition: string;
+            };
+        };
+        '&.webchat__feedback-form-text-area--hidden': {
+            height: number;
+            visibility: string;
+        };
+        '.webchat__feedback-form-text-area-shared': {
+            border: string;
+            font: string;
+            gridArea: string;
+            outline: string;
+            overflowWrap: string;
+            resize: string;
+            scrollbarGutter: string;
+        };
+        '.webchat__feedback-form-text-area-doppelganger': {
+            overflow: string;
+            visibility: string;
+            whiteSpace: string;
+        };
+        '.webchat__feedback-form-text-area-input': {
+            backgroundColor: string;
+            color: string;
+            height: string;
+            padding: number;
+        };
+        '.webchat__feedback-form-text-area-input--scroll': {
+            scrollbarColor: string;
+            scrollbarWidth: string;
+            MozScrollbarColor: string;
+            MozScrollbarWidth: string;
+            '&::-webkit-scrollbar': {
+                width: string;
+            };
+            '&::-webkit-scrollbar-thumb': {
+                backgroundColor: "var(--webchat__color--subtle)";
+                borderRadius: string;
+            };
+            '&::-webkit-scrollbar-corner': {
+                backgroundColor: string;
+            };
+        };
+    };
+    readonly linkDefinitions: {
+        '&.webchat__link-definitions': {
+            '.webchat__link-definitions__header': {
+                alignItems: string;
+                cursor: string;
+                display: string;
+                fontFamily: "var(--webchat__font--primary)";
+                fontSize: "var(--webchat__font-size--small)";
+                gap: number;
+                justifyContent: string;
+                listStyle: string;
+                "@media (forced-colors: none)": {
+                    color: string;
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    color: string;
+                };
+            };
+            '.webchat__link-definitions__header-section': {
+                alignItems: string;
+                display: string;
+                gap: number;
+                overflow: string;
+            };
+            '.webchat__link-definitions__header-section--left': {
+                flexShrink: number;
+            };
+            '.webchat__link-definitions__header-text': {
+                flexShrink: number;
+            };
+            '.webchat__link-definitions__header::-webkit-details-marker': {
+                display: string;
+            };
+            '.webchat__link-definitions__header-chevron': {
+                flexShrink: number;
+            };
+            '&:not([open]) .webchat__link-definitions__header-chevron': {
+                transform: string;
+            };
+            '.webchat__link-definitions__header-accessory': {
+                overflow: string;
+            };
+            '.webchat__link-definitions__message-sensitivity-label': {
+                alignItems: string;
+                display: string;
+                gap: number;
+            };
+            '.webchat__link-definitions__message-sensitivity-label-icon': {
+                color: string;
+                flexShrink: number;
+            };
+            '.webchat__link-definitions__message-sensitivity-label-text': {
+                overflow: string;
+                textOverflow: string;
+                whiteSpace: string;
+            };
+            '.webchat__link-definitions__list': {
+                display: string;
+                flexDirection: string;
+                gap: number;
+                margin: string;
+                padding: number;
+            };
+            '.webchat__link-definitions__list-item': {
+                display: string;
+                flexDirection: string;
+            };
+            '.webchat__link-definitions__badge': {
+                alignItems: string;
+                alignSelf: string;
+                borderRadius: string;
+                borderStyle: string;
+                borderWidth: number;
+                display: string;
+                flexShrink: number;
+                fontSize: string;
+                justifyContent: string;
+                margin: number;
+                minWidth: string;
+                overflow: string;
+                padding: number;
+                whiteSpace: string;
+                "@media (forced-colors: none)": {
+                    backgroundColor: string;
+                    borderColor: string;
+                    color: string;
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    backgroundColor: string;
+                    borderColor: string;
+                    color: string;
+                };
+                "@media (forced-colors: active)": {
+                    borderColor: string;
+                };
+            };
+            '.webchat__link-definitions__list-item-box': {
+                alignItems: string;
+                borderRadius: number;
+                borderStyle: string;
+                borderWidth: number;
+                "@media (forced-colors: none)": {
+                    backgroundColor: string;
+                    borderColor: string;
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    backgroundColor: string;
+                    borderColor: string;
+                };
+                "@media (forced-colors: active)": {
+                    backgroundColor: string;
+                    borderColor: string;
+                };
+            };
+            '.webchat__link-definitions__list-item-box--as-link': {
+                display: string;
+                outlineOffset: number;
+                textDecoration: string;
+            };
+            '.webchat__link-definitions__list-item-box--as-button': {
+                appearance: string;
+                background: string;
+                cursor: string;
+                fontFamily: string;
+                fontSize: string;
+                overflow: string;
+                padding: number;
+                textAlign: string;
+            };
+            '.webchat__link-definitions__list-item-body': {
+                alignItems: string;
+                display: string;
+                fontFamily: string;
+                gap: number;
+                padding: number;
+            };
+            '.webchat__link-definitions__list-item-body-main': {
+                display: string;
+                flexDirection: string;
+                gap: number;
+                overflow: string;
+            };
+            '.webchat__link-definitions__list-item-main-text': {
+                alignItems: string;
+                display: string;
+                gap: number;
+            };
+            '.webchat__link-definitions__list-item-badge, .webchat__link-definitions__list-item-text': {
+                overflow: string;
+                textOverflow: string;
+                whiteSpace: string;
+            };
+            '.webchat__link-definitions__list-item-text': {
+                textDecoration: string;
+                "@media (forced-colors: none)": {
+                    color: "var(--webchat__color--accent)";
+                };
+            };
+            '.webchat__link-definitions__list-item-badge': {
+                fontSize: "var(--webchat__font-size--small)";
+                "@media (forced-colors: none)": {
+                    color: "var(--webchat__color--subtle)";
+                };
+            };
+            '.webchat__link-definitions__open-in-new-window-icon': {
+                flexShrink: number;
+                paddingRight: number;
+                "@media (forced-colors: none)": {
+                    color: "var(--webchat__color--accent)";
+                };
+            };
+        };
+    };
+    readonly modalDialog: {
+        '&.webchat__modal-dialog': {
+            fontFamily: "var(--webchat__font--primary)";
+            maxHeight: string;
+            maxWidth: string;
+            width: string;
+            "@media (forced-colors: none)": {
+                backgroundColor: string;
+                border: number;
+            };
+            '&:has(.webchat__modal-dialog__body:empty)': {
+                opacity: number;
+            };
+            '& .webchat__modal-dialog__box': {
+                borderRadius: number;
+                overflow: string;
+                margin: string;
+                '@media screen and (max-width: 639px)': {
+                    maxWidth: string;
+                };
+                '@media screen and (min-width: 640px)': {
+                    maxWidth: string;
+                    minWidth: string;
+                    width: string;
+                };
+                "@media (forced-colors: none)": {
+                    backgroundColor: string;
+                    boxShadow: string;
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    backgroundColor: string;
+                    boxShadow: string;
+                    color: string;
+                };
+                "@media (forced-colors: active)": {
+                    outlineColor: string;
+                    outlineStyle: string;
+                    outlineWidth: number;
+                };
+            };
+            '& .webchat__modal-dialog__close-button-layout': {
+                float: string;
+                padding: "var(--webchat__padding--regular)";
+            };
+            '& .webchat__modal-dialog__close-button': {
+                height: number;
+                width: number;
+                "@media (forced-colors: none)": {
+                    appearance: string;
+                    backgroundColor: string;
+                    borderColor: string;
+                    borderRadius: number;
+                    borderStyle: string;
+                    borderWidth: number;
+                    color: string;
+                    outline: number;
+                };
+            };
+            '& .webchat__modal-dialog__close-button:focus': {
+                "@media (forced-colors: none)": {
+                    borderColor: string;
+                    '&:active': {
+                        backgroundColor: string;
+                    };
+                    '&:not(:active):hover': {
+                        backgroundColor: string;
+                    };
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    borderColor: string;
+                    '&:active': {
+                        backgroundColor: string;
+                    };
+                    '&:not(:active):hover': {
+                        backgroundColor: string;
+                    };
+                };
+            };
+            '& .webchat__modal-dialog__close-button-image': {
+                height: number;
+                width: number;
+                "@media (forced-colors: none)": {
+                    fill: string;
+                };
+                "@media (forced-colors: none) and not (forced-colors: none)": {
+                    fill: string;
+                };
+                "@media (forced-colors: active)": {
+                    fill: string;
+                };
+            };
+            '& .webchat__modal-dialog__body': {
+                margin: string;
+            };
+        };
+    };
+    readonly renderMarkdown: {
+        '&.webchat__render-markdown': {
+            display: string;
+            '&.webchat__render-markdown--adaptive-cards > *:first-child': {
+                marginTop: number;
+                width: string;
+                overflow: string;
+                textOverflow: string;
+            };
+            '&.webchat__render-markdown--adaptive-cards > *:last-child': {
+                marginBottom: number;
+            };
+            '&.webchat__render-markdown--message-activity > *:first-child': {
+                marginTop: number;
+            };
+            '&.webchat__render-markdown--message-activity > *:last-child': {
+                marginBottom: number;
+            };
+            '& .webchat__render-markdown__external-link-icon': {
+                backgroundImage: "var(--webchat__icon-url--external-link)";
+                height: string;
+                marginLeft: string;
+            };
+            '& .webchat__render-markdown__citation': {
+                background: string;
+                border: number;
+                cursor: string;
+                fontFamily: string;
+                fontSize: string;
+                padding: number;
+                textDecoration: string;
+                whiteSpace: string;
+                "@media (forced-colors: active)": {
+                    color: string;
+                };
+                "@media (forced-colors: none)": {
+                    color: "var(--webchat__color--accent)";
+                };
+            };
+            '& .webchat__render-markdown__pure-identifier': {
+                whiteSpace: string;
+            };
+            '& .webchat__render-markdown__pure-identifier::after': {
+                content: string;
+            };
+            '& .webchat__render-markdown__pure-identifier::before': {
+                content: string;
+            };
+            '& [data-math-type=block]': {
+                alignItems: string;
+                display: string;
+                flexDirection: string;
+                marginBottom: string;
+                paddingBottom: string;
+                outlineOffset: string;
+                overflowX: string;
+                overflowY: string;
+                scrollbarWidth: string;
+            };
+            '& span[data-math-type=block]': {
+                display: string;
+            };
+            '& [data-math-type=inline]': {
+                alignItems: string;
+                display: string;
+                flexDirection: string;
+            };
+            '& :is([data-math-type=block], [data-math-type=inline]) > span': {
+                display: string;
+            };
+        };
+    };
+    readonly sendStatus: {
+        '&.webchat__activity-status': {
+            color: "var(--webchat__color--timestamp)";
+            fontFamily: "var(--webchat__font--primary)";
+            fontSize: "var(--webchat__font-size--small)";
+            marginTop: string;
+        };
+        '&.webchat__activity-status--slotted': {
+            display: string;
+            gap: number;
+        };
+        '& .webchat__activity-status-slot': {
+            display: string;
+            '&:not(:first-child)::before': {
+                content: string;
+            };
+            '&:empty': {
+                display: string;
+            };
+        };
+        '& .webchat__activity-status__originator': {
+            alignItems: string;
+            '&.webchat__activity-status__originator--has-link': {
+                color: "var(--webchat__color--accent)";
+            };
+        };
+    };
+    readonly textContent: {
+        '&.webchat__text-content': {
+            fontFamily: "var(--webchat__font--primary)";
+            margin: number;
+            minHeight: string;
+            padding: "var(--webchat__padding--regular)";
+            '&.webchat__text-content--is-markdown': {
+                display: string;
+                flexDirection: string;
+                gap: "var(--webchat__padding--regular)";
+            };
+            '& .webchat__text-content__markdown img:not(.webchat__render-markdown__external-link-icon)': {
+                maxWidth: "var(--webchat__max-width--message-bubble)";
+                minWidth: "var(--webchat__min-width--message-bubble)";
+                width: string;
+            };
+            '& .webchat__text-content__markdown pre': {
+                overflow: string;
+            };
+            '& .webchat__text-content__open-in-new-window-icon': {
+                height: string;
+            };
+            '& .webchat__text-content__activity-actions': {
+                alignSelf: string;
+                display: string;
+                gap: string;
+                width: string;
+            };
+            '& .webchat__text-content__activity-actions:empty': {
+                display: string;
+            };
+        };
+    };
+    readonly thumbButton: {
+        '&.webchat__thumb-button': {
+            alignItems: string;
+            appearance: string;
+            background: string;
+            border: number;
+            borderRadius: number;
+            boxSizing: string;
+            display: string;
+            gridTemplateAreas: string;
+            height: number;
+            justifyContent: string;
+            padding: number;
+            width: number;
+            '&.webchat__thumb-button--large': {
+                border: string;
+                borderRadius: string;
+                height: string;
+                padding: string;
+                width: string;
+                '& .webchat__thumb-button__image': {
+                    color: string;
+                    fontSize: string;
+                    height: string;
+                    width: string;
+                };
+                '&:hover, &:active, &.webchat__thumb-button--is-pressed': {
+                    background: string;
+                    color: "var(--webchat__color--accent)";
+                };
+                '&[aria-disabled="true"]': {
+                    color: "var(--webchat__color--subtle)";
+                };
+                '&.webchat__thumb-button--submitted:not(.webchat__thumb-button--is-pressed) .webchat__tooltip': {
+                    display: string;
+                };
+                '&.webchat__thumb-button--submitted .webchat__tooltip': {
+                    '--webchat__tooltip-anchor-inline-start': string;
+                };
+            };
+            '&:active': {
+                background: string;
+            };
+            '&:focus-visible': {
+                outline: string;
+            };
+            '& .webchat__thumb-button__image': {
+                color: "var(--webchat__color--accent)";
+                gridArea: string;
+                visibility: string;
+                width: number;
+                '&.webchat__thumb-button__image--is-stroked': {
+                    visibility: string;
+                };
+            };
+            '&:not([aria-disabled="true"]):hover, &.webchat__thumb-button--is-pressed': {
+                '& .webchat__thumb-button__image': {
+                    '&.webchat__thumb-button__image--is-stroked': {
+                        visibility: string;
+                    };
+                    '&.webchat__thumb-button__image--is-filled': {
+                        visibility: string;
+                    };
+                };
+            };
+        };
+    };
+    readonly tooltip: {
+        '*:has(> &.webchat__tooltip)': {
+            position: string;
+            '&:is(:hover, :focus-visible, :active) > .webchat__tooltip': {
+                opacity: number;
+                transitionDelay: string;
+            };
+        };
+        '&.webchat__tooltip': {
+            '--webchat__tooltip-tip-size': string;
+            '--webchat__tooltip-background': string;
+            '--webchat__tooltip-anchor-inline-start': string;
+            background: string;
+            borderRadius: string;
+            color: string;
+            filter: string;
+            fontSize: string;
+            inlineSize: string;
+            isolation: string;
+            lineHeight: string;
+            margin: number;
+            maxInlineSize: string;
+            opacity: number;
+            padding: string;
+            pointerEvents: string;
+            position: string;
+            textAlign: string;
+            transition: string;
+            userSelect: string;
+            willChange: string;
+            '&::after': {
+                background: string;
+                color: string;
+                content: string;
+                inset: number;
+                position: string;
+            };
+            '&.webchat__tooltip--block-start, &.webchat__tooltip--block-end': {
+                textAlign: string;
+            };
+            '&.webchat__tooltip--block-start': {
+                insetBlockEnd: string;
+                insetInlineStart: string;
+                transform: string;
+                '&::after': {
+                    border: string;
+                    borderBottomLeftRadius: string;
+                    clipPath: string;
+                    height: string;
+                    insetBlockStart: string;
+                    insetInlineStart: string;
+                    transform: string;
+                    width: string;
+                };
+            };
+        };
+    };
+    readonly viewCodeDialog: {
+        '&.webchat__view-code-dialog': {
+            boxSizing: string;
+            display: string;
+            height: string;
+            maxHeight: string;
+            overflow: string;
+            padding: string;
+            placeItems: string;
+            '& .webchat__modal-dialog__box': {
+                display: string;
+                flexDirection: string;
+                maxHeight: string;
+                maxWidth: string;
+                position: string;
+            };
+            '& .webchat__modal-dialog__close-button-layout': {
+                position: string;
+                right: number;
+            };
+            '& .webchat__modal-dialog__body': {
+                display: string;
+                flexDirection: string;
+                gap: "var(--webchat__padding--regular)";
+                overflow: string;
+            };
+            '& .webchat__view-code-dialog__header': {
+                alignItems: string;
+                display: string;
+                paddingInlineEnd: string;
+            };
+            '& .webchat__view-code-dialog__title': {
+                margin: string;
+                textTransform: string;
+            };
+            '& .webchat__view-code-dialog__body': {
+                border: string;
+                borderRadius: number;
+                overflow: string;
+                height: string;
+                '.webchat__code-block__body': {
+                    display: string;
+                    margin: number;
+                    padding: string;
+                };
+            };
+            '& .webchat__view-code-dialog__footer': {
+                color: "var(--webchat__color--subtle)";
+                lineHeight: string;
+            };
+            '& .webchat__view-code-dialog__copy-button': {
+                position: string;
+                right: string;
+                top: string;
+            };
+        };
+    };
+}>;
+
+declare function getTabIndex(element: HTMLElement): number | null;
+
+type WaitUntilable<T> = T & {
+    waitUntil: (promise: Promise<void>) => void;
+};
+
+type FocusTranscriptInit = WaitUntilable<EmptyObject>;
+
+type ContextType = {
+    focusTranscriptCallbacksRef: MutableRefObject<((init: FocusTranscriptInit) => Promise<void>)[]>;
+};
+declare const context: react.Context<ContextType>;
+
+declare function useTransformHTMLContent(): (documentFragment: DocumentFragment) => DocumentFragment;
+
+declare const testIds: {
+    codeBlockCopyButton: string;
+    copyButton: string;
+    sendBoxSpeechBox: string;
+    sendBoxTextBox: string;
+    typingIndicator: string;
+    viewCodeButton: string;
+    feedbackSendBox: string;
+};
+
+type InputTargetProps<H> = {
+    onChange?: (event: ChangeEvent<H>) => void;
+    onFocus?: (event: FocusEvent<H>) => void;
+    onKeyDown?: (event: KeyboardEvent<H>) => void;
+    onSelect?: (event: SyntheticEvent<H>) => void;
+    value?: string;
+};
+type PropsOf<T> = T extends ComponentType<infer P> ? P : never;
+declare function withEmoji<T extends ComponentType<P>, P extends InputTargetProps<H> = PropsOf<T>, H extends HTMLInputElement | HTMLTextAreaElement = P extends InputTargetProps<infer H> ? H : never>(componentType: T): react__default.ForwardRefExoticComponent<react__default.PropsWithoutRef<Readonly<Omit<P, "onChange" | "emojiMap"> & {
+    emojiMap?: Map<string, string>;
+    onChange?: (value: string | undefined) => void;
+}>> & react__default.RefAttributes<H>>;
+
+type ContextOf<T extends Context$1<unknown>> = T extends Context$1<infer C> ? C : never;
+
+declare const Context: react.Context<Readonly<{
+    shouldReduceMotionState: readonly [boolean];
+}>>;
+
+declare function useContext(): ContextOf<typeof Context>;
+
+declare function useShouldReduceMotion(): ReturnType<typeof useContext>['shouldReduceMotionState'];
+
+declare function useDictateAbortable(): [boolean];
+
+declare function useFocus(): (where?: 'main' | 'sendBox' | 'sendBoxWithoutKeyboard') => Promise<void>;
+
+declare function useMakeThumbnail(): (file: File, contentType?: string | undefined) => Promise<undefined | URL>;
+
+type ScrollPosition = {
+    activityID?: string;
+    scrollTop: number;
+};
+
+declare function useObserveScrollPosition(observer: (scrollPosition: ScrollPosition) => void, deps: any[]): void;
+
+declare function useObserveTranscriptFocus(observer: (event: {
+    activity: WebChatActivity;
+}) => void, deps: any[]): void;
+
+declare function useRenderMarkdownAsHTML(mode?: 'accessible name' | 'adaptive cards' | 'citation modal' | 'message activity'): ((markdown: string, styleOptions?: Readonly<StrictStyleOptions>, options?: Readonly<{
+    externalLinkAlt: string;
+}>) => string) | undefined;
+
+declare function useScrollDown(): (options?: {
+    displacement: number;
+}) => void;
+
+declare function useScrollTo(): (position: ScrollPosition, scrollToOptions: {
+    behavior?: 'auto' | 'smooth';
+}) => void;
+
+declare function useScrollToEnd(): () => void;
+
+declare function useScrollUp(): (options?: {
+    displacement: number;
+}) => void;
+
+/**
+ * @deprecated This hook will be removed on or after 2026-04-03. Please use `useSendMessage` instead.
+ */
+declare function useSendFiles(): (files: readonly File[]) => void;
+
+type SendMessage = (text?: string, method?: string, init?: {
+    attachments?: Iterable<SendBoxAttachment> | undefined;
+    channelData?: any;
+}) => void;
+declare function useSendMessage(): SendMessage;
+
+declare function useStyleSet(): readonly [Record<keyof ReturnType<typeof createStyleSet>, any>];
+
+declare function useWebSpeechPonyfill(): [WebSpeechPonyfill];
+
+declare function useTypingIndicatorVisible(): readonly [boolean];
+
+declare function useMicrophoneButtonClick(): () => void;
+declare function useMicrophoneButtonDisabled(): [boolean];
+
+/**
+ * Submits the text box and optionally set the focus after send.
+ */
+type SubmitTextBoxFunction = {
+    /**
+     * Submits the text box, without setting the focus after send.
+     *
+     * @deprecated Instead of passing `false`, you should leave the `setFocus` argument `undefined`.
+     */
+    (setFocus: false): void;
+    /**
+     * Submits the text box and optionally set the focus after send.
+     */
+    (setFocus?: 'sendBox' | 'sendBoxWithoutKeyboard'): void;
+};
+declare function useTextBoxSubmit(): SubmitTextBoxFunction;
+declare function useTextBoxValue(): [string, (textBoxValue: string) => void];
+
+type SendBoxFocusOptions = WaitUntilable<{
+    noKeyboard: boolean;
+}>;
+
+declare const hooks: {
+    useDictateAbortable: typeof useDictateAbortable;
+    useFocus: typeof useFocus;
+    useMakeThumbnail: typeof useMakeThumbnail;
+    useMicrophoneButtonClick: typeof useMicrophoneButtonClick;
+    useMicrophoneButtonDisabled: typeof useMicrophoneButtonDisabled;
+    useObserveScrollPosition: typeof useObserveScrollPosition;
+    useObserveTranscriptFocus: typeof useObserveTranscriptFocus;
+    useRegisterFocusSendBox: (listener: (value: SendBoxFocusOptions) => void) => void;
+    useRenderMarkdownAsHTML: typeof useRenderMarkdownAsHTML;
+    useScrollDown: typeof useScrollDown;
+    useScrollTo: typeof useScrollTo;
+    useScrollToEnd: typeof useScrollToEnd;
+    useScrollUp: typeof useScrollUp;
+    useSendBoxSpeechInterimsVisible: typeof useSendBoxSpeechInterimsVisible;
+    useSendFiles: typeof useSendFiles;
+    useSendMessage: typeof useSendMessage;
+    useShouldReduceMotion: typeof useShouldReduceMotion;
+    useStyleSet: typeof useStyleSet;
+    useTextBoxSubmit: typeof useTextBoxSubmit;
+    useTextBoxValue: typeof useTextBoxValue;
+    useTransformHTMLContent: typeof useTransformHTMLContent;
+    useTypingIndicatorVisible: typeof useTypingIndicatorVisible;
+    useWebSpeechPonyfill: typeof useWebSpeechPonyfill;
+    useActiveTyping: (expireAfter?: number) => readonly [Readonly<Record<string, botframework_webchat_api.Typing>>];
+    useActivities: () => [WebChatActivity[]];
+    useActivityKeys: () => readonly [readonly string[]];
+    useActivityKeysByRead: () => readonly [readonly string[], readonly string[]];
+    useAvatarForBot: () => [{
+        image: string;
+        initials: string;
+    }];
+    useAvatarForUser: () => [{
+        image: string;
+        initials: string;
+    }];
+    useByteFormatter: () => (bytes: number) => string;
+    useConnectivityStatus: () => [string];
+    useCreateActivityRenderer: () => botframework_webchat_api.ActivityComponentFactory;
+    useCreateActivityStatusRenderer: () => botframework_webchat_api.ActivityStatusRenderer;
+    useCreateAttachmentForScreenReaderRenderer: () => botframework_webchat_api.AttachmentForScreenReaderComponentFactory;
+    useCreateAvatarRenderer: () => ({ activity }: {
+        activity: WebChatActivity;
+    }) => false | (() => Exclude<react.ReactNode, boolean | null | undefined>);
+    useCreateScrollToEndButtonRenderer: () => botframework_webchat_api.ScrollToEndButtonComponentFactory;
+    useDateFormatter: () => (date: Date | number | string) => string;
+    useDebouncedNotifications: () => [botframework_webchat_api.DebouncedNotifications];
+    useDictateInterims: () => [string[], (interims: string[]) => void];
+    useDictateState: () => [number];
+    useDirection: () => ["auto" | "ltr" | "rtl"];
+    useDisabled: () => readonly [boolean];
+    useDismissNotification: () => (id: string) => void;
+    useEmitTypingIndicator: () => () => void;
+    useGetActivitiesByKey: () => (key?: string) => readonly WebChatActivity[] | undefined;
+    useGetActivityByKey: () => (key?: string) => undefined | WebChatActivity;
+    useGetHasAcknowledgedByActivityKey: typeof hooks$1.useGetHasAcknowledgedByActivityKey;
+    useGetKeyByActivity: () => (activity?: WebChatActivity) => string | undefined;
+    useGetKeyByActivityId: () => (activityId?: string) => string | undefined;
+    useGetSendTimeoutForActivity: () => ({ activity }: {
+        activity: WebChatActivity;
+    }) => number;
+    useGrammars: () => [any];
+    useGroupActivities: () => ({ activities }: Readonly<{
+        activities: readonly WebChatActivity[];
+    }>) => Readonly<{
+        [key: string]: readonly (readonly WebChatActivity[])[];
+    }>;
+    useGroupActivitiesByName: typeof hooks$1.useGroupActivitiesByName;
+    useGroupTimestamp: () => [boolean | number];
+    useLanguage: (options?: "speech") => [string];
+    useLastAcknowledgedActivityKey: () => readonly [string];
+    useLastReadActivityKey: () => readonly [string | undefined];
+    useLocalizer: ({ plural }?: {
+        plural?: boolean;
+    }) => (id: string | {
+        zero?: string;
+        one?: string;
+        two?: string;
+        few?: string;
+        many?: string;
+        other: string;
+    }, args_0?: string | number, ...args: string[]) => any;
+    useMarkActivityAsSpoken: () => (activity: WebChatActivity) => void;
+    useMarkActivityKeyAsRead: () => (activityKey: string) => void;
+    useMarkAllAsAcknowledged: () => () => void;
+    useNotifications: () => [botframework_webchat_api.Notification[]];
+    usePerformCardAction: () => botframework_webchat_api.PerformCardAction;
+    usePonyfill: () => readonly [botframework_webchat_core.GlobalScopePonyfill];
+    usePostActivity: () => (activity: WebChatActivity) => botframework_webchat_core.Observable<string>;
+    useReferenceGrammarID: () => [string];
+    useRelativeTimeFormatter: () => (dateOrString: Date | string) => string;
+    useRenderAttachment: () => botframework_webchat_api.RenderAttachment | undefined;
+    useRenderToast: () => botframework_webchat_api.RenderToast;
+    useRenderTypingIndicator: () => botframework_webchat_api.RenderTypingIndicator;
+    useSendBoxAttachments: () => readonly [readonly botframework_webchat_core.SendBoxAttachment[], (attachments: readonly botframework_webchat_core.SendBoxAttachment[]) => void];
+    useSendBoxValue: () => [string, (value: string) => void];
+    useSendEvent: () => (name: string, value: any) => void;
+    useSendMessageBack: () => (value: any, text?: string, displayText?: string) => void;
+    useSendPostBack: () => (value?: any) => void;
+    useSendStatusByActivityKey: typeof hooks$1.useSendStatusByActivityKey;
+    useSendTimeoutForActivity: (activity: WebChatActivity) => number;
+    useSendTypingIndicator: () => [boolean];
+    useSetNotification: () => (notification: botframework_webchat_api.Notification) => void;
+    useShouldSpeakIncomingActivity: () => [boolean, (value: boolean) => void];
+    useStartDictate: () => () => void;
+    useStopDictate: () => () => void;
+    useStyleOptions: () => [botframework_webchat_api.StrictStyleOptions];
+    useSubmitSendBox: () => (method?: string, { channelData }?: {
+        channelData: any;
+    }) => void;
+    useSuggestedActions: () => [botframework_webchat_core.DirectLineCardAction[], (suggestedActions: never[]) => void, extras: {
+        activity: WebChatActivity;
+    }];
+    useTimeoutForSend: () => [number | ((activity: WebChatActivity) => number)];
+    useTrackDimension: () => (name: string, data: any) => void;
+    useTrackEvent: () => {
+        (name: string, data: any): void;
+        debug: (name: string, data: any) => void;
+        error: (name: string, data: any) => void;
+        info: (name: string, data: any) => void;
+        warn: (name: string, data: any) => void;
+    };
+    useTrackException: () => (error: Error, fatal: boolean) => void;
+    useTrackTiming: <T>() => (name: string, functionOrPromise: (() => T) | Promise<T>) => Promise<T>;
+    useUIState: () => readonly ["blueprint" | "disabled" | undefined];
+    useUserID: () => [string];
+    useUsername: () => [string];
+    useVoiceSelector: (activity: any) => (voices: (typeof window.SpeechSynthesisVoice)[]) => typeof window.SpeechSynthesisVoice;
+};
+declare const version: string;
+declare const buildInfo: {
+    buildTool: string;
+    moduleFormat: string;
+    version: string;
+};
+declare const Components: {
+    BasicWebChat: react.MemoExoticComponent<(props: BasicWebChatProps) => react.JSX.Element>;
+    Composer: {
+        ({ activityMiddleware, activityStatusMiddleware, attachmentForScreenReaderMiddleware, attachmentMiddleware, avatarMiddleware, cardActionMiddleware, children, decoratorMiddleware, extraStyleSet, htmlContentTransformMiddleware, renderMarkdown, scrollToEndButtonMiddleware, sendBoxMiddleware: sendBoxMiddlewareFromProps, sendBoxToolbarMiddleware: sendBoxToolbarMiddlewareFromProps, styleOptions, styleSet, suggestedActionsAccessKey, toastMiddleware, typingIndicatorMiddleware, webSpeechPonyfillFactory, ...composerProps }: ComposerProps): react.JSX.Element;
+        defaultProps: {
+            children: any;
+            extraStyleSet: any;
+            nonce: any;
+            renderMarkdown: any;
+            styleSet: any;
+            suggestedActionsAccessKey: string;
+            webSpeechPonyfillFactory: any;
+            internalRenderErrorBox: any;
+            onTelemetry: any;
+            ponyfill: any;
+            store: any;
+        };
+        propTypes: {
+            children: PropTypes.Requireable<any>;
+            extraStyleSet: PropTypes.Requireable<any>;
+            nonce: PropTypes.Requireable<string>;
+            renderMarkdown: PropTypes.Requireable<(...args: any[]) => any>;
+            styleSet: PropTypes.Requireable<any>;
+            suggestedActionsAccessKey: PropTypes.Requireable<NonNullable<string | boolean>>;
+            webSpeechPonyfillFactory: PropTypes.Requireable<(...args: any[]) => any>;
+            internalRenderErrorBox: PropTypes.Requireable<any>;
+            onTelemetry: PropTypes.Requireable<(...args: any[]) => any>;
+            ponyfill: PropTypes.Requireable<any>;
+            store: PropTypes.Requireable<any>;
+        };
+    };
+    ThemeProvider: react.MemoExoticComponent<({ activityMiddleware, activityStatusMiddleware, attachmentForScreenReaderMiddleware, attachmentMiddleware, avatarMiddleware, cardActionMiddleware, children, groupActivitiesMiddleware, scrollToEndButtonMiddleware, sendBoxMiddleware, sendBoxToolbarMiddleware, styleOptions, styles, toastMiddleware, typingIndicatorMiddleware }: Readonly<{
+        children?: react.ReactNode | undefined;
+    } & Partial<ThemeContextType>>) => react.JSX.Element>;
+    AccessKeySinkSurface: any;
+    BasicConnectivityStatus: any;
+    BasicSendBox: react.MemoExoticComponent<(props: BasicSendBoxProps) => react.JSX.Element>;
+    BasicSendBoxToolbar: react.MemoExoticComponent<({ className }: botframework_webchat_api.SendBoxToolbarMiddlewareProps) => react.JSX.Element>;
+    BasicToaster: any;
+    BasicTranscript: react.ComponentType<{
+        readonly className: string;
+        ref?: react.Ref<never>;
+        key?: react.Key | null | undefined;
+    }>;
+    AudioContent: react.MemoExoticComponent<(props: AudioContentProps) => react.JSX.Element>;
+    FileContent: react.MemoExoticComponent<(props: FileContentProps) => react.JSX.Element>;
+    HTMLVideoContent: react.MemoExoticComponent<(props: HTMLVideoContentProps) => react.JSX.Element>;
+    ImageContent: react.MemoExoticComponent<({ alt, src }: Readonly<{
+        alt?: string;
+        src: string;
+    }>) => react.JSX.Element>;
+    TextContent: react.MemoExoticComponent<(props: TextContentProps) => react.JSX.Element>;
+    VideoContent: react.MemoExoticComponent<(props: VideoContentProps) => react.JSX.Element>;
+    VimeoContent: react.MemoExoticComponent<(props: VimeoContentProps) => react.JSX.Element>;
+    YouTubeContent: react.MemoExoticComponent<(props: YouTubeContentProps) => react.JSX.Element>;
+    Avatar: react.MemoExoticComponent<(props: AvatarProps) => react.JSX.Element>;
+    Bubble: react.MemoExoticComponent<(props: BubbleProps) => react.JSX.Element>;
+    ErrorBox: react.MemoExoticComponent<(props: ErrorBoxProps) => react.JSX.Element>;
+    SendStatus: react.MemoExoticComponent<(props: SendStatusProps) => react.JSX.Element>;
+    SpeakActivity: react.MemoExoticComponent<(props: SpeakProps) => react.JSX.Element>;
+    Timestamp: react.MemoExoticComponent<(props: TimestampProps) => react.JSX.Element>;
+    DictationInterims: react.MemoExoticComponent<(props: DictationInterimsProps) => react.JSX.Element>;
+    MicrophoneButton: react.MemoExoticComponent<{
+        ({ className }: Readonly<{
+            className?: string | undefined;
+        }>): react.JSX.Element;
+        displayName: string;
+    }>;
+    SendButton: typeof SendButton;
+    SendTextBox: ({ className }: Readonly<{
+        className?: string | undefined;
+    }>) => react.JSX.Element;
+    SuggestedActions: ({ className }: Readonly<{
+        className?: string;
+    }>) => react.JSX.Element;
+    UploadButton: react.MemoExoticComponent<(props: UploadButtonProps) => react.JSX.Element>;
+    LocalizedString: react.MemoExoticComponent<(props: Readonly<{
+        className?: string | undefined;
+        linkClassName?: string | undefined;
+        onDecorateLink?: ((href: string, textContent: string) => LinkOptions | undefined) | undefined;
+    }> & (Readonly<{
+        stringIds: {
+            zero?: string;
+            one?: string;
+            two?: string;
+            few?: string;
+            many?: string;
+            other: string;
+        };
+        values: readonly [number, ...(number | string)[]] | undefined;
+    }> | Readonly<{
+        stringIds: string;
+        values?: readonly (number | string)[] | undefined;
+    }>)) => react.JSX.Element>;
+    MonochromeImageMasker: react.MemoExoticComponent<{
+        ({ className, src }: Readonly<{
+            className?: string | undefined;
+            src: string;
+        }>): react.JSX.Element;
+        displayName: string;
+    }>;
+};
+
+export { type BasicWebChatProps, Components, type ComposerProps, context as Context, type HTMLContentTransformEnhancer, type HTMLContentTransformFunction, type HTMLContentTransformMiddleware, type HTMLContentTransformRequest, type ReactWebChatProps, type SendBoxFocusOptions, buildInfo, createCoreMiddleware$1 as createCoreActivityMiddleware, createCoreMiddleware as createCoreActivityStatusMiddleware, createCoreMiddleware$2 as createCoreAttachmentMiddleware, createStyleSet, ReactWebChat as default, getTabIndex, hooks, testIds, version, withEmoji };