import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import type { Divider } from '@fluentui/react-components';
import { ForwardRefComponent } from '@fluentui/react-components';
import type { ProgressBar } from '@fluentui/react-components';
import * as React_2 from 'react';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';
import type { TextProps } from '@fluentui/react-components';
import type { TextSlots } from '@fluentui/react-components';
import type { TextState } from '@fluentui/react-components';

export declare const AiGeneratedDisclaimer: ForwardRefComponent<AiGeneratedDisclaimerProps>;

export declare const aiGeneratedDisclaimerClassNames: SlotClassNames<AiGeneratedDisclaimerSlots>;

export declare type AiGeneratedDisclaimerProps = ComponentProps<AiGeneratedDisclaimerSlots> & TextProps & CopilotMode & {};

export declare type AiGeneratedDisclaimerSlots = {
    root: Slot<'span'>;
};

declare type AiGeneratedDisclaimerState = TextState & CopilotMode & {};

export declare const CopilotChat: ForwardRefComponent<CopilotChatProps>;

export declare const copilotChatClassNames: SlotClassNames<CopilotChatSlots>;

/**
 * CopilotChat Props
 */
export declare type CopilotChatProps = ComponentProps<CopilotChatSlots> & {};

export declare type CopilotChatSlots = {
    root: Slot<'div'>;
};

/**
 * State used in rendering CopilotChat
 */
export declare type CopilotChatState = ComponentState<CopilotChatSlots>;

export declare const CopilotMessage: ForwardRefComponent<CopilotMessageProps>;

export declare const copilotMessageClassNames: SlotClassNames<CopilotMessageSlots>;

export declare const CopilotMessageFooter: ForwardRefComponent<CopilotMessageFooterProps>;

export declare const copilotMessageFooterClassNames: SlotClassNames<CopilotMessageFooterSlots>;

/**
 * CopilotMessageFooter Props
 */
export declare type CopilotMessageFooterProps = ComponentProps<CopilotMessageFooterSlots> & CopilotMode & {};

export declare type CopilotMessageFooterSlots = {
    root: NonNullable<Slot<'div'>>;
    aiDisclaimer?: Slot<'span'>;
    content?: Slot<'div'>;
    divider?: Slot<typeof Divider>;
    feedback?: Slot<'span'>;
    referenceList?: Slot<'div'>;
    referenceListToggle?: Slot<'span'>;
    responseCount?: Slot<'span'>;
    sensitivity?: Slot<'span'>;
    sensitivityDisclaimerContainer?: Slot<'span'>;
};

/**
 * State used in rendering CopilotMessageFooter
 */
export declare type CopilotMessageFooterState = ComponentState<CopilotMessageFooterSlots> & Required<Pick<CopilotMessageFooterProps, 'mode'>>;

/**
 * CopilotMessage Props
 */
export declare type CopilotMessageProps = ComponentProps<CopilotMessageSlots> & Exclude<OutputCardProps, 'mode'> & {
    announcement?: string;
    defaultFocused?: boolean;
};

export declare type CopilotMessageSlots = OutputCardSlots & {
    accessibleHeading?: Slot<'h6', 'div'>;
};

/**
 * State used in rendering CopilotMessage
 */
export declare type CopilotMessageState = ComponentState<CopilotMessageSlots> & OutputCardState;

declare type CopilotMode = {
    mode?: 'canvas' | 'sidecar';
};

/**
 * OutputCard Props
 */
declare type OutputCardProps = ComponentProps<OutputCardSlots> & {
    /**
     * If the card contents are loading.
     * After switching from true to false, the card flair will animate.
     * @default false
     */
    isLoading?: boolean;
    /**
     * The visual modality of the Textarea.
     * @default canvas
     */
    mode?: 'canvas' | 'sidecar';
};

declare type OutputCardSlots = {
    root: Slot<'div'>;
    /**
     * Progress bar is currently opt in, but will become opt out in 0.9.0
     */
    progress?: Slot<typeof ProgressBar>;
};

/**
 * State used in rendering OutputCard
 */
declare type OutputCardState = ComponentState<OutputCardSlots> & Required<Pick<OutputCardProps, 'isLoading' | 'mode'>>;

/**
 * Render the final JSX of CopilotChat
 */
export declare const renderCopilotChat_unstable: (state: CopilotChatState) => JSX.Element;

/**
 * Render the final JSX of CopilotMessage
 */
export declare const renderCopilotMessage_unstable: (state: CopilotMessageState) => JSX.Element;

/**
 * Render the final JSX of CopilotMessageFooter
 */
export declare const renderCopilotMessageFooter_unstable: (state: CopilotMessageFooterState) => JSX.Element;

/**
 * Render the final JSX of SystemMessage
 */
export declare const renderSystemMessage_unstable: (state: SystemMessageState) => JSX.Element;

/**
 * Render the final JSX of UserMessage
 */
export declare const renderUserMessage_unstable: (state: UserMessageState) => JSX.Element;

export declare const SystemMessage: ForwardRefComponent<SystemMessageProps>;

export declare const systemMessageClassNames: SlotClassNames<SystemMessageSlots>;

/**
 * SystemMessage Props
 */
export declare type SystemMessageProps = ComponentProps<SystemMessageSlots> & CopilotMode & {
    defaultFocused?: boolean;
    announcement?: string;
};

