/// <reference types="react" />

import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import type { CopilotMode } from '@fluentui-copilot/react-provider';
import type { DesignVersion } from '@fluentui-copilot/react-provider';
import { ForwardRefComponent } from '@fluentui/react-components';
import { ForwardRefComponent as ForwardRefComponent_2 } from '@fluentui/react-utilities';
import { JSXElement } from '@fluentui/react-utilities';
import type { ProgressBar } from '@fluentui/react-components';
import * as React_2 from 'react';
import { Ref } from 'react';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';
import { SlotClassNames as SlotClassNames_2 } from '@fluentui/react-utilities';
import type { TextProps } from '@fluentui/react-components';
import type { TextSlots } from '@fluentui/react-components';
import type { TextState } from '@fluentui/react-components';
import type { Toolbar } from '@fluentui/react-components';

export declare const AiGeneratedDisclaimer: ForwardRefComponent<AiGeneratedDisclaimerProps>;

export declare const aiGeneratedDisclaimerClassNames: SlotClassNames<AiGeneratedDisclaimerSlots>;

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

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

declare type AiGeneratedDisclaimerState = TextState & CopilotMode & DesignVersion & {};

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

/**
 * CopilotMessage Props
 */
export declare type CopilotMessageProps = CopilotMode & Omit<ComponentProps<CopilotMessageSlots>, 'content'> & Pick<CopilotMessageSlots, 'content'> & {
    announcement?: string;
    defaultFocused?: boolean;
    /**
     * The loading state of the message's contents.
     * @default none
     */
    loadingState?: 'loading' | 'streaming' | 'none';
};

export declare type CopilotMessageSlots = {
    /**
     * The root slot for CopilotMessage
     */
    root: NonNullable<Slot<'div'>>;
    accessibleHeading?: Slot<'h6', 'div'>;
    /**
     * The slot for the icon
     */
    avatar: NonNullable<Slot<'div'>>;
    /**
     * The slot for the name
     */
    name: NonNullable<Slot<'div'>>;
    /**
     * The slot for the AI disclaimer
     */
    disclaimer?: Slot<'div'>;
    /**
     * The slot for the message content
     */
    content?: Slot<'div'>;
    /**
     * The slot for the informational footer items
     */
    footnote?: Slot<'div'>;
    /**
     * The slot for the action footer items
     */
    actions?: Slot<'div'>;
    /**
     * The slot for the progress bar that is shown when content is being streamed
     */
    progress?: Slot<typeof ProgressBar>;
};

/**
 * State used in rendering CopilotMessage
 */
export declare type CopilotMessageState = ComponentState<CopilotMessageSlots> & Required<Pick<CopilotMessageProps, 'mode' | 'loadingState'>> & {
    /**
     * CSS class for the wrapper container around accessible heading, avatar, name, and disclaimer.
     */
    nameLineClassName?: string;
};

/** @deprecated use CopilotMessage */
export declare const CopilotMessageV2: ForwardRefComponent_2<CopilotMessageProps>;

/** @deprecated use copilotMessageClassNames */
export declare const copilotMessageV2ClassNames: SlotClassNames_2<CopilotMessageSlots>;

/** @deprecated use CopilotMessageProps */
export declare type CopilotMessageV2Props = CopilotMessageProps;

/** @deprecated use CopilotMessageSlots */
export declare type CopilotMessageV2Slots = CopilotMessageSlots;

/** @deprecated use CopilotMessageState */
export declare type CopilotMessageV2State = CopilotMessageState;

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

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

/** @deprecated use renderCopilotMessage_unstable */
export declare const renderCopilotMessageV2_unstable: (state: CopilotMessageState) => JSXElement;

/**
 * Render the final JSX of ScrollDownButton
 */
export declare const renderScrollDownButton_unstable: (state: ScrollDownButtonState) => JSXElement;

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

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

/** @deprecated use renderUserMessage_unstable */
export declare const renderUserMessageV2_unstable: (state: UserMessageState) => JSXElement;

