import * as _plait_mind from '@plait/mind';
import { MindLayoutType, AbstractNode, LayoutNode, LayoutOptions } from '@plait/layouts';
import * as _plait_core from '@plait/core';
import { PlaitElement, PlaitBoard, Point, Path, ThemeColor, ThemeColorMode, WithPluginOptions, PlaitOptionsBoard, OnContextChanged, PlaitPluginElementContext, BeforeContextChange, RectangleClient } from '@plait/core';
import * as _plait_common from '@plait/common';
import { ParagraphElement, CommonImageItem, StrokeStyle, RenderComponentRef, Generator, CommonElementFlavour, ImageGenerator, TextManage } from '@plait/common';
import { RoughSVG } from 'roughjs/bin/svg';
import * as slate from 'slate';
import { Element as Element$1, Path as Path$1 } from 'slate';
import * as dist_layouts_types_plait_layouts from 'dist/layouts/types/plait-layouts';
import * as dist_core_types_plait_core from 'dist/core/types/plait-core';
import * as dist_common_types_plait_common from 'dist/common/types/plait-common';

interface EmojiItem {
    name: string;
}
interface BaseData {
    topic: ParagraphElement;
    emojis?: EmojiItem[];
    image?: CommonImageItem;
}
interface EmojiData extends BaseData {
    emojis: EmojiItem[];
}
interface ImageData extends BaseData {
    image: CommonImageItem;
}

interface BaseMindElement extends PlaitElement {
    rightNodeCount?: number;
    manualWidth?: number;
    fill?: string;
    strokeColor?: string;
    strokeWidth?: number;
    strokeStyle?: StrokeStyle;
    shape?: MindElementShape;
    branchColor?: string;
    branchWidth?: number;
    branchShape?: BranchShape;
    layout?: MindLayoutType;
    isCollapsed?: boolean;
    start?: number;
    end?: number;
}
interface PlaitMind<T = BaseData> extends MindElement<T> {
    type: 'mind' | 'mindmap';
    points: Point[];
}
declare const PlaitMind: {
    isMind: (value: any) => value is PlaitMind;
};
interface MindElement<T = BaseData> extends BaseMindElement {
    type: 'mind_child' | 'mind' | 'mindmap';
    children: MindElement[];
    data: T;
}
declare const MindElement: {
    isIndentedLayout(board: PlaitBoard, value: MindElement): boolean;
    isMindElement(board: PlaitBoard | null, element: PlaitElement): element is MindElement;
    getParent(node: MindElement): MindElement<BaseData>;
    findParent(node: MindElement): MindElement<BaseData> | undefined;
    getRoot(board: PlaitBoard, element: MindElement): PlaitMind;
    getAncestors(board: PlaitBoard, element: MindElement): PlaitElement[];
    getNode(element: MindElement): _plait_mind.MindNode;
    findParentNode(element: MindElement): _plait_mind.MindNode | undefined;
    hasEmojis(element: MindElement): element is MindElement<EmojiData>;
    hasImage(element: MindElement): element is MindElement<ImageData>;
    getEmojis(element: MindElement<EmojiData>): _plait_mind.EmojiItem[];
};
declare enum MindElementShape {
    roundRectangle = "round-rectangle",
    underline = "underline"
}
declare enum BranchShape {
    bight = "bight",
    polyline = "polyline"
}

interface MindNode {
    depth: number;
    x: number;
    y: number;
    width: number;
    height: number;
    hGap: number;
    vGap: number;
    children: MindNode[];
    origin: MindElement;
    parent: MindNode;
    left: boolean;
    up: boolean;
}
declare const MindNode: {
    get(root: MindNode, path: Path): MindNode;
};
type ExtendLayoutType = Exclude<MindLayoutType, MindLayoutType.standard>;
type CoordinateType = {
    startX: number;
    startY: number;
    endX: number;
    endY: number;
};
type ExtendUnderlineCoordinateType = {
    [key in ExtendLayoutType]: CoordinateType;
};
type DetectResult = 'top' | 'bottom' | 'right' | 'left' | null;
type RootBaseDirection = 'right' | 'left' | null;

declare enum LayoutDirection {
    'top' = "top",
    'right' = "right",
    'bottom' = "bottom",
    'left' = "left"
}
declare const LayoutDirectionsMap: LayoutDirectionMapType;
type LayoutDirectionMapType = {
    [key: string]: LayoutDirection[];
};

