import { MentionItem, SlashCommand, MergeTag, EditorComment } from './text-editor';
interface Revision {
    html: string;
    timestamp: number;
    label: string;
}
interface A11yIssue {
    type: 'error' | 'warning';
    message: string;
    element?: string;
}
declare function exec(command: string, value?: string): void;
declare function toggleDirection(): void;
declare function insertColumns(n: number): void;
declare function toggleDropCap(): void;
declare function insertMath(): void;
declare function addImageCaption(): void;
declare function insertTOC(): void;
declare function exportPdf(): void;
declare function exportMarkdown(): void;
declare function exportText(): void;
declare function insertAnchor(): void;
declare function applyCaseChange(mode: 'upper' | 'lower' | 'title'): void;
declare function activateFormatPainter(): void;
declare function insertDateTime(fmt: string): void;
declare function insertNonBreaking(): void;
declare function applyListStyle(type: string): void;
declare function openPreview(): void;
declare function saveContent(): void;
declare function toggleVisualBlocks(): void;
declare function toggleVisualChars(): void;
declare function sortTableByColumn(ascending: boolean): void;
declare function insertMergeTag(tag: {
    label: string;
    value: string;
}): void;
declare function togglePermanentPen(): void;
declare function addComment(): void;
declare function resolveComment(id: string): void;
declare function deleteComment(id: string): void;
declare function toggleSuggestMode(): void;
declare function acceptSuggestion(el: HTMLElement): void;
declare function rejectSuggestion(el: HTMLElement): void;
declare function acceptAllSuggestions(): void;
declare function rejectAllSuggestions(): void;
declare function openRevisionHistory(): void;
declare function restoreRevision(index: number): void;
declare function closeRevisionHistory(): void;
declare function toggleSpellCheck(): void;
declare function runA11yCheck(): void;
declare function cleanWordHtml(html: string): string;
declare function importWordFile(): void;
declare function exportWordFile(): void;
declare function insertToggleBlock(): void;
declare function insertCallout(type: string): void;
declare function insertAudio(): void;
declare function insertMermaid(): void;
declare function addImageCaptionToggle(): void;
declare function toggleImageLazyLoad(): void;
declare function applyParagraphSpacing(value: string): void;
declare function toggleSmallCaps(): void;
declare function applyLetterSpacing(value: string): void;
declare function insertSoftHyphen(): void;
declare function togglePaginationMode(): void;
declare function exportCleanHtml(): void;
declare function exportEpub(): void;
declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    readonly modelValue: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly placeholder: {
        readonly type: StringConstructor;
        readonly default: "Start writing...";
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly readonly: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly toolbar: {
        readonly type: import('vue').PropType<import('./text-editor').TextEditorToolbarItem[] | false>;
        readonly default: () => import('./text-editor').TextEditorToolbarItem[];
    };
    readonly minHeight: {
        readonly type: StringConstructor;
        readonly default: "200px";
    };
    readonly maxHeight: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly showCharacterCount: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly showWordCount: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly showReadingTime: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly autofocus: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly beforeUpload: {
        readonly type: import('vue').PropType<import('./text-editor').BeforeUploadFn>;
        readonly default: undefined;
    };
    readonly accept: {
        readonly type: StringConstructor;
        readonly default: "image/*";
    };
    readonly maxFileSize: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly mentions: {
        readonly type: import('vue').PropType<MentionItem[]>;
        readonly default: () => never[];
    };
    readonly slashCommands: {
        readonly type: import('vue').PropType<SlashCommand[]>;
        readonly default: () => never[];
    };
    readonly templates: {
        readonly type: import('vue').PropType<import('./text-editor').EditorTemplate[]>;
        readonly default: () => never[];
    };
    readonly mergeTags: {
        readonly type: import('vue').PropType<MergeTag[]>;
        readonly default: () => never[];
    };
    readonly watermarkText: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly autosave: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly autosaveInterval: {
        readonly type: NumberConstructor;
        readonly default: 30000;
    };
    readonly floatingToolbar: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly markdownShortcuts: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autolink: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autocorrect: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly smartTypography: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly spellcheck: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly dateTimeFormats: {
        readonly type: import('vue').PropType<string[]>;
        readonly default: () => string[];
    };
    readonly permanentPenStyle: {
        readonly type: import('vue').PropType<Record<string, string>>;
        readonly default: () => {
            color: string;
            fontWeight: string;
        };
    };
    readonly paginationPageHeight: {
        readonly type: StringConstructor;
        readonly default: "1056px";
    };
}>, {
    focus: () => void | undefined;
    blur: () => void | undefined;
    getHTML: () => string;
    getText: () => string;
    exec: typeof exec;
    editorRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
    exportPdf: typeof exportPdf;
    exportMarkdown: typeof exportMarkdown;
    exportText: typeof exportText;
    insertTOC: typeof insertTOC;
    insertColumns: typeof insertColumns;
    insertMath: typeof insertMath;
    toggleDirection: typeof toggleDirection;
    toggleDropCap: typeof toggleDropCap;
    insertAnchor: typeof insertAnchor;
    addImageCaption: typeof addImageCaption;
    applyCaseChange: typeof applyCaseChange;
    activateFormatPainter: typeof activateFormatPainter;
    insertDateTime: typeof insertDateTime;
    insertNonBreaking: typeof insertNonBreaking;
    applyListStyle: typeof applyListStyle;
    openPreview: typeof openPreview;
    saveContent: typeof saveContent;
    toggleVisualBlocks: typeof toggleVisualBlocks;
    toggleVisualChars: typeof toggleVisualChars;
    sortTableByColumn: typeof sortTableByColumn;
    insertMergeTag: typeof insertMergeTag;
    togglePermanentPen: typeof togglePermanentPen;
    addComment: typeof addComment;
    resolveComment: typeof resolveComment;
    deleteComment: typeof deleteComment;
    toggleSuggestMode: typeof toggleSuggestMode;
    acceptSuggestion: typeof acceptSuggestion;
    rejectSuggestion: typeof rejectSuggestion;
    acceptAllSuggestions: typeof acceptAllSuggestions;
    rejectAllSuggestions: typeof rejectAllSuggestions;
    openRevisionHistory: typeof openRevisionHistory;
    restoreRevision: typeof restoreRevision;
    closeRevisionHistory: typeof closeRevisionHistory;
    toggleSpellCheck: typeof toggleSpellCheck;
    runA11yCheck: typeof runA11yCheck;
    importWordFile: typeof importWordFile;
    exportWordFile: typeof exportWordFile;
    cleanWordHtml: typeof cleanWordHtml;
    suggestMode: import('vue').Ref<boolean, boolean>;
    comments: import('vue').Ref<{
        id: string;
        author: string;
        text: string;
        timestamp: number;
        resolved?: boolean | undefined;
        replies?: {
            author: string;
            text: string;
            timestamp: number;
        }[] | undefined;
    }[], EditorComment[] | {
        id: string;
        author: string;
        text: string;
        timestamp: number;
        resolved?: boolean | undefined;
        replies?: {
            author: string;
            text: string;
            timestamp: number;
        }[] | undefined;
    }[]>;
    revisions: import('vue').Ref<{
        html: string;
        timestamp: number;
        label: string;
    }[], Revision[] | {
        html: string;
        timestamp: number;
        label: string;
    }[]>;
    formatPainterActive: import('vue').Ref<boolean, boolean>;
    permanentPenActive: import('vue').Ref<boolean, boolean>;
    spellCheckActive: import('vue').Ref<boolean, boolean>;
    showVisualBlocks: import('vue').Ref<boolean, boolean>;
    showVisualChars: import('vue').Ref<boolean, boolean>;
    showCommentsSidebar: import('vue').Ref<boolean, boolean>;
    showRevisionHistory: import('vue').Ref<boolean, boolean>;
    showA11yResults: import('vue').Ref<boolean, boolean>;
    a11yIssues: import('vue').Ref<{
        type: "error" | "warning";
        message: string;
        element?: string | undefined;
    }[], A11yIssue[] | {
        type: "error" | "warning";
        message: string;
        element?: string | undefined;
    }[]>;
    insertToggleBlock: typeof insertToggleBlock;
    insertCallout: typeof insertCallout;
    insertAudio: typeof insertAudio;
    insertMermaid: typeof insertMermaid;
    addImageCaptionToggle: typeof addImageCaptionToggle;
    toggleImageLazyLoad: typeof toggleImageLazyLoad;
    applyParagraphSpacing: typeof applyParagraphSpacing;
    toggleSmallCaps: typeof toggleSmallCaps;
    applyLetterSpacing: typeof applyLetterSpacing;
    insertSoftHyphen: typeof insertSoftHyphen;
    togglePaginationMode: typeof togglePaginationMode;
    exportCleanHtml: typeof exportCleanHtml;
    exportEpub: typeof exportEpub;
    isPaginationMode: import('vue').Ref<boolean, boolean>;
    imageLazyLoadEnabled: import('vue').Ref<boolean, boolean>;
    showCalloutPicker: import('vue').Ref<boolean, boolean>;
    showAudioInput: import('vue').Ref<boolean, boolean>;
    showMermaidInput: import('vue').Ref<boolean, boolean>;
    showParagraphSpacing: import('vue').Ref<boolean, boolean>;
    showLetterSpacing: import('vue').Ref<boolean, boolean>;
    calloutTypes: {
        type: string;
        icon: string;
        label: string;
        color: string;
    }[];
    paragraphSpacingPresets: {
        label: string;
        value: string;
    }[];
    letterSpacingPresets: {
        label: string;
        value: string;
    }[];
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    "update:modelValue": (value: string) => void;
    focus: (event: FocusEvent) => void;
    blur: (event: FocusEvent) => void;
    change: (value: string) => void;
    save: (value: string) => void;
    autosave: (value: string) => void;
    uploadError: (error: Error, file: File) => void;
    mention: (item: MentionItem) => void;
    comment: (comment: EditorComment) => void;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    readonly modelValue: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly placeholder: {
        readonly type: StringConstructor;
        readonly default: "Start writing...";
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly readonly: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly toolbar: {
        readonly type: import('vue').PropType<import('./text-editor').TextEditorToolbarItem[] | false>;
        readonly default: () => import('./text-editor').TextEditorToolbarItem[];
    };
    readonly minHeight: {
        readonly type: StringConstructor;
        readonly default: "200px";
    };
    readonly maxHeight: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly showCharacterCount: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly showWordCount: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly showReadingTime: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly autofocus: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly beforeUpload: {
        readonly type: import('vue').PropType<import('./text-editor').BeforeUploadFn>;
        readonly default: undefined;
    };
    readonly accept: {
        readonly type: StringConstructor;
        readonly default: "image/*";
    };
    readonly maxFileSize: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly mentions: {
        readonly type: import('vue').PropType<MentionItem[]>;
        readonly default: () => never[];
    };
    readonly slashCommands: {
        readonly type: import('vue').PropType<SlashCommand[]>;
        readonly default: () => never[];
    };
    readonly templates: {
        readonly type: import('vue').PropType<import('./text-editor').EditorTemplate[]>;
        readonly default: () => never[];
    };
    readonly mergeTags: {
        readonly type: import('vue').PropType<MergeTag[]>;
        readonly default: () => never[];
    };
    readonly watermarkText: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly autosave: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly autosaveInterval: {
        readonly type: NumberConstructor;
        readonly default: 30000;
    };
    readonly floatingToolbar: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly markdownShortcuts: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autolink: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autocorrect: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly smartTypography: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly spellcheck: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly dateTimeFormats: {
        readonly type: import('vue').PropType<string[]>;
        readonly default: () => string[];
    };
    readonly permanentPenStyle: {
        readonly type: import('vue').PropType<Record<string, string>>;
        readonly default: () => {
            color: string;
            fontWeight: string;
        };
    };
    readonly paginationPageHeight: {
        readonly type: StringConstructor;
        readonly default: "1056px";
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
    onFocus?: ((event: FocusEvent) => any) | undefined;
    onBlur?: ((event: FocusEvent) => any) | undefined;
    onChange?: ((value: string) => any) | undefined;
    onSave?: ((value: string) => any) | undefined;
    onAutosave?: ((value: string) => any) | undefined;
    onUploadError?: ((error: Error, file: File) => any) | undefined;
    onMention?: ((item: MentionItem) => any) | undefined;
    onComment?: ((comment: EditorComment) => any) | undefined;
}>, {
    readonly disabled: boolean;
    readonly modelValue: string;
    readonly placeholder: string;
    readonly readonly: boolean;
    readonly autofocus: boolean;
    readonly maxHeight: string;
    readonly spellcheck: boolean;
    readonly accept: string;
    readonly minHeight: string;
    readonly beforeUpload: import('./text-editor').BeforeUploadFn;
    readonly mergeTags: MergeTag[];
    readonly toolbar: false | import('./text-editor').TextEditorToolbarItem[];
    readonly showCharacterCount: boolean;
    readonly showWordCount: boolean;
    readonly showReadingTime: boolean;
    readonly maxFileSize: number;
    readonly mentions: MentionItem[];
    readonly slashCommands: SlashCommand[];
    readonly templates: import('./text-editor').EditorTemplate[];
    readonly watermarkText: string;
    readonly autosave: boolean;
    readonly autosaveInterval: number;
    readonly floatingToolbar: boolean;
    readonly markdownShortcuts: boolean;
    readonly autolink: boolean;
    readonly autocorrect: boolean;
    readonly smartTypography: boolean;
    readonly dateTimeFormats: string[];
    readonly permanentPenStyle: Record<string, string>;
    readonly paginationPageHeight: string;
}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
    fileInputRef: HTMLInputElement;
    fileAttachInputRef: HTMLInputElement;
    wordFileInputRef: HTMLInputElement;
    videoInputRef: HTMLInputElement;
    linkInputRef: HTMLInputElement;
    imageInputRef: HTMLInputElement;
    audioInputRef: HTMLInputElement;
    editorRef: HTMLDivElement;
    commentInputRef: HTMLInputElement;
}, HTMLDivElement>;
export default _default;