/// <reference types="node" />
export * from './index-minimal';
import ReactWebChat from './FullReactWebChat';
import createAdaptiveCardsAttachmentForScreenReaderMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentForScreenReaderMiddleware';
import createAdaptiveCardsAttachmentMiddleware from './adaptiveCards/createAdaptiveCardsAttachmentMiddleware';
import useAdaptiveCardsHostConfig from './adaptiveCards/hooks/useAdaptiveCardsHostConfig';
import useAdaptiveCardsPackage from './adaptiveCards/hooks/useAdaptiveCardsPackage';
import createCognitiveServicesSpeechServicesPonyfillFactory from './createCognitiveServicesSpeechServicesPonyfillFactory';
import defaultCreateDirectLine from './createDirectLine';
import defaultCreateDirectLineAppServiceExtension from './createDirectLineAppServiceExtension';
import createDirectLineSpeechAdapters from './createDirectLineSpeechAdapters';
import createStyleSet from './createFullStyleSet';
import useStyleOptions from './hooks/useStyleOptions';
import useStyleSet from './hooks/useStyleSet';
import { Components as MinimalComponents, withEmoji } from './index-minimal';
import renderMarkdown from './markdown/renderMarkdown';
import { type AdaptiveCardsPackage } from './types/AdaptiveCardsPackage';
import FullBundleStyleOptions, { StrictFullBundleStyleOptions } from './types/FullBundleStyleOptions';
declare const renderWebChat: any;
declare const buildInfo: {
    variant: string;
    buildTool: string;
    moduleFormat: string;
    version: string;
};
export declare const createDirectLine: (options: Omit<Parameters<typeof defaultCreateDirectLine>[0], 'botAgent'>) => import("botframework-directlinejs").DirectLine;
export declare const createDirectLineAppServiceExtension: (options: Omit<Parameters<typeof defaultCreateDirectLineAppServiceExtension>[0], 'botAgent'>) => Promise<any>;
declare const patchedHooks: {
    useAdaptiveCardsHostConfig: typeof useAdaptiveCardsHostConfig;
    useAdaptiveCardsPackage: typeof useAdaptiveCardsPackage;
    useStyleOptions: typeof useStyleOptions;
    useStyleSet: typeof useStyleSet;
    useDictateAbortable: () => [boolean];
    useFocus: () => (where?: "main" | "sendBox" | "sendBoxWithoutKeyboard") => Promise<void>;
    useMakeThumbnail: () => (file: File, contentType?: string) => Promise<URL>;
    useMicrophoneButtonClick: () => () => void;
    useMicrophoneButtonDisabled: () => [boolean];
    useObserveScrollPosition: (observer: (scrollPosition: {
        activityID?: string;
        scrollTop: number;
    }) => void, deps: any[]) => void;
    useObserveTranscriptFocus: (observer: (event: {
        activity: import("botframework-webchat-core").WebChatActivity;
    }) => void, deps: any[]) => void;
    useRegisterFocusSendBox: (listener: (value: import("botframework-webchat-component").SendBoxFocusOptions) => void) => void;
    useRenderMarkdownAsHTML: (mode?: "accessible name" | "adaptive cards" | "citation modal" | "clipboard" | "message activity") => (markdown: string, styleOptions?: Readonly<import("botframework-webchat-api").StrictStyleOptions>, options?: Readonly<{
        externalLinkAlt: string;
    }>) => string;
    useScrollDown: () => (options?: {
        displacement: number;
    }) => void;
    useScrollTo: () => (position: {
        activityID?: string;
        scrollTop: number;
    }, scrollToOptions: {
        behavior?: "auto" | "smooth";
    }) => void;
    useScrollToEnd: () => () => void;
    useScrollUp: () => (options?: {
        displacement: number;
    }) => void;
    useSendBoxSpeechInterimsVisible: () => [boolean];
    useSendFiles: () => (files: readonly File[]) => void;
    useSendMessage: () => (text?: string, method?: string, init?: {
        attachments?: Iterable<Readonly<{
            blob: Blob | File;
            thumbnailURL?: URL;
        }>>;
        channelData?: any;
    }) => void;
    useTextBoxSubmit: () => {
        (setFocus: false): void;
        (setFocus?: "sendBox" | "sendBoxWithoutKeyboard"): void;
    };
    useTextBoxValue: () => [string, (textBoxValue: string) => void];
    useTypingIndicatorVisible: () => readonly [boolean];
    useWebSpeechPonyfill: () => [import("botframework-webchat-api").WebSpeechPonyfill];
    useActiveTyping: (expireAfter?: number) => readonly [Readonly<Record<string, import("botframework-webchat-api").Typing>>];
    useActivities: () => [import("botframework-webchat-core").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: () => import("botframework-webchat-api").ActivityComponentFactory;
    useCreateActivityStatusRenderer: () => import("botframework-webchat-api").ActivityStatusRenderer;
    useCreateAttachmentForScreenReaderRenderer: () => import("botframework-webchat-api").AttachmentForScreenReaderComponentFactory;
    useCreateAvatarRenderer: () => ({ activity }: {
        activity: import("botframework-webchat-core").WebChatActivity;
    }) => false | (() => import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal);
    useCreateScrollToEndButtonRenderer: () => import("botframework-webchat-api").ScrollToEndButtonComponentFactory;
    useDateFormatter: () => (date: string | number | Date) => string;
    useDebouncedNotifications: () => [import("botframework-webchat-api").DebouncedNotifications];
    useDictateInterims: () => [string[], (interims: string[]) => void];
    useDictateState: () => [number];
    useDirection: () => ["auto" | "ltr" | "rtl"];
    useDisabled: () => [boolean];
    useDismissNotification: () => (id: string) => void;
    useEmitTypingIndicator: () => () => void;
    useGetActivitiesByKey: () => (key?: string) => readonly import("botframework-webchat-core").WebChatActivity[];
    useGetActivityByKey: () => (key?: string) => import("botframework-webchat-core").WebChatActivity;
    useGetHasAcknowledgedByActivityKey: () => (activityKey: string) => boolean;
    useGetKeyByActivity: () => (activity?: import("botframework-webchat-core").WebChatActivity) => string;
    useGetKeyByActivityId: () => (activityId?: string) => string;
    useGetSendTimeoutForActivity: () => ({ activity }: {
        activity: import("botframework-webchat-core").WebChatActivity;
    }) => number;
    useGrammars: () => [any];
    useGroupActivities: () => ({ activities }: {
        activities: import("botframework-webchat-core").WebChatActivity[];
    }) => {
        sender: import("botframework-webchat-core").WebChatActivity[][];
        status: import("botframework-webchat-core").WebChatActivity[][];
    };
    useGroupTimestamp: () => [number | boolean];
    useLanguage: (options?: "speech") => [string];
    useLastAcknowledgedActivityKey: () => readonly [string];
    useLastReadActivityKey: () => readonly [string];
    useLocalizer: ({ plural }?: {
        plural?: boolean;
    }) => (id: string | {
        zero?: string;
        one?: string;
        two?: string;
        few?: string;
        many?: string;
        other: string;
    }, args_0?: string | number, ...args_1: string[]) => any;
    useMarkActivityAsSpoken: () => (activity: import("botframework-webchat-core").WebChatActivity) => void;
    useMarkActivityKeyAsRead: () => (activityKey: string) => void;
    useMarkAllAsAcknowledged: () => () => void;
    useNotifications: () => [import("botframework-webchat-api").Notification[]];
    usePerformCardAction: () => import("botframework-webchat-api").PerformCardAction;
    usePonyfill: () => readonly [{
        cancelAnimationFrame?: typeof cancelAnimationFrame;
        cancelIdleCallback?: typeof cancelIdleCallback;
        clearImmediate?: typeof clearImmediate;
        clearInterval: typeof clearInterval;
        clearTimeout: typeof clearTimeout;
        Date: DateConstructor;
        requestAnimationFrame?: typeof requestAnimationFrame;
        requestIdleCallback?: typeof requestIdleCallback;
        setImmediate?: typeof setImmediate;
        setInterval: typeof setInterval;
        setTimeout: typeof setTimeout;
    }];
    usePostActivity: () => (activity: import("botframework-webchat-core").WebChatActivity) => import("botframework-webchat-core").Observable<string>;
    useReferenceGrammarID: () => [string];
    useRelativeTimeFormatter: () => (dateOrString: string | Date) => string;
    useRenderAttachment: () => import("botframework-webchat-api").RenderAttachment;
    useRenderToast: () => import("botframework-webchat-api").RenderToast;
    useRenderTypingIndicator: () => import("botframework-webchat-api").RenderTypingIndicator;
    useSendBoxAttachments: () => readonly [readonly Readonly<{
        blob: Blob | File;
        thumbnailURL?: URL;
    }>[], (attachments: readonly Readonly<{
        blob: Blob | File;
        thumbnailURL?: URL;
    }>[]) => 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: () => readonly [ReadonlyMap<string, import("botframework-webchat-api").SendStatus>];
    useSendTimeoutForActivity: (activity: import("botframework-webchat-core").WebChatActivity) => number;
    useSendTypingIndicator: () => [boolean];
    useSetNotification: () => (notification: import("botframework-webchat-api").Notification) => void;
    useShouldSpeakIncomingActivity: () => [boolean, (value: boolean) => void];
    useStartDictate: () => () => void;
    useStopDictate: () => () => void;
    useSubmitSendBox: () => (method?: string, { channelData }?: {
        channelData: any;
    }) => void;
    useSuggestedActions: () => [import("botframework-webchat-core").DirectLineCardAction[], (suggestedActions: never[]) => void, extras: {
        activity: import("botframework-webchat-core").WebChatActivity;
    }];
    useTimeoutForSend: () => [number | ((activity: import("botframework-webchat-core").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>;
    useUserID: () => [string];
    useUsername: () => [string];
    useVoiceSelector: (activity: any) => (voices: {
        new (): SpeechSynthesisVoice;
        prototype: SpeechSynthesisVoice;
    }[]) => {
        new (): SpeechSynthesisVoice;
        prototype: SpeechSynthesisVoice;
    };
};
declare const AdditionalComponents: {
    AdaptiveCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: any;
        disabled?: boolean;
    }>;
    AnimationCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineAnimationCard;
        disabled?: boolean;
    }>;
    AudioCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineAudioCard;
        disabled?: boolean;
    }>;
    Composer: {
        (props: import("./FullComposer").FullComposerProps): import("react").JSX.Element;
        defaultProps: {
            adaptiveCardsHostConfig: any;
            adaptiveCardsPackage: any;
            children: any;
            extraStyleSet: any;
            nonce: any;
            renderMarkdown: any;
            styleSet: any;
            suggestedActionsAccessKey: string;
            webSpeechPonyfillFactory: any;
            internalRenderErrorBox: any;
            onTelemetry: any;
            ponyfill: any;
            store: any;
        };
        propTypes: {
            adaptiveCardsHostConfig: import("prop-types").Requireable<any>;
            adaptiveCardsPackage: import("prop-types").Requireable<any>;
            children: import("prop-types").Requireable<any>;
            extraStyleSet: import("prop-types").Requireable<any>;
            nonce: import("prop-types").Requireable<string>;
            renderMarkdown: import("prop-types").Requireable<(...args: any[]) => any>;
            styleSet: import("prop-types").Requireable<any>;
            suggestedActionsAccessKey: import("prop-types").Requireable<NonNullable<string | boolean>>;
            webSpeechPonyfillFactory: import("prop-types").Requireable<(...args: any[]) => any>;
            internalRenderErrorBox: import("prop-types").Requireable<any>;
            onTelemetry: import("prop-types").Requireable<(...args: any[]) => any>;
            ponyfill: import("prop-types").Requireable<any>;
            store: import("prop-types").Requireable<any>;
        };
    };
    HeroCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineHeroCard;
        disabled?: boolean;
    }>;
    OAuthCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineOAuthCard;
        disabled?: boolean;
    }>;
    ReceiptCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineReceiptCard;
        disabled?: boolean;
    }>;
    SignInCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineSignInCard;
        disabled?: boolean;
    }>;
    ThumbnailCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: import("botframework-webchat-core").DirectLineThumbnailCard;
        disabled?: boolean;
    }>;
    VideoCardContent: import("react").FC<{
        actionPerformedClassName?: string;
        content: {
            aspect?: "4:3" | "16:9";
            autoloop?: boolean;
            autostart?: boolean;
            buttons?: import("botframework-webchat-core").DirectLineCardAction[];
            duration?: string;
            image?: {
                url: string;
            };
            media: {
                profile?: string;
                url: string;
            }[];
            shareable?: boolean;
            subtitle?: string;
            title?: string;
            value?: any;
        } & {
            contentType: "application/vnd.microsoft.card.video";
        } & {
            autoloop?: boolean;
            autostart?: boolean;
            image?: {
                url?: string;
            };
            media?: {
                profile?: string;
                url?: string;
            }[];
        };
        disabled?: boolean;
    }>;
};
declare const Components: typeof MinimalComponents & typeof AdditionalComponents;
type StyleOptions = FullBundleStyleOptions;
type StrictStyleOptions = StrictFullBundleStyleOptions;
export default ReactWebChat;
export { Components, buildInfo, createAdaptiveCardsAttachmentForScreenReaderMiddleware, createAdaptiveCardsAttachmentMiddleware, createCognitiveServicesSpeechServicesPonyfillFactory, createDirectLineSpeechAdapters, createStyleSet, patchedHooks as hooks, renderMarkdown, renderWebChat, withEmoji };
export type { AdaptiveCardsPackage, StrictStyleOptions, StyleOptions };
//# sourceMappingURL=index.d.ts.map