import { SendBoxToolbarMiddlewareProps, ComposerProps as ComposerProps$1, WebSpeechPonyfillFactory, ActivityMiddleware, ActivityStatusMiddleware, AttachmentForScreenReaderMiddleware, AttachmentMiddleware, AvatarMiddleware, CardActionMiddleware, GroupActivitiesMiddleware, ScrollToEndButtonMiddleware, SendBoxMiddleware, SendBoxToolbarMiddleware, ToastMiddleware, TypingIndicatorMiddleware } from 'botframework-webchat-api';
import { DecoratorMiddleware } from 'botframework-webchat-api/decorator.js';
import { StoreDebugAPI } from 'botframework-webchat-core/internal.js';
import PropTypes from 'prop-types';
import React__default__default, { ReactNode } from 'react';
import * as valibot from 'valibot';
import { InferInput } from 'valibot';
import { _ as _default$1$1, a as _default$m, T as TextBox } from './TextBox-BEU2rUID.js';
import { Polymiddleware } from 'botframework-webchat-api/middleware.js';

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;
    storeDebugAPI?: StoreDebugAPI | undefined;
    styleSet?: any;
    suggestedActionsAccessKey?: boolean | string;
    webSpeechPonyfillFactory?: WebSpeechPonyfillFactory;
}>;
type ComposerProps = ComposerProps$1 & ComposerCoreProps;
declare const Composer: {
    ({ activityMiddleware, activityStatusMiddleware, attachmentForScreenReaderMiddleware, attachmentMiddleware, avatarMiddleware, cardActionMiddleware, children, decoratorMiddleware, extraStyleSet, htmlContentTransformMiddleware, polymiddleware, renderMarkdown, scrollToEndButtonMiddleware, sendBoxMiddleware: sendBoxMiddlewareFromProps, sendBoxToolbarMiddleware: sendBoxToolbarMiddlewareFromProps, styleOptions, styleSet, suggestedActionsAccessKey, toastMiddleware, typingIndicatorMiddleware, webSpeechPonyfillFactory, ...composerProps }: ComposerProps): React__default__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;
    };
    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>;
    };
};

type ReactWebChatProps = Readonly<Omit<ComposerProps, 'children'> & {
    className?: string | undefined;
    role?: string | undefined;
}>;
declare const ReactWebChat: {
    ({ className, role, ...composerProps }: ReactWebChatProps): React__default__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.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>;
        className: PropTypes.Requireable<string>;
        role: PropTypes.Requireable<string>;
    };
};

declare function BasicConnectivityStatus({ className }: {
    className: any;
}): React__default__default.JSX.Element;

declare const _default$l: React__default__default.MemoExoticComponent<{
    ({ className }: {
        className: any;
    }): React__default__default.JSX.Element;
    displayName: string;
}>;

declare const _default$k: React__default__default.ComponentType<{
    readonly className: string;
    ref?: React__default__default.Ref<never>;
    key?: React__default__default.Key | null | undefined;
}>;

declare const basicWebChatPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
    readonly role: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
}, undefined>, valibot.ReadonlyAction<{
    className?: string;
    role?: string;
}>]>;
type BasicWebChatProps = InferInput<typeof basicWebChatPropsSchema>;
declare function BasicWebChat(props: BasicWebChatProps): React__default__default.JSX.Element;
declare const _default$j: React__default__default.MemoExoticComponent<typeof BasicWebChat>;

declare function BasicSendBoxToolbar({ className }: SendBoxToolbarMiddlewareProps): React__default__default.JSX.Element;
declare const _default$i: React__default__default.MemoExoticComponent<typeof BasicSendBoxToolbar>;

declare const Surface: React__default__default.ForwardRefExoticComponent<Readonly<{
    children?: React__default__default.ReactNode;
    className?: string;
    role?: string;
}> & React__default__default.RefAttributes<HTMLDivElement>>;

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 AudioContent(props: AudioContentProps): React__default__default.JSX.Element;
declare const _default$h: React__default__default.MemoExoticComponent<typeof AudioContent>;

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 function FileContent(props: FileContentProps): React__default__default.JSX.Element;
declare const _default$g: React__default__default.MemoExoticComponent<typeof FileContent>;

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>;
declare function HTMLVideoContent(props: HTMLVideoContentProps): React__default__default.JSX.Element;
declare const _default$f: React__default__default.MemoExoticComponent<typeof HTMLVideoContent>;