declare enum MindPointerType {
    'mind' = "mind"
}

declare const MindDefaultThemeColor: MindThemeColor;
declare const MindColorfulThemeColor: MindThemeColor;
declare const MindSoftThemeColor: MindThemeColor;
declare const MindRetroThemeColor: MindThemeColor;
declare const MindDarkThemeColor: MindThemeColor;
declare const MindStarryThemeColor: MindThemeColor;
declare const MindThemeColors: MindThemeColor[];
interface MindThemeColor extends ThemeColor {
    mode: ThemeColorMode | string;
    branchColors: string[];
    rootFill: string;
    rootTextColor: string;
}
declare const MindThemeColor: {
    isMindThemeColor(value: any): value is MindThemeColor;
};

interface WithMindOptions extends WithPluginOptions {
    emojiPadding: number;
    spaceBetweenEmojis: number;
}

declare enum AbstractHandlePosition {
    start = "start",
    end = "end"
}
declare enum AbstractResizeState {
    start = "start",
    resizing = "resizing",
    end = "end"
}
interface PlaitAbstractBoard extends PlaitOptionsBoard {
    onAbstractResize?: (state: AbstractResizeState) => void;
}
type AbstractRefs = Map<MindElement, Pick<AbstractNode, 'start' | 'end'>>;

interface PlaitMindBoard extends PlaitAbstractBoard {
}

interface PlaitMindEmojiBoard {
    renderEmoji: (container: Element | DocumentFragment, props: EmojiProps) => EmojiComponentRef;
}
declare const withEmoji: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitMindEmojiBoard;
type EmojiComponentRef = RenderComponentRef<EmojiProps>;
interface EmojiProps {
    board: PlaitBoard;
    emojiItem: EmojiItem;
    element: MindElement<EmojiData>;
    fontSize: number;
}

declare class EmojiGenerator {
    private board;
    emojiComponentRef: EmojiComponentRef | null;
    constructor(board: PlaitMindEmojiBoard & PlaitBoard);
    draw(container: Element | DocumentFragment, emoji: EmojiItem, element: MindElement<EmojiData>): void;
    destroy(): void;
}
declare class NodeEmojisGenerator {
    private board;
    static key: string;
    emojiGenerators: EmojiGenerator[];
    g?: SVGGElement;
    constructor(board: PlaitMindBoard);
    drawEmojis(element: MindElement): SVGGElement | undefined;
    destroy(): void;
}

interface ActiveData {
    selected: boolean;
}
declare class NodeActiveGenerator extends Generator<MindElement, ActiveData> {
    static key: string;
    abstractOutlineG?: SVGGElement;
    canDraw(element: MindElement<BaseData>, data: ActiveData): boolean;
    draw(element: MindElement<BaseData>, data: ActiveData): SVGGElement;
    updateAbstractOutline(element: MindElement, activeHandlePosition?: AbstractHandlePosition, resizingLocation?: number): void;
}

interface ShapeData {
    node: MindNode;
}
declare class NodeShapeGenerator extends Generator<MindElement, ShapeData> {
    constructor(board: PlaitBoard);
    canDraw(element: MindElement, data: ShapeData): boolean;
    draw(element: MindElement, data: ShapeData): SVGGElement;
}

interface NodeMoreExtraData {
    isSelected: boolean;
    isHit?: boolean;
    isHitAwarenessRectangle?: boolean | null;
    isHitCollapseArea?: boolean;
    isHitExpandArea?: boolean;
    isHitAddArea?: boolean;
    isShowCollapseAnimation?: boolean;
    isShowAddAnimation?: boolean;
    isHitStandardLeftAddArea?: boolean;
    isHitStandardLeftAwarenessRectangle?: boolean;
}
declare class NodeMoreGenerator extends Generator<MindElement, NodeMoreExtraData> {
    static key: string;
    collapseOrAddG: SVGGElement | undefined | null;
    expandG: SVGGElement | undefined | null;
    canDraw(element: MindElement<BaseData>, extraData: NodeMoreExtraData): boolean;
    draw(element: MindElement<BaseData>, extraData: NodeMoreExtraData): SVGGElement;
    toggleCollapseAndAdd(center: Point, addCenter: Point | null, standardLeftAddCenter: Point | null | undefined, stroke: string, parentG: SVGGElement, isShowCollapse: boolean, isShowAdd: boolean, isShowStandardLeftAdd: boolean, isHitAddArea: boolean, isHitStandardLeftAdd: boolean, isShowCollapseAnimation: boolean, isShowAddAnimation: boolean): void;
    toggleExpandBadge(element: MindElement, moreStartAndEnd: [Point, Point], center: Point, stroke: string, parentG: SVGGElement, isCollapsed: boolean, isHoveredExpandIcon: boolean): void;
}

