botframework-webchat-api 4.18.1 → 4.19.0

package/dist/_dtsroll-chunks/B1b7R2eH-avatarMiddleware-CHa011_j.d.ts

@@ -0,0 +1,109 @@
+import { WebChatActivity } from 'botframework-webchat-core';
+import react__default from 'react';
+import * as react_chain_of_responsibility_preview from 'react-chain-of-responsibility/preview';
+import { ComponentHandler, ComponentHandlerResult, ComponentEnhancer, ProviderProps, ProxyProps, ComponentRenderer } from 'react-chain-of-responsibility/preview';
+
+type InferenceHelper<Request, Props extends object> = {
+    '~types': {
+        handler: ComponentHandler<Request, Props>;
+        handlerResult: ComponentHandlerResult<Props>;
+        middleware: (init: string) => ComponentEnhancer<Request, Props>;
+        props: Props;
+        providerProps: Pick<ProviderProps<Request, Props, string>, 'children' | 'middleware'>;
+        proxyProps: ProxyProps<Request, Props>;
+        renderer: ComponentRenderer<Props>;
+        request: Request;
+    };
+};
+type InferHandler<T extends InferenceHelper<any, any>> = T['~types']['handler'];
+type InferHandlerResult<T extends InferenceHelper<any, any>> = T['~types']['handlerResult'];
+type InferMiddleware<T extends InferenceHelper<any, any>> = T['~types']['middleware'];
+type InferProps<T extends InferenceHelper<any, any>> = T['~types']['props'];
+type InferRenderer<T extends InferenceHelper<any, any>> = T['~types']['renderer'];
+type InferRequest<T extends InferenceHelper<any, any>> = T['~types']['request'];
+
+declare const __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol: unique symbol;
+declare const createAvatarPolymiddleware: (enhancer: react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly activity: WebChatActivity;
+    readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+}, {
+    readonly children?: never;
+}>) => (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly activity: WebChatActivity;
+    readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+}, {
+    readonly children?: never;
+}>;
+declare const AvatarPolymiddlewareProvider: react__default.NamedExoticComponent<{
+    readonly children?: react__default.ReactNode | undefined;
+    readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+        readonly activity: WebChatActivity;
+        readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+    }, {
+        readonly children?: never;
+    }>)[];
+}> & {
+    readonly type: ({ children, middleware }: {
+        readonly children?: react__default.ReactNode | undefined;
+        readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>)[];
+    }) => react__default.JSX.Element;
+} & {
+    '~types': {
+        handler: react_chain_of_responsibility_preview.ComponentHandler<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        handlerResult: react_chain_of_responsibility_preview.ComponentHandlerResult<{
+            readonly children?: never;
+        }>;
+        middleware: (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        props: {
+            readonly children?: never;
+        };
+        providerProps: Pick<react_chain_of_responsibility_preview.ProviderProps<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }, string>, "middleware" | "children">;
+        proxyProps: react_chain_of_responsibility_preview.ProxyProps<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        renderer: react_chain_of_responsibility_preview.ComponentRenderer<{
+            readonly children?: never;
+        }>;
+        request: {
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        };
+    };
+};
+declare const avatarComponent: react_chain_of_responsibility_preview.ReactComponentHandlerResult<{
+    readonly children?: never;
+}>;
+type AvatarPolymiddleware = InferMiddleware<typeof AvatarPolymiddlewareProvider>;
+type AvatarPolymiddlewareHandler = InferHandler<typeof AvatarPolymiddlewareProvider>;
+type AvatarPolymiddlewareHandlerResult = InferHandlerResult<typeof AvatarPolymiddlewareProvider>;
+type AvatarPolymiddlewareProps = InferProps<typeof AvatarPolymiddlewareProvider>;
+type AvatarPolymiddlewareRenderer = InferRenderer<typeof AvatarPolymiddlewareProvider>;
+type AvatarPolymiddlewareRequest = InferRequest<typeof AvatarPolymiddlewareProvider>;
+
+declare const __INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol: unique symbol;
+
+export { __INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol as _, __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol as a, avatarComponent as g, createAvatarPolymiddleware as h };
+export type { AvatarPolymiddlewareRequest as A, InferMiddleware as I, AvatarPolymiddleware as b, AvatarPolymiddlewareHandler as c, AvatarPolymiddlewareHandlerResult as d, AvatarPolymiddlewareProps as e, AvatarPolymiddlewareRenderer as f, InferHandler as i, InferHandlerResult as j, InferProps as k, InferRenderer as l, InferRequest as m };