declare const ImageContent: React__default__default.MemoExoticComponent<({ alt, src }: Readonly<{
    alt?: string;
    src: string;
}>) => React__default__default.JSX.Element>;

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 function TextContent(props: TextContentProps): React__default__default.JSX.Element;
declare const _default$e: React__default__default.MemoExoticComponent<typeof TextContent>;

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 function VideoContent(props: VideoContentProps): React__default__default.JSX.Element;
declare const _default$d: React__default__default.MemoExoticComponent<typeof VideoContent>;

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 function VimeoContent(props: VimeoContentProps): React__default__default.JSX.Element;
declare const _default$c: React__default__default.MemoExoticComponent<typeof VimeoContent>;

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 function YouTubeContent(props: YouTubeContentProps): React__default__default.JSX.Element;
declare const _default$b: React__default__default.MemoExoticComponent<typeof YouTubeContent>;

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>;
/** @deprecated Please use `useRenderAvatar` hook instead. */
declare function Avatar(props: AvatarProps): React__default__default.JSX.Element;
declare const _default$a: React__default__default.MemoExoticComponent<typeof Avatar>;

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__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__default.ReactNode;
    className?: string;
    fromUser?: boolean;
    nub?: boolean | "hidden";
}>]>;
type BubbleProps = InferInput<typeof bubblePropsSchema>;
declare function Bubble(props: BubbleProps): React__default__default.JSX.Element;
declare const _default$9: React__default__default.MemoExoticComponent<typeof Bubble>;

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 function Speak(props: SpeakProps): React__default__default.JSX.Element;
declare const _default$8: React__default__default.MemoExoticComponent<typeof Speak>;

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 function SendStatus(props: SendStatusProps): React__default__default.JSX.Element;
declare const _default$7: React__default__default.MemoExoticComponent<typeof SendStatus>;

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 function Timestamp(props: TimestampProps): React__default__default.JSX.Element;
declare const _default$6: React__default__default.MemoExoticComponent<typeof Timestamp>;

/**
 * @deprecated This component is deprecated and will be removed on or after 2027-08-16.
 */
declare const errorBoxPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
    readonly error: valibot.UnknownSchema;
    readonly type: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
}, undefined>, valibot.ReadonlyAction<{
    error: unknown;
    type?: string;
}>]>;
/**
 * @deprecated This component is deprecated and will be removed on or after 2027-08-16.
 */
type ErrorBoxProps = InferInput<typeof errorBoxPropsSchema>;
/**
 * @deprecated This component is deprecated and will be removed on or after 2027-08-16.
 */
declare function ErrorBox(props: ErrorBoxProps): React__default__default.JSX.Element;
declare const _default$5: React__default__default.MemoExoticComponent<typeof ErrorBox>;

declare const sendBoxAttachmentBarPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
    readonly className: valibot.OptionalSchema<valibot.StringSchema<undefined>, undefined>;
}, undefined>, valibot.ReadonlyAction<{
    className?: string;
}>]>;
type SendBoxAttachmentBarProps = InferInput<typeof sendBoxAttachmentBarPropsSchema>;
declare function SendBoxAttachmentBar(props: SendBoxAttachmentBarProps): React__default__default.JSX.Element;
declare const _default$4: React__default__default.MemoExoticComponent<typeof SendBoxAttachmentBar>;

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 function DictationInterims(props: DictationInterimsProps): React__default__default.JSX.Element;
declare const _default$3: React__default__default.MemoExoticComponent<typeof DictationInterims>;

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__default.JSX.Element;

type SuggestedActionsProps = Readonly<{
    className?: string;
}>;
declare const SuggestedActions: ({ className }: SuggestedActionsProps) => React__default__default.JSX.Element;

declare const uploadButtonPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
    readonly className: valibot.StringSchema<undefined>;
}, undefined>, valibot.ReadonlyAction<{
    className: string;
}>]>;
type UploadButtonProps = InferInput<typeof uploadButtonPropsSchema>;
declare function UploadButton(props: UploadButtonProps): React__default__default.JSX.Element;
declare const _default$2: React__default__default.MemoExoticComponent<typeof UploadButton>;

declare const TextArea: React__default__default.ForwardRefExoticComponent<{
    'aria-describedby'?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    completion?: React__default__default.ReactNode;
    'data-testid'?: string;
    hidden?: boolean;
    onClick?: React__default__default.MouseEventHandler<HTMLTextAreaElement>;
    onInput?: React__default__default.FormEventHandler<HTMLTextAreaElement>;
    placeholder?: string;
    readOnly?: boolean;
    startRows?: number;
    value?: string;
} & React__default__default.RefAttributes<HTMLTextAreaElement>>;

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

type Plural = {
    zero?: string;
    one?: string;
    two?: string;
    few?: string;
    many?: string;
    other: string;
};
type PluralProps = Readonly<{
    stringIds: Plural;
    values: readonly [number, ...(number | string)[]] | undefined;
}>;
type SingularProps = Readonly<{
    stringIds: string;
    values?: readonly (number | string)[] | undefined;
}>;
type Props = Readonly<{
    className?: string | undefined;
    linkClassName?: string | undefined;
    onDecorateLink?: ((href: string, textContent: string) => LinkOptions | undefined) | undefined;
}> & (SingularProps | PluralProps);
declare const _default$1: React__default__default.MemoExoticComponent<(props: Props) => React__default__default.JSX.Element>;