declare class MindNodeComponent extends CommonElementFlavour<MindElement, PlaitMindBoard> implements OnContextChanged<MindElement, PlaitMindBoard> {
    roughSVG: RoughSVG;
    node: MindNode;
    index: number;
    shapeG: SVGGElement | null;
    linkLineG?: SVGGElement;
    nodeEmojisGenerator: NodeEmojisGenerator;
    nodeShapeGenerator: NodeShapeGenerator;
    imageGenerator: ImageGenerator<MindElement<ImageData>>;
    activeGenerator: NodeActiveGenerator;
    nodeMoreGenerator: NodeMoreGenerator;
    get textManage(): TextManage;
    constructor();
    initializeGenerator(): void;
    initialize(): void;
    onContextChanged(value: PlaitPluginElementContext<MindElement, PlaitMindBoard>, previous: PlaitPluginElementContext<MindElement, PlaitMindBoard>): void;
    drawEmojis(): void;
    drawLink(): void;
    drawTopic(): void;
    updateTopic(): void;
    trackBy: (index: number, node: MindNode) => string;
    destroy(): void;
}

declare class PlaitMindComponent extends MindNodeComponent implements BeforeContextChange<PlaitMind> {
    root: MindNode;
    initialize(): void;
    beforeContextChange(value: PlaitPluginElementContext<PlaitMind>): void;
    updateMindLayout(element?: _plait_mind.MindElement<_plait_mind.BaseData>): void;
    updateMindNodeLocation(element: PlaitMind): void;
}

declare function getRectangleByNode(node: MindNode): RectangleClient;
declare function getRectangleByElement(board: PlaitMindBoard, element: MindElement): {
    x: number;
    y: number;
    width: number;
    height: number;
};
declare function isHitMindElement(board: PlaitBoard, point: Point, element: MindElement): boolean;

declare function getEmojiRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
declare function getEmojiForeignRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
declare const isHitEmojis: (board: PlaitBoard, element: MindElement<EmojiData>, point: Point) => boolean;

declare function getTopicRectangleByNode(board: PlaitMindBoard, node: MindNode): {
    height: number;
    width: number;
    x: number;
    y: number;
};
declare function getTopicRectangleByElement(board: PlaitMindBoard, nodeRectangle: RectangleClient, element: MindElement): {
    height: number;
    width: number;
    x: number;
    y: number;
};

declare function getImageForeignRectangle(board: PlaitMindBoard, element: MindElement<ImageData>): RectangleClient;
declare const isHitImage: (board: PlaitBoard, element: MindElement<ImageData>, point: Point) => boolean;
declare const getHitImageResizeHandleDirection: (board: PlaitBoard, element: MindElement<ImageData>, point: Point) => {
    rectangle: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    handle: _plait_common.ResizeHandle;
    cursorClass: _plait_core.ResizeCursorClass;
} | undefined;

declare const MIND_ELEMENT_TO_NODE: WeakMap<MindElement<_plait_mind.BaseData>, MindNode>;

declare const getChildrenCount: (element: MindElement) => number;
declare const isChildElement: (origin: MindElement, child: MindElement) => boolean;
declare const getFirstLevelElement: (elements: MindElement[]) => MindElement<_plait_mind.BaseData>[];
declare const isChildRight: (parent: MindNode, child: MindNode) => boolean;
declare const isChildUp: (parent: MindNode, child: MindNode) => boolean;
declare const copyNewNode: (node: MindElement) => MindElement<_plait_mind.BaseData>;
declare const insertMindElement: (board: PlaitMindBoard, inheritNode: MindElement, path: Path) => void;
declare const findLastChild: (child: MindNode) => MindNode;
declare const divideElementByParent: (elements: MindElement[]) => {
    parentElements: MindElement<_plait_mind.BaseData>[];
    abstractIncludedGroups: MindElement<_plait_mind.BaseData>[][];
};
declare const getDefaultFontSizeForMindElement: (element: MindElement) => 18 | 14;