export declare const ScrollDownButton: ForwardRefComponent<ScrollDownButtonProps>;

export declare const scrollDownButtonClassNames: SlotClassNames<ScrollDownButtonSlots>;

/**
 * ScrollDownButton Props
 */
export declare type ScrollDownButtonProps = ComponentProps<Partial<ScrollDownButtonSlots>> & {
    isGenerating?: boolean;
};

export declare type ScrollDownButtonSlots = {
    root: NonNullable<Slot<'button'>>;
    spinner?: Slot<'svg'>;
    spinnerMaskStroke?: Slot<'circle'>;
    spinnerMaskBackground?: Slot<'circle'>;
    spinnerBase?: Slot<'circle'>;
    icon: NonNullable<Slot<'span'>>;
};

/**
 * State used in rendering ScrollDownButton
 */
export declare type ScrollDownButtonState = ComponentState<ScrollDownButtonSlots> & Partial<Pick<ScrollDownButtonProps, 'isGenerating'>> & {
    maskId: string;
};

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<HTMLDivElement>) => 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<HTMLDivElement>) => CopilotMessageState;

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

/** @deprecated use useCopilotMessage_unstable */
export declare const useCopilotMessageV2_unstable: (props: CopilotMessageProps, ref: Ref<HTMLDivElement>) => CopilotMessageState;

/** @deprecated use useCopilotMessageStyles_unstable */
export declare const useCopilotMessageV2Styles_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 = {
    /**
     * The root slot for UserMessage
     */
    root: NonNullable<Slot<'div'>>;
    accessibleHeading?: Slot<'h5', 'div'>;
    /**
     * The slot for the timestamp of the message
     */
    timestamp?: Slot<'span'>;
    /**
     * The slot for the accessible button
     */
    actionBarAccessibleButton?: Slot<'button'>;
    /**
     * The slot for the action bar above the message
     */
    actionBar?: Slot<typeof Toolbar>;
    /**
     * The slot for the message content. UserMessage's children are forwarded to this slot.
     */
    message?: NonNullable<Slot<'div'>>;
};

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

/** @deprecated use UserMessage */
export declare const UserMessageV2: ForwardRefComponent_2<UserMessageProps>;

/** @deprecated use copilotMessageClassNames */
export declare const userMessageV2ClassNames: SlotClassNames_2<UserMessageSlots>;

/** @deprecated use UserMessageProps */
export declare type UserMessageV2Props = UserMessageProps;

/** @deprecated use UserMessageSlots */
export declare type UserMessageV2Slots = UserMessageSlots;

/** @deprecated use UserMessageState */
export declare type UserMessageV2State = UserMessageState;

/**
 * Create the state required to render ScrollDownButton.
 *
 * The returned state can be modified with hooks such as useScrollDownButtonStyles_unstable,
 * before being passed to renderScrollDownButton_unstable.
 *
 * @param props - props from this instance of ScrollDownButton
 * @param ref - reference to root HTMLElement of ScrollDownButton
 */
export declare const useScrollDownButton_unstable: (props: ScrollDownButtonProps, ref: React_2.Ref<HTMLButtonElement>) => ScrollDownButtonState;

/**
 * Apply styling to the ScrollDownButton slots based on the state
 */
export declare const useScrollDownButtonStyles_unstable: (state: ScrollDownButtonState) => ScrollDownButtonState;

declare type UseScrollToBottom = {
    isAtBottom: boolean;
    sentinel: JSXElement;
};

export declare const useScrollToBottom: (params: UseScrollToBottomParams) => UseScrollToBottom;

declare type UseScrollToBottomParams = {
    sentinelClassName?: string;
};

/**
 * 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;

/** @deprecated use useUserMessage_unstable */
export declare const useUserMessageV2_unstable: (props: UserMessageProps, ref: Ref<HTMLDivElement>) => UserMessageState;

/** @deprecated use useUserMessageStyles_unstable */
export declare const useUserMessageV2Styles_unstable: (state: UserMessageState) => UserMessageState;

export { }