type ThemeProviderProps = {
    readonly children?: ReactNode | undefined;
    readonly styleOptions?: object | undefined;
    /** @deprecated Use `polymiddleware` instead, this will be removed on or after 2027-08-16. */
    readonly activityMiddleware?: readonly ActivityMiddleware[] | undefined;
    readonly activityStatusMiddleware?: readonly ActivityStatusMiddleware[] | undefined;
    readonly attachmentForScreenReaderMiddleware?: readonly AttachmentForScreenReaderMiddleware[] | undefined;
    readonly attachmentMiddleware?: readonly AttachmentMiddleware[] | undefined;
    readonly avatarMiddleware?: readonly AvatarMiddleware[] | undefined;
    readonly cardActionMiddleware?: readonly CardActionMiddleware[] | undefined;
    readonly groupActivitiesMiddleware?: readonly GroupActivitiesMiddleware[] | undefined;
    readonly polymiddleware?: readonly Polymiddleware[] | undefined;
    readonly scrollToEndButtonMiddleware?: readonly ScrollToEndButtonMiddleware[] | undefined;
    readonly sendBoxMiddleware?: readonly SendBoxMiddleware[] | undefined;
    readonly sendBoxToolbarMiddleware?: readonly SendBoxToolbarMiddleware[] | undefined;
    readonly toastMiddleware?: readonly ToastMiddleware[] | undefined;
    readonly typingIndicatorMiddleware?: readonly TypingIndicatorMiddleware[] | undefined;
};
declare const _default: React__default__default.MemoExoticComponent<{
    (props: ThemeProviderProps): React__default__default.JSX.Element;
    displayName: string;
}>;

declare const component_BasicConnectivityStatus: typeof BasicConnectivityStatus;
type component_BasicWebChatProps = BasicWebChatProps;
declare const component_Composer: typeof Composer;
type component_ComposerProps = ComposerProps;
declare const component_ImageContent: typeof ImageContent;
declare const component_ReactWebChat: typeof ReactWebChat;
type component_ReactWebChatProps = ReactWebChatProps;
declare const component_SendButton: typeof SendButton;
declare const component_SuggestedActions: typeof SuggestedActions;
declare const component_TextArea: typeof TextArea;
declare namespace component {
  export { Surface as AccessKeySinkSurface, _default$4 as AttachmentBar, _default$h as AudioContent, _default$a as Avatar, component_BasicConnectivityStatus as BasicConnectivityStatus, _default$1$1 as BasicSendBox, _default$i as BasicSendBoxToolbar, _default$l as BasicToaster, _default$k as BasicTranscript, _default$j as BasicWebChat, _default$9 as Bubble, component_Composer as Composer, _default$3 as DictationInterims, _default$5 as ErrorBox, _default$g as FileContent, _default$f as HTMLVideoContent, component_ImageContent as ImageContent, _default$1 as LocalizedString, _default$m as MicrophoneButton, component_ReactWebChat as ReactWebChat, component_SendButton as SendButton, _default$7 as SendStatus, TextBox as SendTextBox, _default$8 as SpeakActivity, component_SuggestedActions as SuggestedActions, component_TextArea as TextArea, _default$e as TextContent, _default as ThemeProvider, _default$6 as Timestamp, _default$2 as UploadButton, _default$d as VideoContent, _default$c as VimeoContent, _default$b as YouTubeContent };
  export { type component_BasicWebChatProps as BasicWebChatProps, type component_ComposerProps as ComposerProps, type component_ReactWebChatProps as ReactWebChatProps };
}

export { _default$2 as A, BasicConnectivityStatus as B, Composer as C, _default$d as D, _default$c as E, _default$b as F, ImageContent as I, ReactWebChat as R, Surface as S, TextArea as T, _default$4 as _, _default$h as a, _default$a as b, _default$i as c, _default$l as d, _default$k as e, _default$j as f, _default$9 as h, component as i, _default$3 as k, _default$5 as l, _default$g as m, _default$f as q, _default$1 as r, SendButton as t, _default$7 as u, _default$8 as v, SuggestedActions as w, _default$e as x, _default as y, _default$6 as z };
export type { HTMLContentTransformEnhancer as H, BasicWebChatProps as g, ComposerProps as j, HTMLContentTransformFunction as n, HTMLContentTransformMiddleware as o, HTMLContentTransformRequest as p, ReactWebChatProps as s };