package/dist/_dtsroll-chunks/CEcj2Npa-botframework-webchat-redux-store.d.ts

@@ -0,0 +1,16 @@
+import { Dispatch, SetStateAction } from 'react';
+import { DirectLineCardAction, WebChatActivity } from 'botframework-webchat-core';
+
+type SuggestedActionsContextType = Readonly<{
+    useSuggestedActions: () => readonly [
+        readonly DirectLineCardAction[],
+        Dispatch<SetStateAction<readonly DirectLineCardAction[]>>,
+        Readonly<{
+            activity: undefined | WebChatActivity;
+        }>
+    ];
+}>;
+
+declare function useSuggestedActionsHooks(): SuggestedActionsContextType;
+
+export { useSuggestedActionsHooks as u };

package/dist/_dtsroll-chunks/DnThgHcF-botframework-webchat-api-middleware.d.ts

@@ -0,0 +1,231 @@
+import { WebChatActivity, DirectLineAttachment } from 'botframework-webchat-core';
+import react__default, { ReactNode } from 'react';
+import * as valibot from 'valibot';
+import { InferInput } from 'valibot';
+import * as react_chain_of_responsibility_preview from 'react-chain-of-responsibility/preview';
+import { I as InferMiddleware, i as InferHandler, j as InferHandlerResult, k as InferProps, l as InferRenderer, m as InferRequest } from './B1b7R2eH-avatarMiddleware-CHa011_j.js';
+
+type LegacyAttachmentProps = {
+    activity: WebChatActivity;
+    attachment: DirectLineAttachment;
+};
+type LegacyRenderAttachment = (props?: LegacyAttachmentProps) => ReactNode;
+type LegacyAttachmentEnhancer = (next: LegacyRenderAttachment) => LegacyRenderAttachment;
+type LegacyAttachmentMiddleware = () => LegacyAttachmentEnhancer;
+
+type LegacyActivityProps = {
+    children?: never | undefined;
+    hideTimestamp: boolean;
+    renderActivityStatus: (options: {
+        hideTimestamp: boolean;
+    }) => ReactNode;
+    renderAvatar: false | (() => Exclude<ReactNode, boolean | null | undefined>);
+    showCallout: boolean;
+};
+type LegacyActivityComponent = (props: LegacyActivityProps) => Exclude<ReactNode, boolean | null | undefined>;
+type LegacyActivityComponentFactoryOptions = {
+    activity: WebChatActivity;
+};
+type LegacyActivityComponentFactory = (options: LegacyActivityComponentFactoryOptions) => LegacyActivityComponent | false;
+type LegacyRenderActivity = (renderAttachment: LegacyRenderAttachment, { hideTimestamp, renderActivityStatus, renderAvatar, showCallout }: LegacyActivityProps) => Exclude<ReactNode, boolean>;
+type LegacyActivityRenderer = (options: LegacyActivityComponentFactoryOptions) => LegacyRenderActivity | false;
+type LegacyActivityEnhancer = (next: LegacyActivityRenderer) => LegacyActivityRenderer;
+type LegacyActivityMiddleware = () => LegacyActivityEnhancer;
+
+declare const createActivityPolymiddleware: (enhancer: react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly activity: WebChatActivity;
+}, {
+    readonly children?: never;
+}>) => (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly activity: WebChatActivity;
+}, {
+    readonly children?: never;
+}>;
+declare const Provider: react__default.NamedExoticComponent<{
+    readonly children?: react__default.ReactNode | undefined;
+    readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+        readonly activity: WebChatActivity;
+    }, {
+        readonly children?: never;
+    }>)[];
+}> & {
+    readonly type: ({ children, middleware }: {
+        readonly children?: react__default.ReactNode | undefined;
+        readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+        }, {
+            readonly children?: never;
+        }>)[];
+    }) => react__default.JSX.Element;
+} & {
+    '~types': {
+        handler: react_chain_of_responsibility_preview.ComponentHandler<{
+            readonly activity: WebChatActivity;
+        }, {
+            readonly children?: never;
+        }>;
+        handlerResult: react_chain_of_responsibility_preview.ComponentHandlerResult<{
+            readonly children?: never;
+        }>;
+        middleware: (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+        }, {
+            readonly children?: never;
+        }>;
+        props: {
+            readonly children?: never;
+        };
+        providerProps: Pick<react_chain_of_responsibility_preview.ProviderProps<{
+            readonly activity: WebChatActivity;
+        }, {
+            readonly children?: never;
+        }, string>, "middleware" | "children">;
+        proxyProps: react_chain_of_responsibility_preview.ProxyProps<{
+            readonly activity: WebChatActivity;
+        }, {
+            readonly children?: never;
+        }>;
+        renderer: react_chain_of_responsibility_preview.ComponentRenderer<{
+            readonly children?: never;
+        }>;
+        request: {
+            readonly activity: WebChatActivity;
+        };
+    };
+};
+declare const activityComponent: react_chain_of_responsibility_preview.ReactComponentHandlerResult<{
+    readonly children?: never;
+}>;
+declare const useBuildRenderActivityCallback: () => react_chain_of_responsibility_preview.UseBuildRenderCallback<{
+    readonly activity: WebChatActivity;
+}, {
+    readonly children?: never;
+}>;
+type ActivityPolymiddleware = InferMiddleware<typeof Provider>;
+type ActivityPolymiddlewareHandler = InferHandler<typeof Provider>;
+type ActivityPolymiddlewareHandlerResult = InferHandlerResult<typeof Provider>;
+type ActivityPolymiddlewareProps = InferProps<typeof Provider>;
+type ActivityPolymiddlewareRenderer = InferRenderer<typeof Provider>;
+type ActivityPolymiddlewareRequest = InferRequest<typeof Provider>;
+declare const activityPolymiddlewareProxyPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly activity: valibot.CustomSchema<Readonly<WebChatActivity>, undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    activity: Readonly<WebChatActivity>;
+}>]>;
+type ActivityPolymiddlewareProxyProps = Readonly<InferInput<typeof activityPolymiddlewareProxyPropsSchema>>;
+declare const ActivityPolymiddlewareProxy: react__default.MemoExoticComponent<(props: ActivityPolymiddlewareProxyProps) => react__default.JSX.Element>;
+
+declare const createErrorBoxPolymiddleware: (enhancer: react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly error: unknown;
+    readonly where: string;
+}, {
+    readonly children?: never;
+}>) => (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+    readonly error: unknown;
+    readonly where: string;
+}, {
+    readonly children?: never;
+}>;
+declare const ErrorBoxPolymiddlewareProvider: react__default.NamedExoticComponent<{
+    readonly children?: react__default.ReactNode | undefined;
+    readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+        readonly error: unknown;
+        readonly where: string;
+    }, {
+        readonly children?: never;
+    }>)[];
+}> & {
+    readonly type: ({ children, middleware }: {
+        readonly children?: react__default.ReactNode | undefined;
+        readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly error: unknown;
+            readonly where: string;
+        }, {
+            readonly children?: never;
+        }>)[];
+    }) => react__default.JSX.Element;
+} & {
+    '~types': {
+        handler: react_chain_of_responsibility_preview.ComponentHandler<{
+            readonly error: unknown;
+            readonly where: string;
+        }, {
+            readonly children?: never;
+        }>;
+        handlerResult: react_chain_of_responsibility_preview.ComponentHandlerResult<{
+            readonly children?: never;
+        }>;
+        middleware: (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly error: unknown;
+            readonly where: string;
+        }, {
+            readonly children?: never;
+        }>;
+        props: {
+            readonly children?: never;
+        };
+        providerProps: Pick<react_chain_of_responsibility_preview.ProviderProps<{
+            readonly error: unknown;
+            readonly where: string;
+        }, {
+            readonly children?: never;
+        }, string>, "middleware" | "children">;
+        proxyProps: react_chain_of_responsibility_preview.ProxyProps<{
+            readonly error: unknown;
+            readonly where: string;
+        }, {
+            readonly children?: never;
+        }>;
+        renderer: react_chain_of_responsibility_preview.ComponentRenderer<{
+            readonly children?: never;
+        }>;
+        request: {
+            readonly error: unknown;
+            readonly where: string;
+        };
+    };
+};
+declare const errorBoxComponent: react_chain_of_responsibility_preview.ReactComponentHandlerResult<{
+    readonly children?: never;
+}>;
+declare const useBuildRenderCallback: () => react_chain_of_responsibility_preview.UseBuildRenderCallback<{
+    readonly error: unknown;
+    readonly where: string;
+}, {
+    readonly children?: never;
+}>;
+type ErrorBoxPolymiddleware = InferMiddleware<typeof ErrorBoxPolymiddlewareProvider>;
+type ErrorBoxPolymiddlewareHandler = InferHandler<typeof ErrorBoxPolymiddlewareProvider>;
+type ErrorBoxPolymiddlewareHandlerResult = InferHandlerResult<typeof ErrorBoxPolymiddlewareProvider>;
+type ErrorBoxPolymiddlewareProps = InferProps<typeof ErrorBoxPolymiddlewareProvider>;
+type ErrorBoxPolymiddlewareRenderer = InferRenderer<typeof ErrorBoxPolymiddlewareProvider>;
+type ErrorBoxPolymiddlewareRequest = InferRequest<typeof ErrorBoxPolymiddlewareProvider>;
+declare const ErrorBoxPolymiddlewareProxyPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly error: valibot.UnknownSchema;
+    readonly where: valibot.StringSchema<undefined>;
+}, undefined>, valibot.ReadonlyAction<{
+    error: unknown;
+    where: string;
+}>]>;
+type ErrorBoxPolymiddlewareProxyProps = Readonly<InferInput<typeof ErrorBoxPolymiddlewareProxyPropsSchema>>;
+declare const ErrorBoxPolymiddlewareProxy: react__default.MemoExoticComponent<(props: ErrorBoxPolymiddlewareProxyProps) => react__default.JSX.Element>;
+declare const useBuildRenderErrorBoxCallback: typeof useBuildRenderCallback;
+
+type Polymiddleware = ActivityPolymiddleware | ErrorBoxPolymiddleware;
+
+declare const polymiddlewareComposerPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
+    readonly children: valibot.OptionalSchema<valibot.CustomSchema<react__default.ReactNode, undefined>, undefined>;
+    readonly polymiddleware: valibot.SchemaWithPipe<readonly [valibot.CustomSchema<readonly Polymiddleware[], undefined>, valibot.TransformAction<readonly Polymiddleware[], readonly Polymiddleware[]>]>;
+}, undefined>, valibot.ReadonlyAction<{
+    children?: react__default.ReactNode;
+    polymiddleware: readonly Polymiddleware[];
+}>]>;
+type PolymiddlewareComposerProps = Readonly<InferInput<typeof polymiddlewareComposerPropsSchema>>;
+declare function PolymiddlewareComposer(props: PolymiddlewareComposerProps): react__default.JSX.Element;
+declare namespace PolymiddlewareComposer {
+    var displayName: string;
+}
+declare const _default: react__default.MemoExoticComponent<typeof PolymiddlewareComposer>;
+
+export { _default as _, ActivityPolymiddlewareProxy as g, ErrorBoxPolymiddlewareProxy as n, activityComponent as r, createActivityPolymiddleware as s, createErrorBoxPolymiddleware as t, errorBoxComponent as u, useBuildRenderActivityCallback as v, useBuildRenderErrorBoxCallback as w };
+export type { ActivityPolymiddleware as A, ErrorBoxPolymiddleware as E, LegacyActivityMiddleware as L, Polymiddleware as P, LegacyAttachmentMiddleware as a, LegacyRenderAttachment as b, LegacyActivityComponentFactory as c, ActivityPolymiddlewareHandler as d, ActivityPolymiddlewareHandlerResult as e, ActivityPolymiddlewareProps as f, ActivityPolymiddlewareProxyProps as h, ActivityPolymiddlewareRenderer as i, ActivityPolymiddlewareRequest as j, ErrorBoxPolymiddlewareHandler as k, ErrorBoxPolymiddlewareHandlerResult as l, ErrorBoxPolymiddlewareProps as m, ErrorBoxPolymiddlewareProxyProps as o, ErrorBoxPolymiddlewareRenderer as p, ErrorBoxPolymiddlewareRequest as q };