declare const getBranchDirectionsByLayouts: (branchLayouts: MindLayoutType[]) => LayoutDirection[];
declare const isCorrectLayout: (root: MindElement, layout: MindLayoutType) => boolean;
declare const isMixedLayout: (parentLayout: MindLayoutType, layout: MindLayoutType) => boolean;
declare const getInCorrectLayoutDirection: (rootLayout: MindLayoutType, layout: MindLayoutType) => LayoutDirection | undefined;
declare const correctLayoutByDirection: (layout: MindLayoutType, direction: LayoutDirection) => MindLayoutType;
declare const getLayoutDirection: (root: MindElement) => LayoutDirection[];
declare const getDefaultLayout: () => MindLayoutType;
declare const getAvailableSubLayoutsByLayoutDirections: (directions: LayoutDirection[]) => MindLayoutType[];
declare const getLayoutReverseDirection: (layoutDirection: LayoutDirection) => LayoutDirection;
declare const getRootLayout: (root: MindElement) => MindLayoutType;

declare const adjustRootToNode: (board: PlaitBoard, node: MindElement) => MindElement<_plait_mind.BaseData>;
declare const adjustAbstractToNode: (node: MindElement) => MindElement<_plait_mind.BaseData>;
declare const adjustNodeToRoot: (board: PlaitMindBoard, node: MindElement) => MindElement;

declare const createEmptyMind: (board: PlaitBoard, point: Point) => MindElement<_plait_mind.BaseData>;
declare const createMindElement: (text: string | Element$1, options: InheritAttribute) => MindElement<_plait_mind.BaseData>;
interface InheritAttribute {
    fill?: string;
    strokeColor?: string;
    strokeWidth?: number;
    strokeStyle?: number;
    shape?: MindElementShape;
    layout?: MindLayoutType;
    branchColor?: string;
    branchWidth?: number;
    branchShape?: BranchShape;
}
declare const INHERIT_ATTRIBUTE_KEYS: string[];

declare function editTopic(element: MindElement): void;
declare const getSelectedMindElements: (board: PlaitBoard, elements?: PlaitElement[]) => MindElement[];

declare const addImageFocus: (board: PlaitBoard, element: MindElement<ImageData>) => void;
declare const removeImageFocus: (board: PlaitBoard, element: MindElement<ImageData>) => void;

/**
 * 1. return new node height if height changed
 * 2. new height is effected by zoom
 */
declare const getNewNodeHeight: (board: PlaitBoard, element: MindElement, newNodeDynamicWidth: number) => number | undefined;

/**
 * Processing of branch color, width, style, etc. of the mind node
 */

declare const getBranchColorByMindElement: (board: PlaitBoard, element: MindElement) => any;
declare const getBranchShapeByMindElement: (board: PlaitBoard, element: MindElement) => any;
declare const getBranchWidthByMindElement: (board: PlaitBoard, element: MindElement) => any;
declare const getAbstractBranchWidth: (board: PlaitBoard, element: MindElement) => number;
declare const getAbstractBranchColor: (board: PlaitBoard, element: MindElement) => string | undefined;
declare const getNextBranchColor: (board: PlaitBoard, root: MindElement) => string;
declare const getDefaultBranchColor: (board: PlaitBoard, element: MindElement) => string;
declare const getDefaultBranchColorByIndex: (board: PlaitBoard, index: number) => string;
declare const getMindThemeColor: (board: PlaitBoard) => MindThemeColor;

declare const getStrokeColorByElement: (board: PlaitBoard, element: MindElement) => any;
declare const getStrokeStyleByElement: (board: PlaitBoard, element: MindElement) => StrokeStyle;
declare const getStrokeWidthByElement: (board: PlaitBoard, element: MindElement) => number;
declare const getFillByElement: (board: PlaitBoard, element: MindElement) => string;
declare const getShapeByElement: (board: PlaitBoard, element: MindElement) => MindElementShape;

