import type { ChatInputEntityData } from '@fluentui-copilot/chat-input-plugins';
import type { ChatInputEntityPluginProps } from '@fluentui-copilot/chat-input-plugins';
import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import { DecoratorNode } from '@fluentui-copilot/text-editor';
import type { EditorConfig } from '@fluentui-copilot/text-editor';
import type { EditorState } from '@fluentui-copilot/text-editor';
import type { ForwardRefComponent } from '@fluentui/react-components';
import type { IImperativeControlBase } from '@fluentui-copilot/chat-input-plugins';
import type { IManualGhostTextBase } from '@fluentui-copilot/chat-input-plugins';
import type { JSXElement } from '@fluentui/react-utilities';
import type { LexicalEditor } from '@fluentui-copilot/text-editor';
import type { LexicalNode } from '@fluentui-copilot/text-editor';
import type { NodeKey } from '@fluentui-copilot/text-editor';
import { PasteUnfurlingPluginBaseProps } from '@fluentui-copilot/chat-input-plugins';
import * as React_2 from 'react';
import type { SerializedLexicalNode } from '@fluentui-copilot/text-editor';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';
import type { Spread } from '@fluentui-copilot/text-editor';

export declare function $createChatInputEntityNode<T>(pluginId: string, text: string, data?: T, entityProps?: ChatInputEntityProps, key?: NodeKey): ChatInputEntityNode<T>;

export declare function $createChatInputTokenNode(text: string, componentProps?: ChatInputTokenProps, key?: NodeKey): ChatInputTokenNode;

export declare function $createGhostTextNode(id: string, content: string, exposeText?: boolean, componentProps?: GhostTextProps): GhostTextNode;

export declare function $isChatInputEntityNode<T>(node: LexicalNode | null | undefined): node is ChatInputEntityNode<T>;

export declare function $isChatInputTokenNode(node: LexicalNode | null | undefined): node is ChatInputTokenNode;

export declare function $isGhostTextNode(node: LexicalNode | null | undefined): node is GhostTextNode;

export declare const BasicFunctionalityPlugin: React_2.ForwardRefExoticComponent<BasicFunctionalityPluginProps & React_2.RefAttributes<BasicFunctionalityPluginRef>>;

export declare type BasicFunctionalityPluginProps = {
    trimWhitespace?: boolean;
    onCountChanged?: (count: number) => void;
    onContentChange?: (value: string) => void;
    onPaste?: (event: ClipboardEvent) => void;
    isSentinelNodeEnabled?: boolean;
};

export declare type BasicFunctionalityPluginRef = {
    setIsDisabled: (isDisabled: boolean) => void;
};

export declare const ChatInputEntity: ForwardRefComponent<ChatInputEntityProps>;

export declare const chatInputEntityClassNames: SlotClassNames<ChatInputEntitySlots>;

export declare class ChatInputEntityNode<T> extends DecoratorNode<JSXElement | null> {
    __pluginId: string;
    __text: string;
    __entityProps?: ChatInputEntityProps;
    __data?: T;
    static getType(): string;
    static clone<T>(node: ChatInputEntityNode<T>): ChatInputEntityNode<T>;
    static importJSON<T>(serializedNode: SerializedChatInputEntityNode<T>): ChatInputEntityNode<T>;
    isIsolated(): boolean;
    isInline(): boolean;
    isKeyboardSelectable(): boolean;
    getTextContent(): string;
    exportJSON(): SerializedChatInputEntityNode<T>;
    constructor(pluginId: string, text: string, data?: T, entityProps?: ChatInputEntityProps, key?: NodeKey);
    createDOM(): HTMLElement;
    updateDOM(): boolean;
    decorate(_editor: LexicalEditor, config: EditorConfig): JSXElement | null;
    getEntityData(): ChatInputEntityData<T, ChatInputEntityProps>;
    updateEntityData(data: ChatInputEntityData<T, ChatInputEntityProps>): void;
}

export declare const ChatInputEntityPlugin: <ExtraDataType>(props: ChatInputEntityPluginProps<ExtraDataType, ChatInputEntityProps> & {
    controlRef: React_2.Ref<ChatInputEntityPluginRef<ExtraDataType>>;
}) => null;

