import * as valibot from 'valibot';
import { InferInput } from 'valibot';
import * as react from 'react';
import react__default, { ReactNode } from 'react';
import { D as DecoratorMiddleware } from './types-3Ta-OETW.js';
export { c as createActivityBorderMiddleware, a as createActivityGroupingMiddleware } from './types-3Ta-OETW.js';
import { WebChatActivity } from 'botframework-webchat-core';
import './_dtsroll-chunks/Dtb0H_Ee-handler-chain.js';
import 'react-chain-of-responsibility';
import './templateMiddleware-BEttHPJk.js';

declare const decoratorComposerPropsSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
    readonly children: valibot.OptionalSchema<valibot.CustomSchema<react__default.ReactNode, undefined>, undefined>;
    readonly middleware: valibot.OptionalSchema<valibot.SchemaWithPipe<readonly [valibot.ArraySchema<valibot.CustomSchema<DecoratorMiddleware, undefined>, undefined>, valibot.ReadonlyAction<DecoratorMiddleware[]>]>, undefined>;
}, undefined>, valibot.ReadonlyAction<{
    children?: react__default.ReactNode;
    middleware?: readonly DecoratorMiddleware[];
}>]>;
type DecoratorComposerProps = Omit<InferInput<typeof decoratorComposerPropsSchema>, 'middleware'> & {
    readonly middleware?: readonly DecoratorMiddleware[] | undefined;
};
declare function DecoratorComposer(props: DecoratorComposerProps): react__default.JSX.Element;
declare const _default$2: react__default.MemoExoticComponent<typeof DecoratorComposer>;

type ActivityBorderDecoratorRequest = Readonly<{
    /**
     * Decorate the activity as it participate in a livestreaming session.
     *
     * - `"completing"` - decorate as the livestreaming is completing
     * - `"ongoing"` - decorate as the livestreaming is ongoing
     * - `"preparing"` - decorate as the livestreaming is being prepared
     * - `undefined` - not participated in a livestreaming session
     */
    livestreamingState: 'completing' | 'ongoing' | 'preparing' | undefined;
    /**
     * Gets the role of the sender for the activity.
     *
     * - `"bot"` - the sender is a bot or other users
     * - `"channel"` - the sender is the channel service
     * - `"user"` - the sender is the current user
     * - `undefined` - the sender is unknown
     */
    from: 'bot' | 'channel' | `user` | undefined;
}>;
declare const ActivityBorderDecoratorRequestContext: react.Context<Readonly<{
    request: ActivityBorderDecoratorRequest;
}>>;

type ActivityBorderDecoratorProps = Readonly<{
    activity?: WebChatActivity | undefined;
    children?: ReactNode | undefined;
}>;
declare function ActivityBorderDecorator({ activity, children }: ActivityBorderDecoratorProps): react__default.JSX.Element;
declare const _default$1: react__default.MemoExoticComponent<typeof ActivityBorderDecorator>;

declare function useDecoratorRequest(type: typeof ActivityBorderDecoratorRequestContext): Readonly<{
    livestreamingState: "completing" | "ongoing" | "preparing" | undefined;
    from: "bot" | "channel" | `user` | undefined;
}>;
type InferDecoratorRequest<T extends typeof ActivityBorderDecoratorRequestContext> = T extends React.Context<infer U> ? (U extends {
    request: infer R;
} ? R : never) : never;

type ActivityGroupingDecoratorProps = Readonly<{
    activities: readonly WebChatActivity[];
    children?: ReactNode | undefined;
    groupingName: string;
}>;
declare function ActivityGroupingDecorator({ activities, children, groupingName }: ActivityGroupingDecoratorProps): react__default.JSX.Element;
declare const _default: react__default.MemoExoticComponent<typeof ActivityGroupingDecorator>;

export { _default$1 as ActivityBorderDecorator, type ActivityBorderDecoratorProps, ActivityBorderDecoratorRequestContext as ActivityBorderDecoratorRequest, _default as ActivityGroupingDecorator, _default$2 as DecoratorComposer, DecoratorMiddleware, type InferDecoratorRequest, useDecoratorRequest };