declare const addActiveOnDragOrigin: (activeElement: MindElement) => void;
declare const removeActiveOnDragOrigin: (activeElement: MindElement) => void;
declare const setMindDragging: (board: PlaitBoard, state: boolean) => void;
declare const hasPreviousOrNextOfDropPath: (parent: MindElement, dropTarget: {
    target: MindElement;
    detectResult: DetectResult;
}, dropPath: Path) => {
    hasPreviousNode: boolean;
    hasNextNode: boolean;
};
declare const isDropStandardRight: (parent: MindElement, dropTarget: {
    target: MindElement;
    detectResult: DetectResult;
}) => boolean;

declare const directionCorrector: (board: PlaitBoard, node: MindNode, detectResults: DetectResult[]) => DetectResult[] | null;
declare const getAllowedDirection: (detectResults: DetectResult[], illegalDirections: DetectResult[]) => DetectResult[] | null;
declare const detectDropTarget: (board: PlaitBoard, detectPoint: Point, dropTarget: {
    target: MindElement;
    detectResult: DetectResult;
} | null, activeElements: MindElement[]) => {
    target: MindElement;
    detectResult: DetectResult;
} | null;
declare const directionDetector: (targetNode: MindNode, centerPoint: Point) => DetectResult[] | null;
declare const isValidTarget: (origin: MindElement, target: MindElement) => boolean;
declare const getPathByDropTarget: (board: PlaitBoard, dropTarget: {
    target: MindElement;
    detectResult: DetectResult;
}) => Path;

declare const drawFakeDragNode: (board: PlaitBoard, element: MindElement, offsetX: number, offsetY: number) => SVGGElement;
declare const drawFakeDropNode: (board: PlaitBoard, dropTarget: {
    target: MindElement;
    detectResult: DetectResult;
}, path: Path) => SVGGElement;

declare const separateChildren: (parentElement: MindElement) => {
    leftChildren: MindElement<_plait_mind.BaseData>[];
    rightChildren: MindElement<_plait_mind.BaseData>[];
};
declare const isSetAbstract: (element: PlaitElement) => boolean;
declare const canSetAbstract: (element: PlaitElement) => boolean;
declare const getCorrespondingAbstract: (element: MindElement) => MindElement<_plait_mind.BaseData> | undefined;
declare const getBehindAbstracts: (element: MindElement) => MindElement<_plait_mind.BaseData>[];
/**
 * return corresponding abstract that is not child of elements
 */
declare const getOverallAbstracts: (board: PlaitBoard, elements: MindElement[]) => (MindElement & AbstractNode)[];
interface AbstractRef {
    abstract: MindElement & AbstractNode;
    references: MindElement[];
}
/**
 * abstract node is valid when elements contains at least one element it is referenced with
 */
declare const getValidAbstractRefs: (board: PlaitBoard, elements: MindElement[]) => AbstractRef[];
declare function getRelativeStartEndByAbstractRef(abstractRef: AbstractRef, elements: MindElement[]): {
    start: number;
    end: number;
};
declare const insertElementHandleAbstract: (board: PlaitBoard, path: Path, step?: number, isExtendPreviousNode?: boolean, effectedAbstracts?: Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>) => Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>;
declare const deleteElementHandleAbstract: (board: PlaitBoard, deletableElements: MindElement[], effectedAbstracts?: Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>) => Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>;
declare const isChildOfAbstract: (board: PlaitBoard, element: MindElement) => boolean;

declare const getRectangleByResizingLocation: (abstractRectangle: RectangleClient, location: number, activeHandlePosition: AbstractHandlePosition, isHorizontal: boolean) => {
    y: number;
    height: number;
    x: number;
    width: number;
};
declare const getLocationScope: (board: PlaitBoard, handlePosition: AbstractHandlePosition, parentChildren: MindElement[], element: MindElement, parent: LayoutNode, isHorizontal: boolean) => {
    max: number;
    min: number;
};
declare const getHitAbstractHandle: (board: PlaitBoard, element: MindElement, point: Point) => AbstractHandlePosition | undefined;
declare const getAbstractHandleRectangle: (rectangle: RectangleClient, isHorizontal: boolean, position: AbstractHandlePosition) => {
    y: number;
    height: number;
    x: number;
    width: number;
};
declare function findLocationLeftIndex(board: PlaitBoard, parentChildren: MindElement[], location: number, isHorizontal: boolean): number;
declare function handleTouchedAbstract(board: PlaitBoard, touchedAbstract: MindElement | undefined, endPoint: Point): MindElement<_plait_mind.BaseData> | undefined;