export declare type ChatInputEntityPluginRef<ExtraDataType = undefined> = {
    insertChatInputEntity: (props: ChatInputEntityData<ExtraDataType, ChatInputEntityProps>) => string | undefined;
    removeChatInputEntity: (keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, ChatInputEntityProps>, i: number) => boolean)) => void;
    updateChatInputEntityProps: (keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, ChatInputEntityProps>, i: number) => boolean), props: ChatInputEntityData<ExtraDataType, ChatInputEntityProps> | ((oldProps: ChatInputEntityData<ExtraDataType, ChatInputEntityProps>) => ChatInputEntityData<ExtraDataType, ChatInputEntityProps>)) => void;
    getActiveEntities: () => ChatInputEntityData<ExtraDataType, ChatInputEntityProps>[];
};

/**
 * ChatInputEntity Props
 */
export declare type ChatInputEntityProps = ComponentProps<Partial<ChatInputEntitySlots>, 'text'> & {};

export declare type ChatInputEntitySlots = {
    root: NonNullable<Slot<'span'>>;
    text: Slot<'span', 'a'>;
    sensitivity?: Slot<'span'>;
};

/**
 * State used in rendering ChatInputEntity
 */
export declare type ChatInputEntityState = ComponentState<ChatInputEntitySlots>;

export declare const ChatInputToken: ForwardRefComponent<ChatInputTokenProps>;

export declare const chatInputTokenClassNames: SlotClassNames<ChatInputTokenSlots>;

export declare class ChatInputTokenNode extends DecoratorNode<JSXElement | null> {
    __text: string;
    __componentProps?: ChatInputTokenProps;
    static getType(): string;
    static clone(node: ChatInputTokenNode): ChatInputTokenNode;
    static importJSON(serializedNode: SerializedChatInputTokenNode): ChatInputTokenNode;
    isIsolated(): boolean;
    isInline(): boolean;
    getTextContent(): string;
    exportJSON(): SerializedChatInputTokenNode;
    constructor(text: string, componentProps?: ChatInputTokenProps, key?: NodeKey);
    createDOM(): HTMLElement;
    updateDOM(): boolean;
    decorate(_editor: LexicalEditor, config: EditorConfig): JSXElement | null;
}

/**
 * ChatInputToken Props
 */
export declare type ChatInputTokenProps = ComponentProps<ChatInputTokenSlots> & {};

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

/**
 * State used in rendering ChatInputToken
 */
export declare type ChatInputTokenState = ComponentState<ChatInputTokenSlots>;

export declare const GhostText: ForwardRefComponent<GhostTextProps>;

export declare const ghostTextClassNames: SlotClassNames<GhostTextSlots>;

export declare class GhostTextNode extends DecoratorNode<JSXElement | null> {
    __content: string;
    __id: string;
    __allowCommitting?: boolean;
    __componentProps?: GhostTextProps;
    __exposeText?: boolean;
    static clone(node: GhostTextNode): GhostTextNode;
    static getType(): 'ghosttext';
    static importJSON(serializedNode: SerializedGhostTextNode): GhostTextNode;
    exportJSON(): SerializedGhostTextNode;
    constructor(id: string, content: string, exposeText?: boolean, componentProps?: GhostTextProps, key?: NodeKey);
    isInline(): boolean;
    isIsolated(): boolean;
    getTextContent(): string;
    updateDOM(prevNode: unknown, dom: HTMLElement, config: EditorConfig): boolean;
    createDOM(config: EditorConfig): HTMLElement;
    decorate(): JSXElement | null;
}

export declare function GhostTextPlugin(props: GhostTextPluginProps): JSXElement | null;

export declare type GhostTextPluginProps = {
    id: string;
    $getGhostText: (editor: LexicalEditor, editorState: EditorState, prevEditorState: EditorState) => Promise<string | undefined>;
    ghostTextProps?: GhostTextProps;
    exposeText?: boolean;
    allowCompletion?: boolean;
};

/**
 * GhostText Props
 */
export declare type GhostTextProps = ComponentProps<GhostTextSlots> & {
    nodeKey?: string;
};

export declare type GhostTextSlots = {
    root: Slot<'span'>;
    indicator?: Slot<'span'>;
};

