import type { CommandListener, CommandListenerPriority, EditorSetOptions, EditorState, EditorUpdateOptions, Klass, LexicalCommand, LexicalEditor, LexicalNode, MutationListener, NodeKey, TextFormatType, Transform } from 'lexical';
import type { JsonValue } from 'type-fest';
import type { CSSProperties } from 'vue';
import type { RichTextEditorComponentNodeData, RichTextEditorContentItem, RichTextEditorContentSnapshot, RichTextEditorFocusOptions, RichTextEditorInsertOptions, RichTextEditorMutationListenerOptions, RichTextEditorProps, RichTextEditorSlots, RichTextEditorValue } from './types';
type __VLS_Slots = RichTextEditorSlots;
declare function dispatchCommand<T>(command: LexicalCommand<T>, payload: T): boolean;
declare function registerCommand<T>(command: LexicalCommand<T>, listener: CommandListener<T>, priority: CommandListenerPriority): () => void;
declare function registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: Transform<T>): () => void;
declare const __VLS_base: import("vue").DefineComponent<RichTextEditorProps, {
    readonly editor: LexicalEditor | null;
    readonly editorState: EditorState | null;
    readonly rootElement: HTMLDivElement | null;
    readonly canUndo: boolean;
    readonly canRedo: boolean;
    focus: (callback?: () => void, options?: RichTextEditorFocusOptions) => void;
    blur: () => void | undefined;
    clear: () => void;
    undo: () => boolean;
    redo: () => boolean;
    getJSON: () => import("lexical").SerializedEditorState<import("lexical").SerializedLexicalNode> | undefined;
    setJSON: (value: RichTextEditorValue | string, options?: EditorSetOptions) => void;
    getContent: () => RichTextEditorContentSnapshot[];
    setContent: (content: readonly RichTextEditorContentItem[], options?: EditorUpdateOptions) => void;
    insertContent: (content: readonly RichTextEditorContentItem[], options?: RichTextEditorInsertOptions) => void;
    getText: () => string;
    getHTML: () => string;
    setHTML: (html: string, options?: EditorUpdateOptions) => void;
    getMarkdown: (transformers?: readonly import("@lexical/markdown").Transformer[]) => string;
    setMarkdown: (markdown: string, transformers?: readonly import("@lexical/markdown").Transformer[], options?: EditorUpdateOptions) => void;
    insertText: (text: string, options?: RichTextEditorInsertOptions) => void;
    insertComponent: (data: RichTextEditorComponentNodeData, options?: RichTextEditorInsertOptions) => void;
    updateComponent: (nodeKey: NodeKey, value: JsonValue, options?: EditorUpdateOptions) => void;
    removeComponent: (nodeKey: NodeKey, options?: EditorUpdateOptions) => void;
    formatText: (format: TextFormatType) => boolean;
    read: <T>(callback: () => T) => T | undefined;
    update: (callback: () => void, options?: EditorUpdateOptions) => void | undefined;
    dispatchCommand: typeof dispatchCommand;
    registerCommand: typeof registerCommand;
    registerUpdateListener: (listener: import("lexical").UpdateListener) => () => void;
    registerMutationListener: (klass: Klass<LexicalNode>, listener: MutationListener, options?: RichTextEditorMutationListenerOptions) => () => void;
    registerNodeTransform: typeof registerNodeTransform;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    update: (context: import("./types").RichTextEditorChangeContext) => any;
    error: (error: Error) => any;
    focus: (event: FocusEvent) => any;
    blur: (event: FocusEvent) => any;
    change: (value: RichTextEditorValue, context: import("./types").RichTextEditorChangeContext) => any;
    "update:modelValue": (value: RichTextEditorValue) => any;
    ready: (editor: LexicalEditor) => any;
}, string, import("vue").PublicProps, Readonly<RichTextEditorProps> & Readonly<{
    onUpdate?: ((context: import("./types").RichTextEditorChangeContext) => any) | undefined;
    onError?: ((error: Error) => any) | undefined;
    onFocus?: ((event: FocusEvent) => any) | undefined;
    onBlur?: ((event: FocusEvent) => any) | undefined;
    onChange?: ((value: RichTextEditorValue, context: import("./types").RichTextEditorChangeContext) => any) | undefined;
    "onUpdate:modelValue"?: ((value: RichTextEditorValue) => any) | undefined;
    onReady?: ((editor: LexicalEditor) => any) | undefined;
}>, {
    classNames: Partial<Record<import("./types").RichTextEditorSemanticType, string>>;
    autoSize: boolean | import("./types").RichTextEditorAutoSize;
    styles: Partial<Record<import("./types").RichTextEditorSemanticType, CSSProperties>>;
    plugins: readonly import("./types").RichTextEditorPlugin[];
    transformers: readonly import("@lexical/markdown").Transformer[];
    history: boolean;
    historyDelay: number;
    historyMaxDepth: number | null;
    spellcheck: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
declare const _default: typeof __VLS_export;
export default _default;
type __VLS_WithSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};