declare const isInRightBranchOfStandardLayout: (selectedElement: MindElement) => boolean;
interface RightNodeCountRef {
    path: Path;
    rightNodeCount: number;
}
declare const insertElementHandleRightNodeCount: (board: PlaitBoard, path: Path, insertCount: number, effectedRightNodeCount?: RightNodeCountRef[]) => RightNodeCountRef[];
declare const deleteElementsHandleRightNodeCount: (board: PlaitBoard, deletableElements: MindElement[], effectedRightNodeCount?: RightNodeCountRef[]) => RightNodeCountRef[];

declare const NodeSpace: {
    getNodeWidth(board: PlaitMindBoard, element: MindElement): number;
    getNodeHeight(board: PlaitMindBoard, element: MindElement): number;
    getTopicDynamicWidth(board: PlaitMindBoard, element: MindElement): number;
    getTopicHeight(board: PlaitMindBoard, element: MindElement): number;
    getTopicMaxDynamicWidth(board: PlaitMindBoard, element: MindElement): number;
    getNodeResizableMinWidth(board: PlaitMindBoard, element: MindElement): number;
    getNodeTopicMinWidth(board: PlaitMindBoard, element: MindElement): number;
    getTextLeftSpace(board: PlaitMindBoard, element: MindElement): number;
    getTextTopSpace(board: PlaitMindBoard, element: MindElement): number;
    getImageTopSpace(board: PlaitMindBoard, element: MindElement): number;
    getEmojiLeftSpace(board: PlaitMindBoard, element: MindElement<EmojiData>): number;
    getEmojiTopSpace(board: PlaitMindBoard, element: MindElement): number;
};
declare const getFontSizeByMindElement: (board: PlaitBoard, element: MindElement) => number;
declare const normalizeWidthAndHeight: (board: PlaitMindBoard, element: MindElement, width: number, height: number) => {
    width: number;
    height: number;
};

declare function getEmojisWidthHeight(board: PlaitMindBoard, element: MindElement<EmojiData>): {
    width: number;
    height: any;
};
declare function getEmojiFontSize(element: MindElement<EmojiData>): number;

declare const getLayoutOptions: (board: PlaitMindBoard) => LayoutOptions;

declare function findNewChildNodePath(board: PlaitBoard, element: PlaitElement): number[];
declare function findNewRightChildNodePath(board: PlaitBoard, element: PlaitMind, rightNodeCount: number): number[];
declare function findNewSiblingNodePath(board: PlaitBoard, element: PlaitElement): Path$1;

declare const MIND_CENTRAL_TEXT = "\u4E2D\u5FC3\u4E3B\u9898";
declare const ABSTRACT_NODE_TEXT = "\u6982\u8981";
declare const getDefaultMindNameText: (board: PlaitBoard) => string;
declare const getAbstractNodeText: (board: PlaitBoard) => string;

declare const withMind: (baseBoard: PlaitBoard) => PlaitBoard & _plait_mind.PlaitMindEmojiBoard;

declare const withMindExtend: (board: PlaitBoard) => PlaitBoard & PlaitMindBoard;

declare const WithMindPluginKey = "plait-mind-plugin-key";
declare const BASE = 4;
declare const PRIMARY_COLOR = "#6698FF";
declare const GRAY_COLOR = "#AAAAAA";
declare const STROKE_WIDTH = 2;
declare const RESIZE_HANDLE_BUFFER_DISTANCE = 8;
declare const NODE_MORE_LINE_DISTANCE = 10;
declare const NODE_MORE_STROKE_WIDTH = 2;
declare const NODE_MORE_ICON_DIAMETER = 20;
declare const NODE_MORE_BRIDGE_DISTANCE = 10;
declare const NODE_ADD_CIRCLE_COLOR: string;
declare const NODE_ADD_HOVER_COLOR = "#6698FF";
declare const NODE_ADD_INNER_CROSS_COLOR = "white";
declare const DEFAULT_MIND_IMAGE_WIDTH = 240;
declare enum MindI18nKey {
    mindCentralText = "mind-center-text",
    abstractNodeText = "abstract-node-text"
}