/**
 * State used in rendering GhostText
 */
export declare type GhostTextState = ComponentState<GhostTextSlots>;

export declare const ImperativeControlPlugin: React_2.ForwardRefExoticComponent<React_2.RefAttributes<IImperativeControlBase>>;

export declare type ImperativeControlPluginProps = {};

export declare type ImperativeControlPluginRef = IImperativeControlBase;

export declare const ManualGhostTextPlugin: React_2.ForwardRefExoticComponent<ManualGhostTextProps & React_2.RefAttributes<ManualGhostTextRef>>;

export declare type ManualGhostTextProps = {
    id: string;
};

export declare type ManualGhostTextRef = IManualGhostTextBase<GhostTextProps>;

export declare const PasteUnfurlingPlugin: <ExtraDataType>(props: PasteUnfurlingPluginProps<ExtraDataType>) => null;

export declare type PasteUnfurlingPluginProps<ExtraDataType> = Omit<PasteUnfurlingPluginBaseProps<ExtraDataType, ChatInputEntityProps>, '$createEntityNode'> & Pick<Partial<PasteUnfurlingPluginBaseProps<ExtraDataType, ChatInputEntityProps>>, '$createEntityNode'>;

/**
 * Render the final JSX of ChatInputEntity
 */
export declare const renderChatInputEntity_unstable: (state: ChatInputEntityState) => JSXElement;

/**
 * Render the final JSX of ChatInputToken
 */
export declare const renderChatInputToken_unstable: (state: ChatInputTokenState) => JSXElement;

/**
 * Render the final JSX of GhostText
 */
export declare const renderGhostText_unstable: (state: GhostTextState) => JSXElement;

export declare type SerializedChatInputEntityNode<T> = Spread<{
    pluginId: string;
    text: string;
    data?: T;
    entityProps?: ChatInputEntityProps;
}, SerializedLexicalNode>;

export declare type SerializedChatInputTokenNode = Spread<{
    text: string;
    componentProps?: ChatInputTokenProps;
}, SerializedLexicalNode>;

export declare type SerializedGhostTextNode = Spread<{
    content: string;
    id: string;
    componentProps?: GhostTextProps;
    exposeText?: boolean;
}, SerializedLexicalNode>;

/**
 * Create the state required to render ChatInputEntity.
 *
 * The returned state can be modified with hooks such as useChatInputEntityStyles_unstable,
 * before being passed to renderChatInputEntity_unstable.
 *
 * @param props - props from this instance of ChatInputEntity
 * @param ref - reference to root HTMLElement of ChatInputEntity
 */
export declare const useChatInputEntity_unstable: (props: ChatInputEntityProps, ref: React_2.Ref<HTMLSpanElement | HTMLAnchorElement>) => ChatInputEntityState;

/**
 * Apply styling to the ChatInputEntity slots based on the state
 */
export declare const useChatInputEntityStyles_unstable: (state: ChatInputEntityState) => ChatInputEntityState;

/**
 * Create the state required to render ChatInputToken.
 *
 * The returned state can be modified with hooks such as useChatInputTokenStyles_unstable,
 * before being passed to renderChatInputToken_unstable.
 *
 * @param props - props from this instance of ChatInputToken
 * @param ref - reference to root HTMLElement of ChatInputToken
 */
export declare const useChatInputToken_unstable: (props: ChatInputTokenProps, ref: React_2.Ref<HTMLElement>) => ChatInputTokenState;

/**
 * Apply styling to the ChatInputToken slots based on the state
 */
export declare const useChatInputTokenStyles_unstable: (state: ChatInputTokenState) => ChatInputTokenState;

/**
 * Create the state required to render GhostText.
 *
 * The returned state can be modified with hooks such as useGhostTextStyles_unstable,
 * before being passed to renderGhostText_unstable.
 *
 * @param props - props from this instance of GhostText
 * @param ref - reference to root HTMLElement of GhostText
 */
export declare const useGhostText_unstable: (props: GhostTextProps, ref: React_2.Ref<HTMLSpanElement>) => GhostTextState;

/**
 * Apply styling to the GhostText slots based on the state
 */
export declare const useGhostTextStyles_unstable: (state: GhostTextState) => GhostTextState;

export { }