package/dist/_dtsroll-chunks/Dtb0H_Ee-handler-chain.d.ts

@@ -0,0 +1,4 @@
+type Handler<Result, Request> = (request: Request) => Result;
+type Enhancer<Result, Request> = (next: Handler<Result, Request>) => Handler<Result, Request>;
+
+export type { Enhancer as E };

package/dist/_dtsroll-chunks/N-ttGLxs-botframework-webchat-base.utils.d.ts

@@ -0,0 +1,4 @@
+/** @deprecated Will be removed on or after 2028-03-18. */
+type OneOrMany<T> = T | readonly T[];
+
+export type { OneOrMany as O };

package/dist/_dtsroll-chunks/qKTV3q17-avatarMiddleware-CHa011_j.d.ts

@@ -0,0 +1,93 @@
+import { WebChatActivity } from 'botframework-webchat-core';
+import react__default, { ReactNode } from 'react';
+import * as react_chain_of_responsibility_preview from 'react-chain-of-responsibility/preview';
+import { ComponentHandler, ComponentHandlerResult, ComponentEnhancer, ProviderProps, ProxyProps, ComponentRenderer } from 'react-chain-of-responsibility/preview';
+
+type InferenceHelper<Request, Props extends object> = {
+    '~types': {
+        handler: ComponentHandler<Request, Props>;
+        handlerResult: ComponentHandlerResult<Props>;
+        middleware: (init: string) => ComponentEnhancer<Request, Props>;
+        props: Props;
+        providerProps: Pick<ProviderProps<Request, Props, string>, 'children' | 'middleware'>;
+        proxyProps: ProxyProps<Request, Props>;
+        renderer: ComponentRenderer<Props>;
+        request: Request;
+    };
+};
+type InferRequest<T extends InferenceHelper<any, any>> = T['~types']['request'];
+
+declare const __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol: unique symbol;
+declare const AvatarPolymiddlewareProvider: react__default.NamedExoticComponent<{
+    readonly children?: react__default.ReactNode | undefined;
+    readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+        readonly activity: WebChatActivity;
+        readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+    }, {
+        readonly children?: never;
+    }>)[];
+}> & {
+    readonly type: ({ children, middleware }: {
+        readonly children?: react__default.ReactNode | undefined;
+        readonly middleware: readonly ((init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>)[];
+    }) => react__default.JSX.Element;
+} & {
+    '~types': {
+        handler: react_chain_of_responsibility_preview.ComponentHandler<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        handlerResult: react_chain_of_responsibility_preview.ComponentHandlerResult<{
+            readonly children?: never;
+        }>;
+        middleware: (init: string) => react_chain_of_responsibility_preview.ComponentEnhancer<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        props: {
+            readonly children?: never;
+        };
+        providerProps: Pick<react_chain_of_responsibility_preview.ProviderProps<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }, string>, "middleware" | "children">;
+        proxyProps: react_chain_of_responsibility_preview.ProxyProps<{
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        }, {
+            readonly children?: never;
+        }>;
+        renderer: react_chain_of_responsibility_preview.ComponentRenderer<{
+            readonly children?: never;
+        }>;
+        request: {
+            readonly activity: WebChatActivity;
+            readonly [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: any;
+        };
+    };
+};
+type AvatarPolymiddlewareRequest = InferRequest<typeof AvatarPolymiddlewareProvider>;
+
+declare const __INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol: unique symbol;
+type LegacyAvatarComponentFactoryArguments = {
+    readonly [__INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol]: AvatarPolymiddlewareRequest;
+    readonly activity: WebChatActivity;
+    readonly fromUser: boolean;
+    readonly styleOptions: Readonly<Record<string, unknown>>;
+};
+type LegacyAvatarRenderer = false | (() => Exclude<ReactNode, boolean | null | undefined>);
+type LegacyAvatarEnhancer = (next: (args: LegacyAvatarComponentFactoryArguments) => LegacyAvatarRenderer) => (args: LegacyAvatarComponentFactoryArguments) => LegacyAvatarRenderer;
+type LegacyAvatarMiddleware = () => LegacyAvatarEnhancer;
+
+export type { LegacyAvatarMiddleware as L };