declare const DefaultAbstractNodeStyle: {
    branch: {
        color: string;
        width: number;
    };
    shape: {
        strokeColor: string;
        strokeWidth: number;
    };
};
declare const DefaultNodeStyle: {
    branch: {
        width: number;
    };
    shape: {
        rectangleRadius: number;
        strokeWidth: number;
        fill: string;
    };
};

declare const TOPIC_FONT_SIZE = 14;
declare const ROOT_TOPIC_FONT_SIZE = 18;
declare const TOPIC_DEFAULT_MAX_WORD_COUNT = 34;

declare const ABSTRACT_HANDLE_COLOR = "#6698FF80";
declare const ABSTRACT_INCLUDED_OUTLINE_OFFSET = 3.5;
declare const ABSTRACT_HANDLE_LENGTH = 10;
declare const ABSTRACT_HANDLE_MASK_WIDTH = 8;

declare const MindQueries: {
    getAvailableSubLayoutsByElement: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement) => dist_layouts_types_plait_layouts.MindLayoutType[] | undefined;
    getBranchLayouts: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement) => dist_layouts_types_plait_layouts.MindLayoutType[];
    getCorrectLayoutByElement: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement) => dist_layouts_types_plait_layouts.MindLayoutType;
};

declare const MindTransforms: {
    setLayout: (board: dist_core_types_plait_core.PlaitBoard, type: dist_layouts_types_plait_layouts.MindLayoutType) => void;
    setShape: (board: dist_core_types_plait_core.PlaitBoard, shape: _plait_mind.MindElementShape) => void;
    setBranchShape: (board: dist_core_types_plait_core.PlaitBoard, branchShape: _plait_mind.BranchShape) => void;
    setBranchWidth: (board: dist_core_types_plait_core.PlaitBoard, branchWidth: number) => void;
    setBranchColor: (board: dist_core_types_plait_core.PlaitBoard, branchColor: string) => void;
    setTopic: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement, topic?: slate.Element) => void;
    setNodeManualWidth: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement, width: number) => void;
    addEmoji: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement, emojiItem: _plait_mind.EmojiItem) => void;
    removeEmoji: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.EmojiData>, emojiItem: _plait_mind.EmojiItem) => void;
    replaceEmoji: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.EmojiData>, oldEmoji: _plait_mind.EmojiItem, newEmoji: _plait_mind.EmojiItem) => void;
    insertAbstract: (board: dist_core_types_plait_core.PlaitBoard, elements: dist_core_types_plait_core.PlaitElement[]) => void;
    setAbstractsByRefs: (board: dist_core_types_plait_core.PlaitBoard, abstractRefs: _plait_mind.AbstractRefs) => void;
    setAbstractByStandardLayout: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement) => void;
    insertNodes: (board: dist_core_types_plait_core.PlaitBoard, elements: _plait_mind.MindElement[], path: slate.Path) => void;
    insertAbstractNodes: (board: dist_core_types_plait_core.PlaitBoard, validAbstractRefs: _plait_mind.AbstractRef[], elements: _plait_mind.MindElement[], path: slate.Path) => void;
    setRightNodeCountByRefs: (board: dist_core_types_plait_core.PlaitBoard, refs: _plait_mind.RightNodeCountRef[]) => void;
    removeImage: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.ImageData>) => void;
    setImage: (board: dist_core_types_plait_core.PlaitBoard, element: _plait_mind.MindElement, imageItem: dist_common_types_plait_common.CommonImageItem) => void;
    insertChildNode: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement) => void;
    insertSiblingNode: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement) => void;
    insertMind: (board: _plait_mind.PlaitMindBoard, mind: _plait_mind.MindElement) => void;
};

declare abstract class MindEmojiBaseComponent {
    fontSize: number;
    emojiItem: EmojiItem;
    board: PlaitBoard;
    element: MindElement<EmojiData>;
    abstract nativeElement(): HTMLElement;
}

