/// <reference types="node" />
import { IImageOptions } from "../../commons/doc2docx";
import "./patch/intersection-observer";
import AttributeMap from 'quill-delta/dist/AttributeMap';
import { AuthMessage, AuthPermission } from "../../commons/auth-message";
import { TemplateValues } from "../../commons/template";
import { GetReferenceClientRect, Placement } from 'tippy.js';
import RichTextOperations from "./text/RichTextOperations";
import RichTextDocument from "./text/RichTextDocument";
import { DocComment, DocBlock, BlockLockInfo, EditorDoc, BlockBase, DocVersion, LinkDetails, TextAlign, OnProgress, EditorOp, Doc2MarkdownOptionalOptions } from "./ot/index";
import MenuItem from "./ui/MenuItem";
import FindDialog from "./find/FindDialog";
import { ICON_KEY } from "./utils/icons";
export { RichTextOperations, RichTextDocument };
export { MenuItem };
export { docData2Text } from "../../commons/doc2text";
export { markdown2Doc } from "../../commons/markdown2doc";
export { DocComment, DocBlock, BlockLockInfo, EditorDoc, TextAlign, DocVersion, LinkDetails, OnProgress, Op, EditorOp, EditorChangeSet, Doc2MarkdownOptionalOptions, } from "./ot/index";
export { getListNumber } from "../../commons/list-number";
export { IImageOptions };
declare global {
    interface Element {
        scrollIntoViewIfNeeded?: () => void;
    }
    interface Window {
        disableVideo?: boolean;
        disableAudio?: boolean;
    }
    interface CSSStyleDeclaration {
        zoom: string;
    }
}
export declare class AccessDeniedError extends Error {
    constructor();
}
export declare class NotSupportError extends Error {
    constructor(message?: string, code?: string);
}
export declare class InvalidParamError extends Error {
    constructor(message?: string);
}
export declare type RichTextElement = HTMLElement & {
    __neverUse: 'RichTextElement';
};
export declare type RootElement = HTMLDivElement & {
    __neverUse: 'RootElement';
};
export declare type ContainerElement = HTMLDivElement & {
    __neverUse: 'ContainerElement';
};
export declare type BlockElement = HTMLDivElement & {
    __neverUse: 'BlockElement';
};
export declare type BlockContentElement = HTMLElement & {
    __neverUse: 'BlockContentElement';
};
export declare type BlockToolsElement = HTMLDivElement & {
    __neverUse: 'BlockToolsElement';
};
export declare type EmbedElement = HTMLElement & {
    __neverUse: 'EmbedElement';
};
export declare type BoxElement = HTMLSpanElement & {
    __neverUse: 'BoxElement';
};
export declare type TextAttributes = AttributeMap;
export declare enum BLOCK_ATTR {
    NODE_TYPE = "data-node-type",
    BLOCK_TYPE = "data-block-type",
    BOX_TYPE = "data-box-type",
    EMBED_TYPE = "data-embed-type"
}
export declare enum NODE_TYPE {
    CONTAINER = "container",
    BLOCK = "block",
    BOX = "box",
    EMBED = "embed"
}
export declare enum EDITOR_EVENT {
    RESIZE = "resize",
    THEME_MODE_CHANGE = "themeModeChange",
    ELEMENT_REMOVE = "elementRemove"
}
export declare enum BLOCK_TYPE {
    TEXT = "text",
    HEADING = "heading",
    LIST = "list",
    TABLE = "table",
    EMBED = "embed",
    CODE_LINE = "code-line",
    CODE = "code"
}
export declare enum BOX_TYPE {
    FAKE_CARET = "fake-caret",
    TAG = "tag",
    WIKI_LINK = "wiki-link",
    MENTION = "mention",
    MATH = "math",
    CALENDAR = "calendar",
    LOADING = "loading",
    INPUT = "input",
    FILE = "file",
    HISTORY_DELETED = "history-deleted",
    BR = "br",
    IMAGE = "image",
    ANCHOR = "anchor"
}
export declare enum INPUT_DIALOG_CLASS {
    Content = "dialog-input-content"
}
export declare enum EDITOR_CLASS {
    AUTO_DARK_MODE = "auto-dark-mode",
    DARK_MODE = "dark-mode",
    AUTO_WRAP = "auto-wrap",
    ACTIVE = "active",
    HIDDEN = "editor-hidden",
    READONLY = "editor-readonly",
    ALERT = "alert",
    ERROR = "error",
    RETRY = "retry",
    UPLOAD_ERROR = "upload-error",
    BUTTON = "editor-button",
    BUTTON_CANCEL = "editor-button-cancel",
    ENTIRE_SELECTED = "editor-entire-selected",
    SUB_ITEMS_ACTIVE = "sub-items-active",
    BLOCK = "editor-block",
    BLOCK_CONTENT = "block-content",
    BLOCK_MENU_BUTTON = "block-menu-button",
    BLOCK_TOOLS = "block-tools",
    BLOCK_POSITION_MARKING_LINE = "block-position-marking-line",
    BLOCK_ENTIRE_HOVER = "block-entire-hover",
    BUTTON_CONTAINER = "editor-button-container",
    BUTTON_SPLIT = "editor-toolbar-split-line",
    POPOVER_DIALOG_CONTAINER = "editor-popover-dialog-container",
    MENU_CONTAINER = "editor-menu-container",
    MENU_SCROLL_CONTAINER = "editor-menu-scroll-container",
    MENU_SPLIT = "menu-split",
    MENU_FONT_COLOR = "menu-font-color",
    COMMAND_ITEM = "editor-command-item",
    CLICKABLE_ITEM = "clickable-item",
    CHECKBOX = "editor-checkbox",
    CHECKED = "editor-checked",
    COMMENT = "comment",
    COMMENT_IS_ACTIVE = "editor-comment-active",
    COMMENT_IS_MINI = "editor-comment-mini",
    COMMENT_ID = "comment-id",
    COMMENT_EDITOR = "comment-editor",
    COMMENT_READY = "comment-ready",
    SHOW_MOBILE_COMMENT = "show-mobile-comments",
    HIDE_SCROLLBAR = "hide-scrollbar",
    COMPOSITION = "editor-composition",
    COMPOSITING = "editor-compositing",
    CONTAINER = "editor-container",
    DISABLED = "disabled",
    DIALOG_INPUT_CONTAINER = "dialog-input-container",
    EDITOR_MAIN = "editor-main",
    EMBED = "editor-embed",
    EMBED_CONTAINER = "embed-container",
    EMPTY_BLOCK = "empty-block",
    FILE_CONTENT = "file-content",
    FOCUSED = "focused",
    HIDE_LINE_NUMBER = "editor-hide-line-number",
    HOVER = "hover",
    ICON_BUTTON = "editor-icon-button",
    IGNORE = "editor-ignore",
    IMAGE_LOADING = "image-loading",
    IMAGE_ERROR = "image-error",
    IMAGE_EMPTY = "image-empty",
    NO_BORDER = "table-no-border",
    LINK = "link",
    TOC_LINK = "editor-toc-link",
    LOCKED_BY_USER = "locked-by-user",
    LOCKED_READONLY = "locked-readonly",
    ROOT_CONTAINER = "root-container",
    ROOT_CONTAINER_EXTEND = "root-container-extend",
    ROOT_CONTAINER_CUSTOM = "root-container-custom",
    SUB_ITEMS_CONTAINER = "editor-sub-items-container",
    BLOCK_SCROLL_BAR = "editor-block-scrollbar",
    BLOCK_LEFT_OVERFLOW = "editor-block-left-overflow",
    TABLE_SELECTION_MASK = "table-selection-mask",
    TABLE_CONTROL_BAR = "table-control-bar",
    TABLE_TOOLBAR = "table-toolbar",
    TABLE_TOOLBAR_ACTIVE = "table-toolbar-active",
    TABLE_COL_GROUP = "table-col-group",
    TABLE_RESIZE_TOOL = "table-resize-tool",
    TEXT_BUTTON = "editor-text-button",
    UNCHECKED = "editor-unchecked",
    QUICK_EDITABLE_ELEMENT = "editor-quick-editable",
    UNORDERED = "list-ul",
    ORDERED = "list-ol",
    SHOW_FULL_SCREEN_IFRAME = "show_full_screen_iframe",
    FOCUS_MODE = "editor-focus-mode",
    TYPEWRITER_MODE = "editor-typewriter-mode",
    FULLSCREEN = "editor-fullscreen",
    ALIGN_LEFT = "editor-align-left",
    ALIGN_RIGHT = "editor-align-right",
    ALIGN_CENTER = "editor-align-center",
    ALIGN_JUSTIFY = "editor-align-justify",
    FLASH = "editor-block-blink",
    SLIDING_TOOLS = "block-siding-tools",
    SLIDING_TOOLS_CONTAINER = "sliding-tool-view-window",
    TOOLTIP = "editor-tooltip",
    ON_DRAGGING = "on-dragging",
    HISTORY = "history",
    STRIPE_STYLE_TABLE = "stripe-style-table",
    ROW_TITLE_TABLE = "row-title-table",
    COL_TITLE_TABLE = "col-title-table",
    COL_TITLE_ITEM = "col-title-item",
    POPOVER_INPUT = "editor-popover-input",
    POPOVER_BUTTON = "editor-popover-button",
    POPOVER_CANCEL_BUTTON = "editor-popover-cancel-button"
}
export declare const FILL_CHAR = "\u200B";
export declare const FILL_CHAR_REG: RegExp;
export declare const SPACE_CHAR = "\u00A0";
export declare const SPACE_CHAR_REG: RegExp;
export declare const MARKER_TOOLBAR_HEIGHT = 44;
export declare const MARKER_WIDTH_EXPAND = 12;
export declare const MARKER_HEIGHT_EXPAND = 24;
export declare type BlockTypes = BLOCK_TYPE.TEXT | BLOCK_TYPE.HEADING | BLOCK_TYPE.LIST | BLOCK_TYPE.EMBED | BLOCK_TYPE.TABLE | BLOCK_TYPE.CODE | BLOCK_TYPE.CODE_LINE;
export interface BlockData extends BlockBase {
    text?: RichTextDocument;
}
export interface BlockTemplateData {
    [index: string]: any;
    text?: RichTextDocument;
}
export interface CompositionData {
    block: BlockElement | null;
    complexBlock: BlockElement | null;
    endTime: number | null;
}
export interface BoxData {
    box: true;
    id: string;
    type: BOX_TYPE;
    created: number;
    fake?: boolean;
}
export interface InputBoxItem {
    text: string;
    value: string;
}
export interface QuickInsertMenuTrigger {
    '/'?: boolean;
    '、'?: boolean;
    '+'?: boolean;
}
export interface BoxTemplateData {
    [index: string]: string | boolean | number | InputBoxItem[] | undefined | string[];
}
export interface ImageBoxTemplateData extends BoxTemplateData {
    src: string;
    link?: string;
    width: number | undefined;
    height: number | undefined;
}
export interface ImageBoxData extends BoxData {
    src: string;
    link?: string;
    width: number;
    height: number | undefined;
}
export interface WikiLinkBoxTemplateData extends BoxTemplateData {
    name: string;
    secondaryName?: string;
    linkId?: string;
    blockId?: string;
}
export interface WikiLinkBoxData extends BoxData, WikiLinkBoxTemplateData {
}
export interface WikiLinkItem {
    linkId: string;
    name: string;
    iconUrl?: string;
    parts?: {
        text: string;
        highlight: boolean;
    }[];
    secondaryName?: string;
}
export interface InputBoxData extends BoxData {
    label?: string;
    inputId: string;
    inputType: 'text' | 'select' | 'checkbox';
    value?: string;
    items?: InputBoxItem[];
    width?: number;
    classes?: string[];
    checked?: boolean;
    disabled?: boolean;
    placeholder?: string;
    customData?: string;
    inlineStyle?: string;
}
export interface TextInputBoxTemplateData extends BoxTemplateData {
    label?: string;
    value?: string;
    inputId: string;
    width?: number;
    classes?: string[];
    disabled?: boolean;
    customData?: string;
    placeholder?: string;
}
export interface CheckInputBoxTemplateData extends BoxTemplateData {
    label?: string;
    value?: string;
    inputId: string;
    width?: number;
    classes?: string[];
    checked?: boolean;
    disabled?: boolean;
    customData?: string;
}
export interface SelectBoxTemplateData extends BoxTemplateData {
    label?: string;
    value?: string;
    inputId: string;
    width?: number;
    classes?: string[];
    items: InputBoxItem[];
    disabled?: boolean;
    customData?: string;
}
export interface ContainerData {
    id: string;
    blocks: BlockData[];
}
export interface CaretPosOneSide {
    containerId: string;
    blockId: string;
    offset: number;
}
export interface BlockOptions {
    textBlock?: boolean;
    complexBlock?: boolean;
    prefix?: string;
    icon?: string;
    disableQuickInput?: boolean;
}
export declare enum DialogInputType {
    INPUT = "input",
    TEXTAREA = "textarea"
}
export interface DialogOptions {
    type: 'dialog';
    content: HTMLElement;
    data?: any;
    mainClass?: string;
    contentClass?: string;
    onShown?: (data: any) => void;
    onHidden?: (data: any) => void;
}
export interface PopoverDialogOptions extends Omit<DialogOptions, 'type'> {
    popoverOptions: Omit<PopoverOptions, 'content' | 'maskTarget' | 'parentPopover'>;
    placementCenter?: boolean;
    disableEscape?: boolean;
}
export interface StandardDialogOptions {
    type: 'standard';
    content: HTMLElement;
    title: string;
    data?: any;
    containerClasses?: string[];
    showCloseButton?: boolean;
    onShown?: (data: any) => void;
    onHidden?: (data: any) => void;
    onOK: (data: any) => Promise<boolean>;
    onCancel: (data: any) => void;
}
export interface InputOptionsForDialog {
    id: string;
    defaultValue: string;
    inputPlaceholder?: string;
    inputType: DialogInputType;
    inputDescription?: string;
    inputDescriptionInfo?: string;
    inputExtActions?: HTMLElement;
    required?: boolean;
    secondaryText?: HTMLElement;
    secondaryTextOnTop?: boolean;
}
export interface InputSubmitValueForDialog {
    options: InputOptionsForDialog;
    value: string;
}
export interface StandardInputDialog {
    type: 'input';
    inputList: InputOptionsForDialog[];
    title: string;
    data?: any;
    showCloseButton?: boolean;
    containerClasses?: string[];
    autoFocus?: boolean;
    onShown?: (data: any) => void;
    onHidden?: (data: any) => void;
    onOK: (data: any, inputValue: InputSubmitValueForDialog[]) => Promise<boolean | {
        inputOptions: InputOptionsForDialog;
        error: Error;
    }>;
    onCancel: (data: any) => void;
}
export interface StandardConfirmDialog {
    type: 'confirm';
    text: string;
    title: string;
    data?: any;
    containerClasses?: string[];
    onShown?: (data: any) => void;
    onHidden?: (data: any) => void;
    onOK: (data: any, ...args: any) => Promise<boolean>;
    onCancel: (data: any) => void;
}
export declare abstract class Dialog {
    abstract restoreSelectionState(): void;
    abstract show(options: DialogOptions): void;
    abstract hide(): void;
    abstract isVisible(): boolean;
}
export interface PopoverOptions {
    commandTarget: Node;
    popoverTarget: HTMLElement;
    maskTarget: HTMLElement | null;
    parentPopover: HTMLElement | null;
    content: HTMLElement;
    autoShow?: boolean;
    autoHide?: boolean;
    hideOnClick?: boolean;
    interactive?: boolean;
    interactiveBorder?: number;
    delay?: number | [number | null, number | null];
    placement?: Placement;
    fallbackPlacements?: Placement[];
    offset?: [number, number] | undefined;
    arrow?: boolean;
    theme?: string;
    zIndex?: number;
    showMask?: boolean;
    trigger?: string;
    getReferenceClientRect?: GetReferenceClientRect;
    followCursor?: boolean;
    maxWidth?: string | number;
    refuseOverflow?: boolean;
    overflowBoundary?: Element;
}
export declare abstract class Hidable {
    abstract destroy(): void;
    abstract hide(forcedToHide?: boolean): void;
    abstract isVisible(): boolean;
    abstract handleMouseMove(event: MouseEvent): boolean;
    abstract on(event: 'hide' | 'show', callback: (...args: any[]) => void): void;
}
export declare abstract class Popover extends Hidable {
    abstract create(options: PopoverOptions): void;
}
export declare abstract class Menu extends Hidable {
    abstract createAutoHideMenu(commandTarget: Node, popoverTarget: HTMLElement, maskTarget: HTMLElement | null, items: CommandItemData[], options?: MenuOptions): void;
    abstract createContextMenu(event: MouseEvent, commandTarget: HTMLElement, items: CommandItemData[]): void;
}
export declare abstract class BlockMenuButton {
    abstract destroy(): void;
    abstract show(block?: BlockElement): void;
    abstract handleMouseMove(event: MouseEvent): boolean;
    abstract handleSelectionChanged(detail: SelectionDetail): boolean;
    abstract isShowMenu(): boolean;
    abstract updatedXOffset(): void;
}
export interface ToolbarOptions {
    placement?: Placement;
    hideOnClicking?: boolean;
    autoHide?: boolean;
    offset?: [number, number] | undefined;
    popoverOptions?: any;
    arrow?: boolean;
}
export interface MenuOptions {
    autoHide?: boolean;
    autoShow?: boolean;
    showMask?: boolean;
    trigger?: string;
    onShown?: (data: any) => void;
    onHidden?: (data: any) => void;
}
export declare abstract class Toolbar extends Hidable {
    abstract createAutoHideToolbar(commandTarget: Node, popoverTarget: HTMLElement, items: CommandItemData[]): void;
    abstract createManualHideToolbar(commandTarget: Node, popoverTarget: HTMLElement, items: CommandItemData[], options: ToolbarOptions): void;
    abstract updateStatus(editor: Editor, status: CommandStatus): void;
}
export declare abstract class TextToolbar extends Hidable {
    abstract isVisibleForTextBlock(): boolean;
    abstract isMyPopover(popover: Popover): boolean;
    abstract update(editor: Editor, force: boolean, event: MouseEvent | null): void;
    abstract updateStatus(editor: Editor, status: CommandStatus): void;
    abstract updatePosition(): void;
}
export declare abstract class EditableToolbar extends Hidable {
}
export interface AutoSuggestData {
    iconUrl: string;
    text: string;
    id: string;
    data: any;
    order?: number;
    disabled?: boolean;
    autoWrap?: boolean;
    subText?: string;
    className?: string;
    parts?: {
        text: string;
        highlight: boolean;
    }[];
    placeholder?: boolean;
}
export interface AutoSuggestOptions {
    target: HTMLElement;
    keyword: string;
    placeholder: string;
    placeholderNoMatch: string;
    customSuggest: boolean;
    customSuggestTheme?: string;
    customType?: string;
    boxClass: Box;
    getSuggest: (keyword: string) => Promise<AutoSuggestData[]>;
    selectSuggest: (target: HTMLElement, autoSuggestData: AutoSuggestData) => void;
    renderSuggestItem?: (editor: Editor, autoSuggestData: AutoSuggestData, options: AutoSuggestOptions) => HTMLElement;
    renderSuggestHeader?: (editor: Editor, autoSuggestData: AutoSuggestData[], options: AutoSuggestOptions, renderOptions: {
        loading: boolean;
    }) => HTMLElement | null;
    renderSuggestFooter?: (editor: Editor, autoSuggestData: AutoSuggestData[], options: AutoSuggestOptions, renderOptions: {
        loading: boolean;
    }) => HTMLElement | null;
    renderLoading?: (editor: Editor, keywords: string, exitsContent: HTMLElement, autoSuggestData: AutoSuggestData[], options: AutoSuggestOptions) => HTMLElement | null;
    enableSelectItem?: boolean;
    onHidden?: (options: AutoSuggestOptions, data: any) => void;
    onReturn: (options: AutoSuggestOptions) => boolean;
    suggestMaxHeight?: number;
    data?: any;
}
export declare abstract class AutoSuggest {
    abstract destroy(): void;
    abstract show(blockTools: BlockToolsElement, boxElement: BoxElement | null, options: AutoSuggestOptions, customData: any): void;
    abstract updateKeyword(keyword: string): void;
    abstract hide(): void;
    abstract isVisible(): boolean;
    abstract isInPopper(target: Node | null): boolean;
    abstract isInBlock(block: BlockElement): boolean;
    abstract rootElement(): HTMLElement | undefined;
    abstract getCustomData(): any;
    abstract handleKeydown(event: KeyboardEvent): boolean;
    abstract handleMouseMove(event: MouseEvent): boolean;
    abstract handleMouseDown(event: MouseEvent): boolean;
    abstract handleMouseUp(event: MouseEvent): boolean;
    abstract options(): AutoSuggestOptions;
}
export interface TooltipOptions {
    getContent?: (target: Element, customData: any) => Element | string;
}
export declare abstract class Tooltip {
    abstract destroy(): void;
    abstract show(target: Element, options: TooltipOptions, customData: any): void;
    abstract hide(): void;
    abstract isVisible(): boolean;
    abstract rootElement(): HTMLElement | undefined;
    abstract handleMouseMove(event: MouseEvent, options: TooltipOptions): boolean;
}
export declare type StyleColor = 'style-color-0' | 'style-color-1' | 'style-color-2' | 'style-color-3' | 'style-color-4' | 'style-color-5' | 'style-color-6';
export declare type StyleBgColor = 'style-bg-color-0' | 'style-bg-color-1' | 'style-bg-color-2' | 'style-bg-color-3' | 'style-bg-color-4' | 'style-bg-color-5' | 'style-bg-color-6' | 'style-bg-color-7' | 'style-bg-color-8' | 'style-bg-color-9' | 'style-bg-color-10' | 'style-bg-color-11' | 'style-bg-color-12' | 'style-bg-color-13';
export interface CommandItemData {
    id: string;
    text: string;
    infoText?: string;
    icon?: string;
    className?: string;
    color?: StyleColor;
    bgColor?: StyleBgColor;
    data?: any;
    shortCut?: string;
    disabled?: boolean;
    checked?: boolean;
    subItemsType?: 'menu' | 'button';
    subItems?: CommandItemData[];
    subItemsArrow?: boolean;
    element?: HTMLElement;
    groupHeader?: boolean;
    order?: number;
    supportMarkdown?: boolean;
    showIconAndText?: boolean;
    onClick?: (event: Event, item: CommandItemData) => void;
    updateStatus?: (editor: Editor, item: CommandItemData, status: CommandStatus) => void;
}
export declare const ITEM_SEP: CommandItemData;
export interface ItemElement {
    updateStatus(editor: Editor, status: CommandStatus): void;
}
export declare abstract class ContextMenu {
    abstract destroy(): void;
    abstract handleContextMenu(event: MouseEvent, editor: Editor): boolean;
    abstract isVisible(): boolean;
    abstract hide(forcedToHide: boolean): void;
}
export declare abstract class FloatMenu {
    popover?: Menu;
    abstract destroy(): void;
    abstract show(editor: Editor, commandTarget: Node, popoverTarget: HTMLElement, items: CommandItemData[], options: MenuOptions): void;
    abstract hide(): void;
    abstract isVisible(commandTarget: Node, popoverTarget: HTMLElement): boolean;
}
export declare type LANGS = 'zh-CN' | 'zh-TW' | 'en-US' | 'ja-JP';
export declare abstract class AgentSelector {
    abstract isSelected(): boolean;
    abstract isMultiSelected(): boolean;
    abstract getSelectedSubContainers(): ContainerElement[];
    abstract getSelectedBlocks(): BlockElement[];
    abstract getSelectedBlock(): BlockElement;
    abstract getContextMenuData(): CommandItemData[];
    abstract getDetail(): any;
    abstract handleMultiBlocksEvent(event: KeyboardEvent): boolean;
    abstract updateSelection(complexBlock: BlockElement, selectIndex?: {
        colIndex: number;
        rowIndex: number;
    }[]): boolean;
    abstract getCurPopover(): Hidable | null;
    abstract selectionToDoc(): EditorDoc;
    abstract selectionToHtml(): string;
    abstract selectBlock(block: BlockElement): boolean;
    abstract isFullSelected(): boolean;
    abstract isSelecting(): boolean;
    abstract isMultiSelecting(): boolean;
    abstract clearSelection(): void;
    abstract deleteSelectedContents(): void;
    abstract destroy(): void;
}
export declare type AgentSelectorRegister = (editor: Editor) => AgentSelector;
export interface MentionBoxData extends BoxData {
    iconUrl: string;
    text: string;
    mentionId: string;
}
export declare enum FilePreviewType {
    CARD = "card",
    LINK = "link",
    PREVIEW = "preview"
}
export declare enum ReservedMediaSrcType {
    Empty = "empty",
    Loading = "loading",
    Progress = "progress",
    Error = "error"
}
export declare function isReservedMediaSrc(src: string): boolean;
export interface MediaData {
    src: string;
    width?: number;
    height?: number;
    previewType?: FilePreviewType;
    fileName: string;
    fileSize: number;
    fileType: string;
}
export interface FileBoxTemplateData extends BoxTemplateData {
    src: string;
    fileName: string;
    fileSize: number;
    fileType: string;
}
export interface FileBoxData extends BoxData, FileBoxTemplateData {
}
export interface SelectedBlock {
    block: BlockElement;
    start: number;
    end: number;
}
export declare enum SelectionDetailType {
    ONE_TEXT_BLOCK = "ONE_TEXT_BLOCK",
    ONE_FULL_COMPLEX_BLOCK = "ONE_FULL_COMPLEX_BLOCK",
    ONE_EMBED_BLOCK = "ONE_EMBED_BLOCK",
    MULTI_BLOCKS = "MULTI_BLOCKS",
    INVALID = "INVALID"
}
export interface CaretDetail {
    atTop: boolean;
    atBottom: boolean;
    atHome: boolean;
    atEnd: boolean;
    homeOffset: number;
    endOffset: number;
    lineOffset: number;
    previousLineHomeOffset?: number;
    nextLineEndOffset?: number;
}
export interface RangeDetail {
    range: Range;
    type: SelectionDetailType;
    collapsed: boolean;
    startBlock?: BlockElement;
    endBlock?: BlockElement;
    startOffset?: number | undefined;
    endOffset?: number | undefined;
    startComplexBlock?: BlockElement;
    endComplexBlock?: BlockElement;
    direction: number;
    noSel?: boolean;
    focusedOnInput?: boolean;
}
export interface SelectionDetail extends RangeDetail {
    selection: Selection;
}
export interface BasicCommandStatus {
    [index: string]: boolean | number | 'enabled' | 'disabled' | BLOCK_TYPE | string;
}
export interface CommandStatus {
    parentComplexBlock?: BasicCommandStatus;
    [index: string]: boolean | number | 'enabled' | 'disabled' | BLOCK_TYPE | string | BasicCommandStatus | undefined;
}
export interface EditorDocTocNode {
    title?: boolean;
    blockId: string;
    text: string;
    children: EditorDocTocNode[];
    level: number;
    type: 'title' | BLOCK_TYPE;
    start?: number;
    startText?: string;
    ordered?: boolean;
}
export declare type EditorDocToc = EditorDocTocNode[];
export interface OnlineUser {
    userId: string;
    displayName: string;
    avatarUrl: string;
    joinAt: number;
    rainbowIndex: number;
    userData?: string;
    permission?: string;
}
export declare type OnlineUsers = OnlineUser[];
export interface OnlineUserChange {
    reason: 'join' | 'leave';
    userId: string;
}
export declare type ThemeModeType = 'light' | 'auto' | 'dark';
export declare type PreviewInfo = {
    html?: string;
    url?: string;
    pageCount?: number;
    iframeUrl?: string;
};
export interface WebPageEmbedType {
    name: string;
    type: string;
    helpLink?: string;
    helpHtml?: string;
    icon: string;
}
export interface DocTemplate {
    docId: string;
    name: string;
    token: string;
    thumbnailUrl?: string;
    isStarred?: boolean;
    isCustom?: boolean;
}
export interface EditorOptions {
    lang?: LANGS;
    isMobile?: boolean;
    isHistory?: boolean;
    defaultRootElement?: Element | null;
    defaultRootContainerExtendElement?: Element | null;
    disableRootContainerCustom?: boolean;
    disableAutoCreateDoc?: boolean;
    custom?: unknown;
    customLangText?: any;
    serverUrl: string;
    readonly?: boolean;
    template?: Object;
    templateValues?: TemplateValues;
    docTemplates?: {
        hideWhenReadOnly?: boolean;
        templates: DocTemplate[];
        showTemplateOperator: (maxCount: number, firstCard: HTMLElement) => {
            showCreateTemplate: boolean;
            showChooseTemplate: boolean;
            createTemplateImageSrc?: string;
            chooseTemplateImageSrc?: string;
        };
        placeHolderImageSrc?: string;
        showTemplateTitleAttr?: boolean;
        customizedMarkText?: string;
    };
    placeholder?: string;
    titleInEditor?: boolean;
    titlePlaceholder?: string;
    readonlyTitlePlaceholder?: string;
    contentPlaceholder?: string;
    dialog?: Dialog;
    autoSuggest?: AutoSuggest;
    tooltip?: Tooltip;
    textToolbar?: TextToolbar;
    contextMenu?: ContextMenu;
    floatMenu?: FloatMenu;
    blockMenuButton?: BlockMenuButton;
    hideBlockMenuButton?: boolean;
    hideBlockCommentButton?: boolean;
    hideBlockMenu?: boolean;
    hideBlockIcon?: boolean;
    hideTableToolbar?: boolean;
    disableTableBorderBar?: boolean;
    disableTableResize?: boolean;
    showComplexBlockMenuButton?: boolean;
    local?: boolean;
    initLocalData?: EditorDoc;
    initLocalDataOps?: EditorOp[];
    playOps?: boolean;
    playOpsSpeed?: number;
    localNeedAuth?: boolean;
    disableLogout?: boolean;
    markdownOnly?: boolean;
    codeTabSize?: number;
    lineNumber?: boolean;
    initTitle?: string;
    hideComments?: boolean;
    colors?: string[];
    selectionColors?: string[];
    officeType?: FilePreviewType;
    allowDarkMode?: boolean;
    themeMode?: ThemeModeType;
    maxHeading?: number;
    allowedFiles?: string[];
    acceptAllOfficeFiles?: boolean;
    acceptOfficeFilesMenuText?: string;
    officeMenuIcon?: string;
    debug?: boolean;
    previewFiles?: string[];
    disableListBulletClick?: boolean;
    disableMarker?: boolean;
    disableMindmap?: boolean;
    disableMentions?: boolean;
    disableCalendar?: boolean;
    disableTex?: boolean;
    disableVideo?: boolean;
    disableAudio?: boolean;
    disableOfficeDownload?: boolean;
    disableContextMenu?: boolean;
    tableExtendBoundary?: {
        enable: boolean;
        container?: HTMLElement;
        left?: number;
        right?: number;
        rightIgnoreComments?: boolean;
    };
    disableRealTime?: boolean;
    disableLazyLoading?: boolean;
    scrollIntoViewIfNeeded?: boolean;
    disableDragListChildren?: boolean;
    strictList?: boolean;
    maxLength?: number;
    highlightMaxCodeLines?: number;
    deleteChildComments?: boolean;
    resourceProtocol?: string[];
    insertEmptyImage?: boolean;
    insertEmptyImageOnQuickInput?: boolean;
    quickInsertMenuTrigger?: QuickInsertMenuTrigger;
    allowedWebPages?: WebPageEmbedType[];
    ignoreWebPages?: string[];
    quickInsertMenus?: AutoSuggestData[];
    blockMenuItems?: CommandItemData[];
    disableDropOfficeFile?: boolean;
    icons?: {
        [key in ICON_KEY]?: string;
    };
    disableInsertAfterLastLockedBlock?: boolean;
    defaultCellWidth?: number;
    imageDefaultAlign?: TextAlign;
    popover?: {
        refuseOverflow?: boolean;
        overflowBoundary?: Element;
    };
    findDialog?: {
        popoverTarget?: HTMLElement;
        getReferenceClientRect?: (popoverTarget: HTMLElement, dialog: HTMLElement) => DOMRect;
    };
    commentsOptions?: {
        disableForReadonly?: boolean;
        disableReply?: boolean;
        disableQuickReply?: boolean;
        disableEdit?: boolean;
        pullThreshold?: number;
        scrollContainerForMobile?: HTMLElement;
    };
    officeConverter?: {
        convertList?: boolean;
        convertFont?: boolean;
    };
    maxSize?: {
        all?: number;
        image?: number;
        video?: number;
        audio?: number;
        office?: number;
    };
    unknownMediaToOffice?: boolean;
    allowedMedias?: {
        image?: string[];
        video?: string[];
        audio?: string[];
        office?: string[];
    };
    zIndex?: {
        popover?: number;
        autoSuggest?: number;
        popoverDialog?: number;
        editableToolbar?: number;
        menu?: number;
        tooltip?: number;
    };
    cdn?: {
        mathjax?: string;
        prismCore?: string;
        prismLoader?: string;
        mermaid?: string;
        flowchart?: string[];
        pako?: string;
        drawio?: string;
        drawioIframe?: string;
        chartjs?: string;
        revealjs?: {
            js: string[];
            css: string[];
        };
        plantuml?: string;
    };
    xmind?: {
        isBought: boolean;
        isInstalled: boolean;
        isExpired: boolean;
    };
    syncToHistoryOptions?: Record<string, any>;
    callbacks?: {
        onLoad?: (editor: Editor, data: EditorDoc) => void;
        onError?: (editor: Editor, error: Error) => void;
        onSave?: (editor: Editor, data: EditorDoc) => void;
        onChange?: (editor: Editor) => void;
        onBuildUserAvatarUrl?: (editor: Editor, userId: string) => string;
        onRemoteUserChanged?: (editor: Editor, users: OnlineUsers, change: OnlineUserChange) => void;
        onStatusChanged?: (editor: Editor, isDirty: boolean) => void;
        onReauth?: (userId: string, docId: string, permission: AuthPermission) => Promise<string>;
        onMentionCreateData?: (editor: Editor, item: AutoSuggestData) => BoxTemplateData | null;
        onGetMentionItems?: (editor: Editor, keywords: string) => Promise<AutoSuggestData[]>;
        onMentionInserted?: (editor: Editor, boxData: MentionBoxData, block: BlockElement, pos: number) => void;
        onMentionClicked?: (editor: Editor, boxData: MentionBoxData, block: BlockElement) => void;
        onCreateMentionPhoneOrEmail?: (editor: Editor, content: string) => Promise<BoxTemplateData>;
        onMentionCreated?: (editor: Editor, boxData: MentionBoxData, box: BoxElement) => void;
        onFileInserted?: (editor: Editor, boxData: FileBoxData, block: BlockElement, pos: number) => void;
        onFileClicked?: (editor: Editor, boxData: FileBoxData, block: BlockElement, event: Event) => void;
        onGetFileDownloadUrl?: (editor: Editor, boxData: FileBoxData) => Promise<string | undefined>;
        onGetTagItems?: (editor: Editor, keywords: string) => Promise<string[]>;
        onTagInserted?: (editor: Editor, tag: string, block: BlockElement, pos: number) => void;
        onTagClicked?: (editor: Editor, tag: string) => void;
        onGetWikiLinkItems?: (editor: Editor, keywords: string) => Promise<WikiLinkItem[]>;
        onWikiLinkInserted?: (editor: Editor, data: WikiLinkBoxData, block: BlockElement, pos: number) => void;
        onWikiLinkClicked?: (editor: Editor, data: WikiLinkBoxData, event: Event) => void;
        onCreateWikiLinkId?: (editor: Editor, name: string) => Promise<string | undefined>;
        onGetWikiLinkName?: (editor: Editor, link: WikiLinkBoxData) => string | undefined;
        onImageClicked?: (editor: Editor, block: BlockElement, src: string, allImageScr: {
            src: string;
            id: string;
        }[], doubleClick: boolean, img: HTMLImageElement, event: MouseEvent, data: Record<string, unknown>) => boolean | undefined;
        onCommentInserted?: (editor: Editor, commentId: string, commentDocText: string, commentText: string, selectedBlock: SelectedBlock) => void;
        onCommentReplied?: (editor: Editor, toUserId: string, orgCommentText: string, commentText: string) => void;
        onRenderAutoSuggestItem?: (editor: Editor, suggestData: AutoSuggestData) => HTMLElement;
        onGetBlockCommand?: (editor: Editor, block: BlockElement, detail: SelectionDetail, type: 'fixed' | 'hover' | 'menu', target: Node | null, editorMenuData: CommandItemData[]) => CommandItemData[];
        onCommandStatusChanged?: (editor: Editor, status: CommandStatus) => void;
        onCheckboxChanged?: (editor: Editor, text: string, blockData: BlockData, mentions: BoxData[], calendars: BoxData[]) => void;
        onMarkerCreated?: (editor: Editor, text: string, blockData: BlockData) => void;
        onQuickInput?: (editor: Editor, event: KeyboardEvent | null, block: BlockElement, text: string, offset: number) => boolean;
        onUploadResource?: (editor: Editor, file: File, onProgress: OnProgress) => Promise<string>;
        onTitleChanged?: (editor: Editor, docId: string, title: string) => void;
        onGetChartJsData?: (editor: Editor, data: string) => Promise<any>;
        onUpdateToc?: (editor: Editor, toc: EditorDocToc) => void;
        onCustomMessage?: (editor: Editor, data: string) => void;
        onBuildResourceUrl?: (editor: Editor, resourceName: string, fileName?: string) => string;
        onBeforeUploadResource?: (editor: Editor, file: File) => Promise<void>;
        onCopyResourcesFromOtherServer?: (editor: Editor, apiServer: string, resourceName: string[], token: string) => Promise<{
            [index: string]: string;
        }>;
        onGetListNumber?: (editor: Editor, level: number, start: number) => string;
        onGetBlockToolbarOptions?(editor: Editor, block: BlockElement, detail: SelectionDetail, type: 'fixed' | 'hover'): CommandItemData[] | null;
        onRecognizeLink?: (editor: Editor, text: string, block: BlockElement, options: {
            offset: number;
            count: number;
        }) => Promise<{
            text: string;
            link: string;
            processed?: boolean;
        } | null>;
        onRecognizeWebPageLink?: (editor: Editor, url: string) => Promise<{
            type?: 'iframe' | 'video' | 'audio' | 'image';
            providerName?: string;
            url: string;
        } | null>;
        onBlockMouseEnter?: (editor: Editor, block: BlockElement, event: MouseEvent) => void;
        onBlockMouseLeave?: (editor: Editor, block: BlockElement, event: MouseEvent) => void;
        onBlockFocusChanged?: (editor: Editor, block: BlockElement, focused: boolean) => void;
        onMediaUploadProgress?: (editor: Editor, block: BlockElement, percentage: number) => void;
        onCreatePreviewUrl?: (editor: Editor, block: BlockElement, type: 'start' | 'end') => void;
        onKeyDown?: (editor: Editor, event: KeyboardEvent) => boolean;
        onBlur?: (editor: Editor, event: FocusEvent) => void;
        onSelectionChanged?: (editor: Editor, detail: SelectionDetail, mouseDown: boolean) => void;
        onTableSelectionChanged?: (editor: Editor, selection: any, rect: DOMRect | null) => void;
        onReplaceAll?: (editor: Editor, count: number, from: string, to: string) => void;
        onClickListNumber?: (editor: Editor, block: BlockElement, data: {
            rect: DOMRect;
            status: CommandStatus;
        }) => void;
        onRenderMediaPlayer?: (editor: Editor, parent: HTMLElement, data: EmbedData, type: 'audio' | 'video') => void;
        onUpdateMediaSrc?: (editor: Editor, media: HTMLElement, src: string, data: MediaData) => void;
        onAddMention?: (editor: Editor, block: BlockElement, detail: SelectionDetail) => void;
        onSendComment?: (editor: Editor, comment: DocComment, data: DocBlock[]) => void;
        onCancelComment?: (editor: Editor, comment?: DocComment, data?: DocBlock[]) => void;
        onReplyComment?: (editor: Editor, comment: DocComment, data: DocBlock[]) => void;
        onCreateReplyCommentMention?: (editor: Editor, replyUserId: string, displayName: string, avatarUrl: string) => BoxData;
        onHoverImage?: (editor: Editor, block: BlockElement | null, image: HTMLImageElement | null) => void;
        onSelectImage?: (editor: Editor, block: BlockElement | null, image: HTMLImageElement | null) => void;
        onRevertVersion?: (editor: Editor, revertedBy: {
            userId: string;
            displayName: string;
        }) => void;
        onBlockMenuButtonClick?: (editor: Editor, block: BlockElement, event: MouseEvent) => void;
        onUpdateLayout?: (editor: Editor, options: {
            [index: string]: any;
        }) => void;
        onCopyToClipboard?: (editor: Editor, data: {
            html: string;
            text: string;
            doc?: EditorDoc;
        }) => {
            html: string;
            text: string;
        } | null | undefined;
        onFormatDate?: (editor: Editor, date: Date) => string;
        onSelectFileUpload?: (editor: Editor, container: ContainerElement | null, index: number, embedType: EMBED_TYPE) => Promise<void>;
        onScrollIntoView?: (editor: Editor, scrollContainer: HTMLElement, dom: Element) => void;
        onInputClicked?: (editor: Editor, inputBox: BoxData, event: Event) => void;
        onImageError?: (editor: Editor, image: HTMLImageElement) => void;
        onSaveImage?: (editor: Editor, image: HTMLImageElement) => void;
        onBeforePaste?: (editor: Editor, event: ClipboardEvent) => boolean;
        onBeforePasteInBlock?: (editor: Editor, block: BlockElement, options: {
            doc?: EditorDoc;
            text?: string;
            html?: string;
            fromEditor: boolean;
            detail: SelectionDetail;
        }) => Promise<EditorDoc | undefined>;
        onBeforePasteDoc?: (editor: Editor, doc: EditorDoc) => Promise<EditorDoc>;
        onAfterPaste?: (editor: Editor, event: ClipboardEvent) => void;
        onCodeCopied?: (editor: Editor, code: string) => void;
        onBeforeCutAction?: (editor: Editor, block: BlockElement) => boolean;
        onBeforeCopyAction?: (editor: Editor, block: BlockElement) => boolean;
        onDownloadImage?: (editor: Editor, src: string, origin: (src: string) => Promise<File | null>) => Promise<File | null>;
        onInsertOfficeMenuClicked?: (editor: Editor, block: BlockElement, offset: number, source: 'BlockMenu' | 'QuickInsert') => void;
        onEditOffice?: (editor: Editor, blockOrBox: BlockElement | BoxElement, data: MediaData, event: Event) => void;
        onOpenOffice?: (editor: Editor, blockOrBox: BlockElement | BoxElement, data: MediaData, event: Event) => Promise<boolean>;
        onSaveOffice?: (editor: Editor, block: BlockElement, data: MediaData, event: Event) => void;
        onPreviewOffice?: (editor: Editor, block: BlockElement, data: MediaData, type: 'open' | 'preview', event: Event) => Promise<boolean>;
        onGetPreviewInfo?: (editor: Editor, src: string, data: MediaData) => Promise<PreviewInfo | null>;
        onFileCardClicked?: (editor: Editor, src: string, data: MediaData) => boolean;
        onRenderFileCardIcon?: (editor: Editor, mediaData: MediaData, iconContainer: HTMLElement) => Promise<string>;
        onExecutePaste?: (editor: Editor) => void;
        onBeginInitDrawIo?: (editor: Editor, block: BlockElement) => void;
        onEndInitDrawIo?: (editor: Editor, block: BlockElement) => void;
        onCreateDrawIoFrame?: (editor: Editor) => Promise<HTMLIFrameElement>;
        onCloseDrawIoFrame?: (editor: Editor, iframe: HTMLIFrameElement) => void;
        onClickTocItem?: (editor: Editor, event: MouseEvent, block: BlockElement, a: HTMLAnchorElement) => void;
        onClickLink?: (editor: Editor, event: MouseEvent, a: HTMLAnchorElement) => boolean;
        onDocSnapshotClicked?: (editor: Editor, block: BlockElement, doc: EditorDoc, event: Event) => void;
        onClickWebPageHelp?: (editor: Editor, type: string) => void;
        onCreateTemplate?: (editor: Editor) => void;
        onChooseTemplate?: (editor: Editor) => void;
        onApplyTemplate?: (editor: Editor, template: DocTemplate) => Promise<void>;
        onTemplateChooserStatusChanged?: (editor: Editor, cardContainer: HTMLElement | null, status: 'visible' | 'hide') => void;
        onQuickInsertClicked?: (editor: Editor, item: AutoSuggestData) => boolean;
        onGetCurrentScale?: (editor: Editor) => number;
        isSetScale?: (editor: Editor) => boolean;
        onShowBlockMenu?: (editor: Editor, block: BlockElement, items: CommandItemData[]) => boolean | undefined;
        onReadonlyChange?: (editor: Editor, readonly: boolean) => void;
        onLoadBlocks?: (editor: Editor, container: ContainerElement, blocks: Array<DocBlock | BlockData>) => void;
        onUpdateBlockText?: (editor: Editor, block: BlockElement, text: RichTextOperations) => void;
        verifyUploadImage?: (image: File) => boolean;
    };
}
export interface CaretPos {
    containerId: string;
    blockId: string;
    offset: number;
    attributes?: any;
}
export interface RemoteUserCaretPos extends CaretPos {
    userId: string;
    displayName: string;
    avatarUrl: string;
    lastUpdated: number;
    color: string;
    selectionColor: string;
    caretType: 'start' | 'end';
}
export interface ContainerSelectedBlocks {
    container: ContainerElement;
    selectedBlocks: SelectedBlock[];
}
export declare enum EMBED_TYPE {
    IMAGE = "image",
    AUDIO = "audio",
    VIDEO = "video",
    DRAWIO = "drawio",
    MERMAID = "mermaid",
    FLOWCHART = "flowchart",
    HR = "hr",
    MATHJAX = "math",
    OFFICE = "office",
    WEBPAGE = "webpage",
    CHARTJS = "chartjs",
    TOC = "toc",
    PLANTUML = "plantuml",
    SNAPSHOT = "snapshot"
}
export declare type EMBED_MEDIA_TYPE = EMBED_TYPE.IMAGE | EMBED_TYPE.VIDEO | EMBED_TYPE.AUDIO | EMBED_TYPE.OFFICE;
export interface EmbedData {
    [index: string]: unknown;
}
export interface EmbedBlockTemplateData extends BlockTemplateData {
    embedType: EMBED_TYPE;
    embedData: EmbedData;
}
export interface EmbedOptions {
    menuItems: CommandItemData[];
    editorHeight?: number;
}
export interface AdjustArrowResult {
    block?: BlockElement;
    offset?: number;
    stop?: boolean;
    moveToEnd?: boolean;
}
export interface Embed {
    getEmbedOptions?: (editor: Editor) => EmbedOptions;
    createElement(editor: Editor, embedContainer: BlockContentElement, data: EmbedData, blockData: BlockData): EmbedElement;
    deleteElement?: (block: BlockElement, embed: EmbedElement) => void;
    saveData(editor: Editor, embed: EmbedElement): EmbedData;
    saveSelectionData?: (editor: Editor, embed: EmbedElement) => EmbedData;
    clearSelection?: (editor: Editor, embed: EmbedElement) => boolean;
    updateData(editor: Editor, embed: EmbedElement, data: EmbedData, blockData: BlockData): void;
    getToolbarOptions?: (block: BlockElement) => CommandItemData[] | null;
    notify?: (block: BlockElement, embed: EmbedElement, name: string, data: any) => void;
    getAbstract?: (block: BlockElement, embed: EmbedElement) => string;
    toMarkdown?: (doc: EditorDoc, containerId: string, blockIndex: number, blockData: DocBlock, embedData: EmbedData, options: Doc2MarkdownOptionalOptions) => string | undefined;
    handleSelectChanged?: (block: BlockElement, detail: SelectionDetail) => void;
    handleUnselectChanged?: (block: BlockElement, detail: SelectionDetail) => void;
    handleEmbedClicked?: (block: BlockElement, embed: EmbedElement, event: MouseEvent) => boolean;
    handleEmbedMouseDown?: (block: BlockElement, embed: EmbedElement, event: MouseEvent) => boolean;
    handleEmbedMouseEnter?: (block: BlockElement, embed: EmbedElement, event: MouseEvent) => void;
    handleEmbedMouseLeave?: (block: BlockElement, embed: EmbedElement, event: MouseEvent) => void;
    handleEmbedInserted?: (block: BlockElement, embed: EmbedElement) => void;
    removeComment?: (block: BlockElement, embed: EmbedElement, commentId: string) => void;
    handleKeydownEvent?: (block: BlockElement, detail: SelectionDetail, event: KeyboardEvent) => boolean;
    getContextMenuData?: (block: BlockElement, embed: EmbedElement, detail: SelectionDetail, target: Node) => CommandItemData[];
    adjustArrowMove?: (editor: Editor, event: KeyboardEvent, detail: CaretDetail, block: BlockElement, blockOffset: number, direction: 'left' | 'right') => AdjustArrowResult | null;
    toStandardDoc?: (editor: Editor, appId: string, docId: string, blockData: DocBlock) => Promise<EditorDoc | undefined>;
    getBlockMenuOptions?: (editor: Editor, block: BlockElement) => Partial<Record<'cut' | 'copy' | 'delete' | 'lock', boolean>>;
    handleSnapShotBlock?: (block: BlockElement) => HTMLElement | null;
}
export interface UndoState {
    rememberCaretPos(): void;
    lastCaretPos(): CaretPos;
    reset(): void;
    onUpdateBlockTextAction(container: ContainerElement, block: BlockElement, oldData: RichTextDocument): void;
    onUpdateBlockDataAction(container: ContainerElement, block: BlockElement, oldData: BlockData): void;
    onReplaceBlockAction(container: ContainerElement, blockId: string, oldData: BlockData, newData: BlockData): void;
    onCreateBlockAction(container: ContainerElement, block: BlockElement, index: number, data: BlockData): void;
    onDeleteBlockAction(container: ContainerElement, index: number): void;
    beginGroup(): void;
    endGroup(): void;
    undo(): boolean;
    redo(): boolean;
    canUndo(): boolean;
    canRedo(): boolean;
}
export declare const TextCommands: readonly ["style-bold", "style-italic", "style-underline", "style-strikethrough", "style-sub", "style-super", "style-code", "style-color-0", "style-color-1", "style-color-2", "style-color-3", "style-color-4", "style-color-5", "style-color-6", "style-bg-color-0", "style-bg-color-1", "style-bg-color-2", "style-bg-color-3", "style-bg-color-4", "style-bg-color-5", "style-bg-color-6", "style-bg-color-7", "style-bg-color-8", "style-bg-color-9", "style-bg-color-10", "style-bg-color-11", "style-bg-color-12", "style-bg-color-13", "link", "comment", "unlink", "inline-math", "insertComplexBlock", "selectAll", "clearFormat", "clearTextFormat", "clearColor", "clearBackground", "cut", "copy", "paste", "delete", "wiki-link", "tag"];
export declare const BlockCommands: readonly ["lock", "unlock", "toBodyText", "toHeading1", "toHeading2", "toHeading3", "toHeading4", "toHeading5", "toHeading6", "toHeading7", "toHeading8", "toQuoted", "toOrderedList", "toUnorderedList", "indent", "outdent", "toCheckbox", "list/indent", "list/outdent", "list/continueList", "list/restartList", "list/changeListStart", "list/remove", "cloneBlockAbove", "cloneBlockBelow", "moveBlockUp", "moveBlockDown", "alignLeft", "alignCenter", "alignRight", "alignJustify", "comment", "style", "padding", "table/mergeCells", "table/splitCell", "table/deleteSelectedRows", "table/deleteSelectedCols", "table/setCellBackground", "table/clearCellBackground", "table/insertRowAbove", "table/insertRowBelow", "table/insertColLeft", "table/insertColRight", "table/showBorder", "table/hideBorder", "table/delete", "webpage"];
export declare type TextCommand = typeof TextCommands[number];
export declare type BlockCommand = typeof BlockCommands[number];
export declare type CommandParams = {
    [index: string]: any;
};
export interface CommentTextCommandParams {
    commentId: string;
}
export declare type CommentData = DocComment;
export declare abstract class CommentsContainer {
    abstract highlightCommentGroupById(id: string): void;
    abstract isInCommentContainer(node: Node): boolean;
    abstract showComments(comments: Array<Array<CommentData>>): void;
    abstract getComments(): any;
    abstract getAllCommentTarget(commentId: string): Array<Element>;
    abstract editComment(groupId: string, id: string): void;
    abstract handleSelectImg(img: HTMLImageElement): void;
    abstract reset(): void;
    abstract rootElement(): HTMLElement;
    abstract fixGroupsPosition(): void;
}
export interface DeleteBlockOptions {
    fromUndo: boolean;
    localAction: boolean;
    withChildren?: boolean;
    noFixEmptyContainer?: boolean;
}
export interface UpdateBlockData {
    id: string;
    [index: string]: any;
}
export interface ReplaceBlockOptions {
    fromUndo: boolean;
    focusToBlock: boolean;
}
export interface BreakTextBlockOptions {
    breakText?: boolean;
}
export interface ActionOperatorOptions {
    operator?: string;
}
export interface InsertBlockOptions extends BreakTextBlockOptions {
    fromUndo: boolean;
    focusToBlock: boolean;
    localAction: boolean;
    autoCorrectList?: boolean;
}
export interface UpdateBlockDataOptions {
    fromUndo: boolean;
    updateBlock: boolean;
    partial: boolean;
}
export interface UpdateBlockTextOptions {
    fromUndo: boolean;
    updateBlock: boolean;
    updateLocalOnly?: boolean;
}
export interface InsertBoxOptions {
    deletePrefix?: boolean;
    showAutoSuggest?: boolean;
    disableAppendSpace?: boolean;
}
export interface SelectionState {
    startCaret: CaretPos | null;
    endCaret: CaretPos | null;
    startOldData: BlockData | null;
    endOldData: BlockData | null;
}
export interface CommandTargetInfo {
    selectionState: SelectionState;
    target: Node;
    srcPopover: Popover;
}
export interface VersionDialogOptions {
    hideActions?: boolean;
    groupVersions?: boolean;
    hideNonVersionedOps?: boolean;
    hideOps?: boolean;
    initSelectedVersion?: number | string;
    useCreatedBy?: boolean;
    syncFromEditorOptions?: Record<string, any>;
    onWillChangeVersion?: (mainEditor: Editor, version: DocVersion, isLatest: boolean, isOldest: boolean) => undefined | {
        hideOps?: boolean;
    };
    onVersionChanged?: (mainEditor: Editor, versionEditor: Editor, version: DocVersion, isLatest: boolean, isOldest: boolean) => void;
    onVersionsLoaded?: (mainEditor: Editor, versions: DocVersion[]) => void;
}
export interface VersionDialog {
    hide: () => void;
    setShowOps: (showOps: boolean) => void;
    showVersion: (version: number | string) => void;
    getCurrentVersion: () => DocVersion | null;
}
export interface HeadingBlockScrollListenerCallbackResult {
    curHeadingBlock: BlockElement | null;
    previousHeadingBlock: BlockElement | null;
    nextHeadingBlock: BlockElement | null;
}
export interface Editor {
    readonly undoState: UndoState;
    readonly options: EditorOptions;
    readonly commentsContainer: CommentsContainer;
    readonly parentEditor: Editor | null;
    readonly version: string;
    readonly id: string;
    readonly loaded: boolean;
    readonly destroyed: boolean;
    editorElement: HTMLElement;
    autoSuggest: AutoSuggest;
    tooltip: Tooltip | null;
    rootElement: RootElement;
    auth: AuthMessage;
    textToolbar: TextToolbar;
    editableToolbar: Hidable;
    contextMenu: ContextMenu;
    findDialog: FindDialog;
    floatMenu: FloatMenu;
    blockMenuButton?: BlockMenuButton;
    themeMode: ThemeModeType;
    lastEvent: MouseEvent | KeyboardEvent | null;
    linkDialogShow: boolean;
    mouseWheeled: boolean;
    destroy(): void;
    apiServer(): string;
    editorServer(): string;
    docId(): string;
    data(): EditorDoc;
    isDirty(): boolean;
    isReadOnly(): boolean;
    isLocal(): boolean;
    isHistory(): boolean;
    isMarkdownOnly(): boolean;
    isCommentable(): boolean;
    isWritable(): boolean;
    isDragging(): boolean;
    isMouseDown(): boolean;
    isAllLoaded(): boolean;
    setDragging(isDragging: boolean): void;
    isChildEditor(): boolean;
    mousePosition(): Position;
    saveData(): void;
    reload(): void;
    setReadOnly(readonly: boolean): void;
    isBlockWritable(block: BlockElement): boolean;
    isBlockMarkerExpired(block: BlockElement): boolean;
    setBlockMarkerExpired(block: BlockElement, status: boolean): void;
    insertDoc(doc: EditorDoc, options?: {
        block: BlockElement;
        offset: number;
    }): void;
    insertMarkdown(markdown: string, options?: {
        block: BlockElement;
        offset: number;
    }): void;
    importDocx(file: File): Promise<void>;
    toHtml(): string;
    selectionToDoc(options?: {
        keepComments?: boolean;
    }): EditorDoc;
    selectionToHtml(): string;
    toPlainText(options?: {
        withoutTitle: boolean;
    }): string;
    toImage(width?: number, height?: number, download?: boolean): Promise<Blob | null>;
    print(): Promise<void>;
    toMarkdown(): string;
    toDocx(template: Buffer | undefined, download?: boolean, backgroundImageOptions?: IImageOptions): Promise<Blob>;
    showVersions(container: HTMLElement | null, options?: VersionDialogOptions): VersionDialog;
    showOps(ops: EditorOp[], options?: {
        play: boolean;
        speed?: number;
    }): Promise<void>;
    getVersions(options?: {
        groupVersions?: boolean;
    }): Promise<DocVersion[]>;
    getVersion(ver: number): Promise<EditorDoc>;
    getVersionOps(ver: number, from?: number): Promise<{
        doc: EditorDoc;
        ops: EditorOp[];
    }>;
    getChanges(): Element[];
    highlightChanges(elem: Element, timeout: number): void;
    getLatestVersion(): Promise<EditorDoc>;
    createVersion(tag: string, publish: boolean): Promise<any>;
    revertVersion(ver: number): Promise<void>;
    meta(): {
        [index: string]: any;
    };
    getOnlineUsers(): OnlineUsers;
    updateTextToolbar(force: boolean): void;
    fixSelection(options: {
        autoScroll: boolean;
    }): void;
    loadLocalBlocks(blocks: DocBlock[]): void;
    loadLocalData(data: EditorDoc): void;
    getOnlineUserColor(userId: string, type: 'flag' | 'selection'): string;
    getFixedUserColor(userId: string, type: 'flag' | 'selection'): string;
    getUserAvatarUrl(avatarUrl: string, userId: string): string;
    getAgentSelector(): AgentSelector;
    getContainerById(id: string): ContainerElement | null;
    getBlockById(id: string): BlockElement | null;
    getBlockByIndex(container: ContainerElement, index: number): BlockElement;
    getBlockContainer(block: BlockElement): ContainerElement;
    getBlockIndex(block: BlockElement): number;
    getBoxById(id: string): BoxElement | null;
    getBoxData(id: string): BoxData;
    replaceBoxToText(id: string, text: string): void;
    updateBoxData(id: string, data: BoxTemplateData, updateLocalOnly?: boolean): void;
    getWikiBoxDataByLinkId(linkId: string): WikiLinkBoxData | null;
    getResourceBasePath(): string;
    getResourceToken(): string | null;
    resourceNameFromUrl(url: string): string;
    buildResourceUrl(resourceName: string, fileName?: string, options?: {
        withToken: boolean;
    }): string;
    getDocThumbImage(template: DocTemplate): string;
    showFindDialog(): void;
    showReplaceDialog(): void;
    highlightText(text: string, options?: {
        keepReplaceResult?: boolean;
    }): void;
    clearHighlight(options?: {
        keepReplaceResult?: boolean;
    }): void;
    broadcastCaretPos(): void;
    isPreviewEnabled(fileName: string): boolean;
    getBlockData(block: BlockElement): BlockData;
    getBlockDataFromDoc(block: BlockElement): BlockData;
    getEmbedBlockEmbedData(block: BlockElement): EmbedData;
    rootContainer(): ContainerElement;
    isMainContainer(container: ContainerElement): boolean;
    isInEditor(dom: Node): boolean;
    createComment(commentGroupId: string | null, replyCommentId: string | null, doc: EditorDoc | null, abstract?: string): string;
    updateCommentText(id: string, doc: EditorDoc): void;
    deleteComment(id: string): void;
    getCommentData(id: string): CommentData;
    getGroupComments(groupId: string): CommentData[];
    getComments(): CommentData[][];
    refreshComments(options?: {
        refreshNow: boolean;
    }): void;
    createChildContainer(parent: HTMLElement, id: string, blocks: any[]): ContainerElement;
    createEmptyChildContainer(parent: HTMLElement, id: string): ContainerElement;
    createEmptyChildContainerData(initBlocks?: BlockData[], id?: string): string;
    createBlockData(type: BLOCK_TYPE, options?: any, id?: string): BlockData;
    createEmbedBlockData(embedType: EMBED_TYPE, data: EmbedData, id?: string): BlockData;
    getChildContainerData(containerId: string): DocBlock[];
    updateBlockData(block: BlockElement, data: BlockTemplateData, options: UpdateBlockDataOptions): void;
    updateBlockText(block: BlockElement, text: RichTextDocument, options: UpdateBlockTextOptions): void;
    setBlockMarkerData(block: BlockElement, markerData: string, width: number, options: UpdateBlockDataOptions): void;
    batchInsertBlocks(container: ContainerElement, insertPos: number, blocks: BlockData[]): BlockElement[];
    canInsertBlockAt(container: ContainerElement, index: number): boolean;
    insertBlock(container: ContainerElement | null, index: number, blockType: string, blockData: BlockData | null, options: InsertBlockOptions): BlockElement;
    deleteBlock(block: BlockElement, options: DeleteBlockOptions): void;
    replaceBlock(block: BlockElement, newBlockData: BlockData, options: ReplaceBlockOptions): BlockElement;
    replaceContainerData(container: ContainerElement, blocks: DocBlock[]): void;
    insertBox(type: BOX_TYPE, id: string | null, data: BoxTemplateData, options?: InsertBoxOptions): Promise<BoxData | null>;
    insertEmptyBox(type: BOX_TYPE): Promise<BoxData | null>;
    insertImageBox(src: string, width: number, height: number | null | undefined, block: BlockElement | null, offset: number | undefined): ImageBoxData | null;
    insertAnchorBox(block: BlockElement | null, offset: number | undefined): BoxData | null;
    insertFileBox(block: BlockElement | null, offset: number | undefined, id: string | null, data: FileBoxTemplateData): BoxData | null;
    insertTextInput(block: BlockElement | null, offset: number | undefined, id: string | null, data: TextInputBoxTemplateData): BoxData | null;
    insertCheckInput(block: BlockElement | null, offset: number | undefined, id: string | null, data: CheckInputBoxTemplateData): BoxData | null;
    insertSelect(block: BlockElement | null, offset: number | undefined, id: string | null, data: SelectBoxTemplateData): BoxData | null;
    insertWikiLink(block: BlockElement | null, offset: number | undefined, id: string | null, data: WikiLinkBoxTemplateData): BoxData | null;
    editBox(boxData: BoxData, block: BlockElement): void;
    getAccepts(type: EMBED_TYPE.AUDIO | EMBED_TYPE.VIDEO | EMBED_TYPE.IMAGE | EMBED_TYPE.OFFICE): string;
    insertEmbed(container: ContainerElement | null, index: number, embedType: EMBED_TYPE, embedData: EmbedData): BlockElement;
    insertMediaFile(container: ContainerElement | null, file: File, index: number, embedType: EMBED_MEDIA_TYPE, options?: BreakTextBlockOptions & ActionOperatorOptions, uploadedCallback?: (block: BlockElement, embedData: EmbedData) => void): BlockElement;
    insertImage(container: ContainerElement | null, file: File | string, index: number, options?: BreakTextBlockOptions, title?: string, link?: string): BlockElement;
    insertAudio(container: ContainerElement | null, file: File | string, index: number, options?: BreakTextBlockOptions): BlockElement;
    insertVideo(container: ContainerElement | null, file: File | string, index: number, options?: BreakTextBlockOptions): BlockElement;
    insertOffice(container: ContainerElement | null, file: File | string, index: number, options?: BreakTextBlockOptions): BlockElement;
    insertWebpage(container: ContainerElement | null, url: string, index: number, customType?: string, options?: BreakTextBlockOptions): Promise<BlockElement>;
    insertMermaid(container: ContainerElement | null, index: number, text: string, options?: BreakTextBlockOptions): BlockElement;
    insertDrawIO(container: ContainerElement | null, index: number, xml: string | null | undefined, options?: BreakTextBlockOptions): BlockElement;
    insertHorizontalLine(container: ContainerElement | null, index: number, options?: BreakTextBlockOptions): BlockElement;
    insertDocSnapshot(container: ContainerElement | null, doc: EditorDoc, index: number, options?: BreakTextBlockOptions): Promise<BlockElement>;
    insertChart(container: ContainerElement | null, index: number, srcOrData: string, options?: {
        width?: number | string;
        height?: number | string;
    }): BlockElement;
    insertTextBlock(container: ContainerElement | null, index: number, text: string | RichTextDocument, textBlockData?: any, options?: InsertBlockOptions): BlockElement;
    insertCheckbox(container: ContainerElement | null, index: number, checked: boolean, text: string): BlockElement;
    replaceBlockToText(block: BlockElement, text: string): BlockElement;
    insertTable(index: number, cols: number, rows: number, params?: BlockTemplateData): BlockElement;
    insertCode(index: number, code: string, language?: string, params?: BlockTemplateData): BlockElement;
    insertLayout(index: number, cols: number): BlockElement;
    uploadResource(file: File, onProgress: OnProgress): Promise<string>;
    addResources(resources: string[]): Promise<string[]>;
    updateOffice(type: 'block' | 'box', id: string, file: File): Promise<BlockElement | BoxElement | null>;
    updateEmbedData(block: BlockElement, data: EmbedData, options?: UpdateBlockDataOptions): void;
    deleteBlockText(block: BlockElement, from: number, to: number): void;
    insertBlockText(block: BlockElement, pos: number, doc: RichTextDocument | string): void;
    splitTextBlock(block: BlockElement, offset: number, options: {
        keepFormat: boolean;
    }): BlockElement;
    closeAutoSuggest(): void;
    getMediaBlockUrl(block: BlockElement): string;
    getAllImages(): {
        src: string;
        id: string;
    }[];
    setFileDisplayType(fileBlockOrFileBox: BlockElement | BoxElement, type: FilePreviewType): void;
    fullscreenPreviewFile(fileBlockOrFileBox: BlockElement | BoxElement): void;
    setCommentsVisible(visible: boolean): void;
    getLinkInfo(node: Node): {
        text: string;
        link: string;
    };
    setLinkInfo(node: Node, info: {
        text?: string;
        link?: string;
    }): void;
    formatDate(date: Date): string;
    isHeadingBlockCollapsed(block: BlockElement): boolean;
    expandHeadingBlock(block: BlockElement): void;
    collapseHeadingBlock(block: BlockElement): void;
    getBlockTocInfo(block: BlockElement): {
        prevHeadingBlockId?: string;
        nextHeadingBlockId?: string;
    };
    endComposition(): void;
    isComposing(): boolean;
    composingBlock(): BlockElement | null;
    isLockedForComposition(): boolean;
    isApplyingRemoteOpsForComposition(): boolean;
    getWaitingCommand(): CommandParams | null;
    addWaitingCommand(params: CommandParams): void;
    clearWaitingCommand(): void;
    selectBlock(block: BlockElement, start: number, end: number | undefined): void;
    moveCaretTo(x: number, y: number): void;
    selectBox(block: BlockElement, boxElement: BoxElement): void;
    isBlockEntireSelected(block: BlockElement): boolean;
    selectEntireBlock(block: BlockElement): void;
    scrollToMiddleView(): void;
    getSelectionDetail(): SelectionDetail;
    getHoverBlock(): BlockElement | null;
    getHoverImage(): HTMLImageElement | null;
    getFocusedImage(): HTMLImageElement | null;
    getEntireSelectedBlock(): BlockElement | null;
    isSelectionWritable(detail: SelectionDetail): boolean;
    getCaretPos(): CaretPos;
    setCaretPos(pos: CaretPos): void;
    getCurrentBlockIndex(): number;
    getRemoteCaretPosesInBlock(blockId: string): RemoteUserCaretPos[];
    getSelectedText(options?: {
        visibleTextOnly?: boolean;
    }): string;
    getCommandStatus(): CommandStatus;
    getBlockCommandStatus(block: BlockElement): CommandStatus;
    getDetailCommandStatus(detail: SelectionDetail): CommandStatus;
    getAllBlocks(options: {
        deep: boolean;
    }): BlockElement[];
    getAllSelectedBlocks(options: {
        deep: boolean;
    }): BlockElement[];
    getCurrentScale(): number;
    isSetScale(): boolean;
    saveSelectionState(): SelectionState;
    restoreSelectionState(state: SelectionState): boolean;
    saveCommandTarget(node: Node, popover: Popover): void;
    executeBlockCommand(command: BlockCommand, block?: BlockElement, params?: CommandParams): any;
    executeTextCommand(command: TextCommand, params?: CommandParams): any;
    applyTextCustomStyle(style: string, enable?: boolean): void;
    undo(): boolean;
    redo(): boolean;
    beginUndoGroup(): void;
    endUndoGroup(): void;
    beginUpdateSelection(): void;
    endUpdateSelection(): void;
    isUpdatingSelection(): boolean;
    cloneBlock(block: BlockElement, options: {
        type: 'above' | 'below';
        focusToNewBlock: boolean;
    }): boolean;
    moveBlock(block: BlockElement, options: {
        type: 'up' | 'down';
    }): boolean;
    exclusiveBlock(block: BlockElement): void;
    unexclusiveBlock(block: BlockElement): void;
    isBlockExclusive(block: BlockElement): boolean;
    isBlockQuoted(block: BlockElement): boolean;
    setBlockQuoted(block: BlockElement, quoted: boolean): void;
    addBlockInlineStyle(block: BlockElement, style: string): void;
    getBlockInlineStyle(block: BlockElement): string | undefined;
    isBlockLocked(block: BlockElement): boolean;
    getBlockLockInfo(block: BlockElement): BlockLockInfo;
    lockBlock(block: BlockElement): void;
    unlockBlock(block: BlockElement): void;
    setBlockLockPassword(block: BlockElement, password: string): void;
    unlockBlockByPassword(block: BlockElement, password: string): void;
    isBlockUnlockedByPassword(block: BlockElement): boolean;
    indentBlock(block: BlockElement): void;
    outdentBlock(block: BlockElement): void;
    setBlockPadding(block: BlockElement, padding: number): void;
    setBlockStyleState(block: BlockElement, style: string, enabled: boolean): void;
    addBlockComment(block: BlockElement, text?: string): string;
    addCommentToBlock(block: BlockElement, commentId: string, options?: {
        noEditComment: boolean;
    }): void;
    commentImage(block: BlockElement, image: HTMLElement): string;
    alignBlock(block: BlockElement, type?: TextAlign): void;
    blinkBlock(block: BlockElement, delay: number): void;
    isTitleBlock(block: BlockElement): boolean;
    titleFromEditor(): string;
    setTitle(title?: string): void;
    handleCommentInserted(block: BlockElement, start: number, end: number, commentId: string): void;
    createChildLocalEditor(elem: HTMLElement, permission: AuthPermission, options: EditorOptions, data?: EditorDoc): Editor;
    showDialog(options: DialogOptions | StandardDialogOptions | StandardInputDialog | StandardConfirmDialog): Dialog;
    focus(offset?: number): void;
    fullscreen(): void;
    addEventListener(eventType: EDITOR_EVENT, callback: (entries: readonly ResizeObserverEntry[]) => void): void;
    removeEventListener(eventType: EDITOR_EVENT, callback: (entries: readonly ResizeObserverEntry[]) => void): void;
    postCustomMessage(data: string): void;
    request(options: string | any): Promise<any>;
    recognizeWebPageLink(url: string): Promise<LinkDetails>;
    recognizeNormalLink(url: string, block: BlockElement, options: {
        offset: number;
        count: number;
    }): Promise<{
        text: string;
        link: string;
    } | null>;
    setFocusMode(isFocusMode: boolean): void;
    setTypewriterMode(isTypewriterMode: boolean): void;
    setThemeMode(themeModeType?: ThemeModeType): void;
    isFocusMode(): boolean;
    isTypewriterMode(): boolean;
    updateImageResizeTool(): void;
    addTokenToResources(html: string): void;
    adjustTextInputSize(): void;
    animateScrollToBlock(block: BlockElement): void;
    play(): void;
    setBlockIconVisible(visible: boolean): void;
    isInComment(element: Element): boolean;
    setQuickInsertMenuTrigger(quickInsertMenuTrigger: QuickInsertMenuTrigger): void;
    startHeadingBlockScrollListener(callback: (result: HeadingBlockScrollListenerCallbackResult) => void): void;
    stopHeadingBlockScrollListener(): void;
    signLinkDialog(show: boolean): void;
}
export interface Position {
    x: number;
    y: number;
}
export interface ClearSelectionOptions {
    merge: boolean;
}
export interface ClipboardData {
    text?: string;
    doc?: EditorDoc;
    html?: string;
    pasteAsText?: boolean;
    fromEditor?: boolean;
}
export interface Block {
    getBlockOptions?: () => BlockOptions;
    getBlockMenuItems?: (editor: Editor) => CommandItemData[];
    getTextElement?: (block: BlockElement) => RichTextElement;
    createBlockTemplateData: (editor: Editor, options: any) => BlockTemplateData;
    createBlockContent: (editor: Editor, id: string, data: BlockData, blockElement: BlockElement) => BlockContentElement;
    updateBlockData: (block: BlockElement, data: BlockData) => void;
    updateBlockText?: (block: BlockElement, data: RichTextOperations) => void;
    executeTextCommand?: (block: BlockElement, command: TextCommand, start: number, end: number, params?: CommandParams) => any;
    executeBlockCommand?: (block: BlockElement, command: BlockCommand, params?: CommandParams) => any;
    getBlockCommandStatus?: (block: BlockElement) => BasicCommandStatus;
    getTextCommandStatus?: (block: BlockElement, offset: number, options: {
        selectNext: boolean;
    }) => TextAttributes;
    saveData: (block: BlockElement) => BlockData;
    saveSelectionData?: (block: BlockElement) => BlockData;
    clearSelection?: (block: BlockElement) => boolean;
    handleKeydownEvent?: (block: BlockElement, detail: SelectionDetail, event: KeyboardEvent) => boolean;
    handlePaste?: (block: BlockElement, data: ClipboardData, detail: SelectionDetail) => boolean;
    handleBlockTextChanged?: (block: BlockElement) => boolean;
    handleBlockInserted?: (block: BlockElement, options: InsertBlockOptions) => void;
    handleBlockLoaded?: (block: BlockElement) => void;
    handleBlockDeleted?: (container: ContainerElement, index: number, blockData: BlockData, options: DeleteBlockOptions) => void;
    handleBlockReload?: (container: ContainerElement, block: BlockElement) => void;
    handleBlockClicked?: (block: BlockElement, event: MouseEvent) => boolean;
    handleBlockMouseEnter?: (block: BlockElement, event: MouseEvent) => void;
    handleBlockMouseLeave?: (block: BlockElement, event: MouseEvent) => void;
    handleBlockMouseMove?: (block: BlockElement, event: MouseEvent) => boolean;
    handleBlockMouseDown?: (block: BlockElement, event: MouseEvent) => boolean;
    handleBlockFocusChanged?: (block: BlockElement, focused: boolean) => void;
    handleChildBlockChanged?: (parent: BlockElement, child: BlockElement, type: 'text-change' | 'data-change' | 'insert' | 'delete') => void;
    getChildContainersData?: (block: BlockElement) => ContainerData[];
    getCaretPos: (block: BlockElement, node: Node, nodeOffset: number) => number;
    createRange: (block: BlockElement, pos: number) => Range;
    handleSelectionChanged?: (block: BlockElement, detail: SelectionDetail, lastEvent: MouseEvent | KeyboardEvent | null, lastPosition: Position) => boolean;
    getSubContainerInComplexBlock?: (block: BlockElement, element: HTMLElement, type: 'top' | 'right' | 'bottom' | 'left') => ContainerElement | null;
    getToolbarOptions?: (block: BlockElement, detail: SelectionDetail, type: 'fixed' | 'hover') => CommandItemData[] | null;
    getTextToolbarOptions?: (block: BlockElement, target: Element) => CommandItemData[] | null;
    getContextMenuData?: (block: BlockElement, detail: SelectionDetail, target: Node) => CommandItemData[];
    notify?: (block: BlockElement, name: string, data: any) => void;
    toText?: (block: BlockElement, startOffset?: number, endOffset?: number) => string;
    toMarkdown?: (doc: EditorDoc, containerId: string, blockIndex: number, blockData: DocBlock, options: Doc2MarkdownOptionalOptions) => string | undefined;
    replaceChildrenId?: (doc: EditorDoc, data: DocBlock) => void;
    createSplittedBlockData?: (block: BlockElement) => BlockTemplateData;
    accept?: (block: BlockElement, type: BOX_TYPE | BLOCK_TYPE) => boolean;
    highlightText?: (block: BlockElement, text: string) => void;
    toHtml?: (block: BlockElement) => string;
    getAbstract?: (block: BlockElement) => string;
    getContainerAlign?: (block: BlockElement, childBlock: BlockElement) => TextAlign | null;
    removeComment?: (block: BlockElement, commentId: string) => void;
    fixEmptyContainer?: (block: BlockElement, options: InsertBlockOptions) => boolean;
    toStandardDoc?: (editor: Editor, appId: string, docId: string, blockData: DocBlock) => Promise<EditorDoc | undefined>;
}
export interface BoxChild {
    type: 'text' | 'image' | 'a' | 'input' | 'br';
    classes?: string[];
    attributes?: {
        [index: string]: string;
    };
}
export interface BoxTextChild extends BoxChild {
    text: string;
}
export interface BoxImageChild extends BoxChild {
    src: string;
    alt?: string;
}
export interface BoxAnchorChild extends BoxChild {
    text: string;
    href?: string;
    id?: string;
    download?: string;
}
export interface BoxInputChild extends BoxChild {
    inputType: 'text' | 'select' | 'checkbox';
    inputId: string;
    value: string;
    items?: InputBoxItem[];
    checked?: boolean;
    classes?: string[];
    width?: number;
    disabled?: boolean;
    placeholder?: string;
    inlineStyle?: string;
}
export interface BoxNode {
    classes?: string[];
    attributes?: {
        [index: string]: string;
    };
    children?: BoxChild[];
}
export interface Box {
    prefix?: string;
    suggestPlaceholder?: string;
    suggestPlaceholderNoMatch?: string;
    customSuggest?: boolean;
    customSuggestTheme?: string;
    insertDefaultThenEdit?: boolean;
    supportMarkdown?: boolean;
    triggerMode?: 'normal' | 'any';
    createNode: (editor: Editor, data: BoxData) => BoxNode;
    available?: (editor: Editor) => boolean;
    getItems?: (editor: Editor, keywords: string) => Promise<AutoSuggestData[]>;
    createBoxDataFromItem?: (editor: Editor, item: AutoSuggestData) => BoxTemplateData;
    createBoxData?: (editor: Editor) => Promise<BoxTemplateData | null>;
    renderAutoSuggestItem?: (editor: Editor, suggestData: AutoSuggestData, options: AutoSuggestOptions) => HTMLElement;
    renderAutoSuggestHeader?: (editor: Editor, suggestData: AutoSuggestData[], options: AutoSuggestOptions, renderOptions: {
        loading: boolean;
    }) => HTMLElement | null;
    renderAutoSuggestFooter?: (editor: Editor, suggestData: AutoSuggestData[], options: AutoSuggestOptions, renderOptions: {
        loading: boolean;
    }) => HTMLElement | null;
    renderAutoSuggestLoading?: (editor: Editor, keywords: string, existsContent: HTMLElement, autoSuggestData: AutoSuggestData[], options: AutoSuggestOptions) => HTMLElement | null;
    enableAutoSuggestSelectItem?: boolean;
    handleBoxInserted?: (editor: Editor, data: BoxData, block: BlockElement, pos: number) => void;
    handleBoxClicked?: (editor: Editor, data: BoxData, block: BlockElement, event: Event) => void;
    handleBoxItemSelected?: (editor: Editor, item: AutoSuggestData, options: AutoSuggestOptions) => void;
    getToolbarOptions?: (editor: Editor, box: BoxElement) => CommandItemData[];
    handleAutoSuggestHidden?: (editor: Editor, data?: BoxData) => void;
    handleReturn?: (editor: Editor) => boolean;
    isFullBox?: (editor: Editor, detail: SelectionDetail) => boolean;
    updateBox?: (editor: Editor, box: BoxData, elem: BoxElement) => void;
    autoSuggestMaxHeight?: number;
    toStandardText?: (editor: Editor, boxData: BoxData) => Promise<any[] | undefined>;
}
export declare function blockData2DocBlock(data: BlockData): DocBlock;
export declare function docData2BlockData(data: DocBlock): BlockData;
export declare function encodeResourceName(resourceName: string): string;
export declare function blockDataToDocBlock(data: BlockData): DocBlock;