export declare type SystemMessageSlots = {
    root: Slot<'div'>;
    icon?: Slot<'span'>;
    message?: Slot<'span'>;
    accessibleHeading?: Slot<'h6', 'div'>;
};

/**
 * State used in rendering SystemMessage
 */
export declare type SystemMessageState = ComponentState<SystemMessageSlots> & Required<Pick<SystemMessageProps, 'mode'>> & {};

export declare const Timestamp: ForwardRefComponent<TimestampProps>;

export declare const timestampClassNames: SlotClassNames<TimestampSlots>;

/**
 * Timestamp Props
 */
export declare type TimestampProps = ComponentProps<TimestampSlots> & {};

export declare type TimestampSlots = {
    root: TextSlots['root'];
};

/**
 * State used in rendering Timestamp
 */
export declare type TimestampState = TextState & {};

export declare const useAiGeneratedDisclaimerStyles_unstable: (state: AiGeneratedDisclaimerState) => AiGeneratedDisclaimerState;

/**
 * Create the state required to render CopilotChat.
 *
 * The returned state can be modified with hooks such as useCopilotChatStyles_unstable,
 * before being passed to renderCopilotChat_unstable.
 *
 * @param props - props from this instance of CopilotChat
 * @param ref - reference to root HTMLElement of CopilotChat
 */
export declare const useCopilotChat_unstable: (props: CopilotChatProps, ref: React_2.Ref<HTMLElement>) => CopilotChatState;

/**
 * Apply styling to the CopilotChat slots based on the state
 */
export declare const useCopilotChatStyles_unstable: (state: CopilotChatState) => CopilotChatState;

/**
 * Create the state required to render CopilotMessage.
 *
 * The returned state can be modified with hooks such as useCopilotMessageStyles_unstable,
 * before being passed to renderCopilotMessage_unstable.
 *
 * @param props - props from this instance of CopilotMessage
 * @param ref - reference to root HTMLElement of CopilotMessage
 */
export declare const useCopilotMessage_unstable: (props: CopilotMessageProps, ref: React_2.Ref<HTMLElement>) => CopilotMessageState;

/**
 * Create the state required to render CopilotMessageFooter.
 *
 * The returned state can be modified with hooks such as useCopilotMessageFooterStyles_unstable,
 * before being passed to renderCopilotMessageFooter_unstable.
 *
 * @param props - props from this instance of CopilotMessageFooter
 * @param ref - reference to root HTMLElement of CopilotMessageFooter
 */
export declare const useCopilotMessageFooter_unstable: (props: CopilotMessageFooterProps, ref: React_2.Ref<HTMLDivElement>) => CopilotMessageFooterState;

/**
 * Apply styling to the CopilotMessageFooter slots based on the state
 */
export declare const useCopilotMessageFooterStyles_unstable: (state: CopilotMessageFooterState) => CopilotMessageFooterState;

export declare const useCopilotMessageStyles_unstable: (state: CopilotMessageState) => CopilotMessageState;

export declare const useMessageAttributes: ({ id, defaultFocused }: {
    id: string;
    defaultFocused?: boolean | undefined;
}) => {
    "data-tabster": string | undefined;
    role: string;
    tabIndex: number;
    id: string;
    'aria-labelledby': string;
};

export declare const UserMessage: ForwardRefComponent<UserMessageProps>;

export declare const userMessageClassNames: SlotClassNames<UserMessageSlots>;

/**
 * UserMessage Props
 */
export declare type UserMessageProps = ComponentProps<UserMessageSlots> & {
    announcement?: string;
};

export declare type UserMessageSlots = {
    root: Slot<'div'>;
    accessibleHeading?: Slot<'h5', 'div'>;
};

/**
 * State used in rendering UserMessage
 */
export declare type UserMessageState = ComponentState<UserMessageSlots>;

/**
 * Create the state required to render SystemMessage.
 *
 * The returned state can be modified with hooks such as useSystemMessageStyles_unstable,
 * before being passed to renderSystemMessage_unstable.
 *
 * @param props - props from this instance of SystemMessage
 * @param ref - reference to root HTMLElement of SystemMessage
 */
export declare const useSystemMessage_unstable: (props: SystemMessageProps, ref: React_2.Ref<HTMLDivElement>) => SystemMessageState;

/**
 * Apply styling to the SystemMessage slots based on the state
 */
export declare const useSystemMessageStyles_unstable: (state: SystemMessageState) => SystemMessageState;

/**
 * Apply styling to the Timestamp slots based on the state
 */
export declare const useTimestampStyles_unstable: (state: TimestampState) => TimestampState;

/**
 * Create the state required to render UserMessage.
 *
 * The returned state can be modified with hooks such as useUserMessageStyles_unstable,
 * before being passed to renderUserMessage_unstable.
 *
 * @param props - props from this instance of UserMessage
 * @param ref - reference to root HTMLElement of UserMessage
 */
export declare const useUserMessage_unstable: (props: UserMessageProps, ref: React_2.Ref<HTMLDivElement>) => UserMessageState;

/**
 * Apply styling to the UserMessage slots based on the state
 */
export declare const useUserMessageStyles_unstable: (state: UserMessageState) => UserMessageState;

export { }