export { ABSTRACT_HANDLE_COLOR, ABSTRACT_HANDLE_LENGTH, ABSTRACT_HANDLE_MASK_WIDTH, ABSTRACT_INCLUDED_OUTLINE_OFFSET, ABSTRACT_NODE_TEXT, AbstractHandlePosition, AbstractResizeState, BASE, BranchShape, DEFAULT_MIND_IMAGE_WIDTH, DefaultAbstractNodeStyle, DefaultNodeStyle, GRAY_COLOR, INHERIT_ATTRIBUTE_KEYS, LayoutDirection, LayoutDirectionsMap, MIND_CENTRAL_TEXT, MIND_ELEMENT_TO_NODE, MindColorfulThemeColor, MindDarkThemeColor, MindDefaultThemeColor, MindElement, MindElementShape, MindEmojiBaseComponent, MindI18nKey, MindNode, MindNodeComponent, MindPointerType, MindQueries, MindRetroThemeColor, MindSoftThemeColor, MindStarryThemeColor, MindThemeColor, MindThemeColors, MindTransforms, NODE_ADD_CIRCLE_COLOR, NODE_ADD_HOVER_COLOR, NODE_ADD_INNER_CROSS_COLOR, NODE_MORE_BRIDGE_DISTANCE, NODE_MORE_ICON_DIAMETER, NODE_MORE_LINE_DISTANCE, NODE_MORE_STROKE_WIDTH, NodeSpace, PRIMARY_COLOR, PlaitMind, PlaitMindComponent, RESIZE_HANDLE_BUFFER_DISTANCE, ROOT_TOPIC_FONT_SIZE, STROKE_WIDTH, TOPIC_DEFAULT_MAX_WORD_COUNT, TOPIC_FONT_SIZE, WithMindPluginKey, addActiveOnDragOrigin, addImageFocus, adjustAbstractToNode, adjustNodeToRoot, adjustRootToNode, canSetAbstract, copyNewNode, correctLayoutByDirection, createEmptyMind, createMindElement, deleteElementHandleAbstract, deleteElementsHandleRightNodeCount, detectDropTarget, directionCorrector, directionDetector, divideElementByParent, drawFakeDragNode, drawFakeDropNode, editTopic, findLastChild, findLocationLeftIndex, findNewChildNodePath, findNewRightChildNodePath, findNewSiblingNodePath, getAbstractBranchColor, getAbstractBranchWidth, getAbstractHandleRectangle, getAbstractNodeText, getAllowedDirection, getAvailableSubLayoutsByLayoutDirections, getBehindAbstracts, getBranchColorByMindElement, getBranchDirectionsByLayouts, getBranchShapeByMindElement, getBranchWidthByMindElement, getChildrenCount, getCorrespondingAbstract, getDefaultBranchColor, getDefaultBranchColorByIndex, getDefaultFontSizeForMindElement, getDefaultLayout, getDefaultMindNameText, getEmojiFontSize, getEmojiForeignRectangle, getEmojiRectangle, getEmojisWidthHeight, getFillByElement, getFirstLevelElement, getFontSizeByMindElement, getHitAbstractHandle, getHitImageResizeHandleDirection, getImageForeignRectangle, getInCorrectLayoutDirection, getLayoutDirection, getLayoutOptions, getLayoutReverseDirection, getLocationScope, getMindThemeColor, getNewNodeHeight, getNextBranchColor, getOverallAbstracts, getPathByDropTarget, getRectangleByElement, getRectangleByNode, getRectangleByResizingLocation, getRelativeStartEndByAbstractRef, getRootLayout, getSelectedMindElements, getShapeByElement, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTopicRectangleByElement, getTopicRectangleByNode, getValidAbstractRefs, handleTouchedAbstract, hasPreviousOrNextOfDropPath, insertElementHandleAbstract, insertElementHandleRightNodeCount, insertMindElement, isChildElement, isChildOfAbstract, isChildRight, isChildUp, isCorrectLayout, isDropStandardRight, isHitEmojis, isHitImage, isHitMindElement, isInRightBranchOfStandardLayout, isMixedLayout, isSetAbstract, isValidTarget, normalizeWidthAndHeight, removeActiveOnDragOrigin, removeImageFocus, separateChildren, setMindDragging, withEmoji, withMind, withMindExtend };
export type { AbstractRef, AbstractRefs, BaseData, BaseMindElement, CoordinateType, DetectResult, EmojiComponentRef, EmojiData, EmojiItem, EmojiProps, ExtendLayoutType, ExtendUnderlineCoordinateType, ImageData, InheritAttribute, LayoutDirectionMapType, PlaitAbstractBoard, PlaitMindBoard, PlaitMindEmojiBoard, RightNodeCountRef, RootBaseDirection, WithMindOptions };