import * as _plait_core from '@plait/core';
import { PlaitElement, PlaitBoard, RectangleClient, Point, ResizeCursorClass, Path, Direction, PointOfRectangle, Vector, DirectionFactor, WithPluginOptions, PlaitElementRef, ElementFlavour, PlaitGroup, OnContextChanged, PlaitPluginElementContext } from '@plait/core';
import * as slate from 'slate';
import { Element as Element$1, Editor, Operation, BaseElement } from 'slate';

declare const BASE = 4;
declare const PRIMARY_COLOR = "#6698FF";
declare const RESIZE_HANDLE_DIAMETER = 9;
declare const WithTextPluginKey = "plait-text-plugin-key";
declare const DEFAULT_ROUTE_MARGIN = 30;
declare const TRANSPARENT = "transparent";
declare const ROTATE_HANDLE_DISTANCE_TO_ELEMENT = 4;
declare const ROTATE_HANDLE_SIZE = 18;
declare const DEFAULT_FONT_FAMILY = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'PingFang SC', 'Noto Sans', 'Noto Sans CJK SC', 'Microsoft Yahei', 'Hiragino Sans GB', Arial, sans-serif";
declare const DEFAULT_FILL = "none";

declare enum MediaKeys {
    image = "image"
}
declare const PICTURE_ACCEPTED_UPLOAD_SIZE = 20;
declare const acceptImageTypes: string[];
declare const WithCommonPluginKey = "plait-common-plugin-key";

declare enum ResizeHandle {
    nw = "0",
    n = "4",
    ne = "1",
    e = "5",
    se = "2",
    s = "6",
    sw = "3",
    w = "7"
}

declare enum StrokeStyle {
    solid = "solid",
    dashed = "dashed",
    dotted = "dotted"
}

interface GeneratorExtraData {
}
interface GeneratorOptions {
    prepend?: boolean;
    active?: boolean;
}
declare abstract class Generator<T extends PlaitElement = PlaitElement, K extends GeneratorExtraData = GeneratorExtraData, V extends GeneratorOptions = GeneratorOptions, P extends PlaitBoard = PlaitBoard> {
    protected board: P;
    g?: SVGGElement;
    protected options?: V;
    constructor(board: P, options?: V);
    processDrawing(element: T, parentG: SVGGElement, data?: K): void;
    /**
     * abstract function
     */
    protected abstract canDraw(element: T, data?: K): boolean;
    /**
     * abstract function
     */
    protected abstract draw(element: T, data?: K): SVGGElement | undefined;
    destroy(): void;
}
interface AfterDraw<T extends PlaitElement = PlaitElement> {
    afterDraw(element: T): void;
}
declare function hasAfterDraw(value: any): value is AfterDraw;

interface ActiveGeneratorExtraData {
    selected: boolean;
}
interface ActiveGeneratorOptions<T> extends GeneratorOptions {
    getRectangle: (element: T) => RectangleClient;
    getStrokeWidth: () => number;
    getStrokeOpacity: () => number;
    hasResizeHandle: () => boolean;
    active: true;
}
declare const createActiveGenerator: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, options: Omit<ActiveGeneratorOptions<T>, "active">) => ActiveGenerator<T>;
declare class ActiveGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, ActiveGeneratorExtraData, ActiveGeneratorOptions<T>> {
    board: PlaitBoard;
    options: ActiveGeneratorOptions<T>;
    static key: string;
    hasResizeHandle: boolean;
    constructor(board: PlaitBoard, options: ActiveGeneratorOptions<T>);
    canDraw(element: T, data: ActiveGeneratorExtraData): boolean;
    draw(element: T, data: ActiveGeneratorExtraData): SVGGElement;
}

type PlaitElementOrArray = PlaitElement | PlaitElement[];
interface ResizeOptions {
}
interface WithResizeOptions<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
    key: string;
    canResize: () => boolean;
    hitTest: (point: Point) => ResizeHitTestRef<T, K, P> | null;
    onResize: (resizeRef: ResizeRef<T, K, P>, resizeState: ResizeState) => void;
    afterResize?: (resizeRef: ResizeRef<T, K, P>) => void;
    beforeResize?: (resizeRef: ResizeRef<T, K, P>) => void;
}
interface ResizeHitTestRef<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
    element: T;
    rectangle?: RectangleClient;
    handle: K;
    handleIndex?: number;
    cursorClass?: ResizeCursorClass;
    options?: P;
}
interface ResizeState {
    startPoint: Point;
    endPoint: Point;
    isShift: boolean;
}
interface ResizeRef<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
    element: T;
    rectangle?: RectangleClient;
    path: Path | Path[];
    handle: K;
    handleIndex?: number;
    options?: P;
}

declare const getResizeHandleByIndex: (index: number) => ResizeHandle;
declare const getIndexByResizeHandle: (resizeHandle: ResizeHandle) => number;
declare const getSymmetricHandleIndex: (board: PlaitBoard, index: number) => number;
declare const getRotatedResizeCursorClassByAngle: (cursor: ResizeCursorClass, angle: number) => ResizeCursorClass;
declare const getRectangleResizeHandleRefs: (rectangle: RectangleClient, diameter: number) => {
    rectangle: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    handle: ResizeHandle;
    cursorClass: ResizeCursorClass;
}[];
declare const getResizeHandlePointByIndex: (rectangle: RectangleClient, index: number) => Point;
declare const IS_RESIZING: WeakMap<PlaitBoard, ResizeRef<any, any, any>>;
declare const isResizing: (board: PlaitBoard) => boolean;
declare const isResizingByCondition: <T extends PlaitElementOrArray, K>(board: PlaitBoard, match: (resizeRef: ResizeRef<T, K>) => boolean) => boolean;
declare const addResizing: <T extends PlaitElementOrArray, K, P>(board: PlaitBoard, resizeRef: ResizeRef<T, K, P>, key: string) => void;
declare const removeResizing: (board: PlaitBoard, key: string) => void;
declare const isEdgeHandle: (board: PlaitBoard, handle: ResizeHandle) => boolean;
declare const isCornerHandle: (board: PlaitBoard, handle: ResizeHandle) => boolean;
declare const resetPointsAfterResize: (originRectangle: RectangleClient, currentRectangle: RectangleClient, originSelectionCenterPoint: Point, currentSelectionCenterPoint: Point, angle: number) => [Point, Point];
declare const hasMoreThanOnePoint: (element: PlaitElement) => boolean;
declare const hasResizeHandle: (board: PlaitBoard, element: PlaitElement) => boolean;

declare function getPointOnPolyline(points: Point[], ratio: number): number[];
declare function calculatePolylineLength(points: Point[]): number;
declare function getRatioByPoint(points: Point[], point: Point): number;
declare const removeDuplicatePoints: (points: Point[]) => Point[];
declare function simplifyOrthogonalPoints(points: Point[]): Point[];
declare const getExtendPoint: (source: Point, target: Point, extendDistance: number) => Point;

declare const getPoints: (source: Point, sourcePosition: Direction, target: Point, targetPosition: Direction, offset: number) => Point[];

declare function isVirtualKey(e: KeyboardEvent): boolean;
declare const isExpandHotkey: (event: KeyboardEvent) => boolean;
declare const isTabHotkey: (event: KeyboardEvent) => boolean;
declare const isEnterHotkey: (event: KeyboardEvent) => boolean;
declare const isSpaceHotkey: (event: KeyboardEvent) => boolean;
declare const isDelete: (event: KeyboardEvent) => boolean;

declare enum BoardCreationMode {
    'dnd' = "dnd",
    'drawing' = "drawing"
}
declare const getCreationMode: (board: PlaitBoard) => BoardCreationMode | undefined;
declare const setCreationMode: (board: PlaitBoard, mode: BoardCreationMode) => void;
declare const isDndMode: (board: PlaitBoard) => boolean;
declare const isDrawingMode: (board: PlaitBoard) => boolean;

declare function getOppositeDirection(direction: Direction): Direction;
declare function getDirectionByPointOfRectangle(point: PointOfRectangle): Direction | undefined;
/**
 * this function accepts vector parameter, the vector parameter vector is based on the screen coordinate system
 * vector[0] and vector[1] are the x and y components of the vector respectively.
 * if the vector has only one direction, the function returns a string in that direction, such as 'right', 'top', 'bottom' or 'left'.
 * if the vector has two directions, the function will return the string in which direction it is closer.
 */
declare function getDirectionByVector(vector: Vector): Direction | null;
declare function getDirectionBetweenPointAndPoint(source: Point, target: Point): Direction;
declare function getDirectionFactor(direction: Direction): {
    x: number;
    y: number;
} | {
    x: number;
    y: number;
} | {
    x: number;
    y: number;
} | {
    x: number;
    y: number;
};
declare function getDirectionFactorByDirectionComponent(directionComponent: number): DirectionFactor;

interface RenderComponentRef<T> {
    destroy: () => void;
    update: (props: Partial<T>) => void;
}

interface PlaitTextBoard {
    renderText: (container: Element | DocumentFragment, props: TextProps) => TextComponentRef;
}
declare const withText: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitTextBoard;
type TextComponentRef = RenderComponentRef<TextProps>;
interface TextProps {
    board: PlaitBoard;
    text: Element$1;
    textPlugins?: TextPlugin[];
    readonly?: boolean;
    onChange?: (data: TextChangeData) => void;
    afterInit?: (data: Editor) => void;
    onComposition?: (data: CompositionEvent) => void;
}
type TextChangeData = {
    newText: Element$1;
    operations: Operation[];
};
interface WithTextPluginOptions extends WithPluginOptions {
    textPlugins?: TextPlugin[];
}
type TextPlugin = (editor: Editor) => Editor;

interface TextManageChangeData {
    newText?: Element$1;
    operations?: Operation[];
    width: number;
    height: number;
}
declare class TextManage {
    private board;
    private options;
    isEditing: boolean;
    editor: Editor;
    g: SVGGElement;
    foreignObject: SVGForeignObjectElement;
    textComponentRef: TextComponentRef;
    exitCallback?: () => void;
    constructor(board: PlaitBoard, options: {
        getRectangle: () => RectangleClient;
        onChange?: (data: TextManageChangeData) => void;
        getRenderRectangle?: () => RectangleClient;
        getMaxWidth?: () => number;
        textPlugins?: TextPlugin[];
    });
    draw(text: Element$1): void;
    updateRectangleWidth(width: number): void;
    updateAngle(centerPoint: Point, angle?: number): void;
    updateRectangle(rectangle?: RectangleClient): void;
    updateText(newText: Element$1): void;
    edit(callback?: () => void, exitEdit?: (event: Event) => boolean): () => void;
    getSize: (element?: Element$1, maxWidth?: number) => {
        width: number;
        height: number;
    };
    getText: () => slate.Descendant;
    destroy(): void;
}
declare const buildCompositionData: (editor: Editor, data: string) => {
    children: any[];
} | null;

type ElementSize = {
    width: number;
    height: number;
};
declare enum Alignment {
    left = "left",
    center = "center",
    right = "right"
}
type CustomText = {
    bold?: boolean;
    italic?: boolean;
    strike?: boolean;
    code?: boolean;
    text: string;
    underlined?: boolean;
    color?: string;
    [`font-size`]?: string;
};
interface LinkElement extends BaseElement {
    type: 'link';
    url: string;
}
interface ParagraphElement extends BaseElement {
    align?: Alignment;
}
type CustomElement = ParagraphElement | LinkElement;

interface TextInterface {
    getTextEditors: (board: PlaitBoard, elements?: PlaitElement[]) => Editor[] | undefined;
    findFirstTextEditor: (board: PlaitBoard) => null;
    getFirstTextEditor: (element: PlaitElement) => Editor;
    getTextEditorsByElement: (element: PlaitElement) => Editor[];
    getEditingTextEditor: (board: PlaitBoard, elements?: PlaitElement[]) => Editor | undefined;
}
declare const getTextManages: (element: PlaitElement) => TextManage[];
declare const getFirstTextManage: (element: PlaitElement) => TextManage;
declare const getTextEditorsByElement: TextInterface['getTextEditorsByElement'];
declare const getFirstTextEditor: TextInterface['getFirstTextEditor'];
declare const findFirstTextEditor: TextInterface['findFirstTextEditor'];
declare const getElementsText: (elements: PlaitElement[]) => string;
declare const getTextEditors: TextInterface['getTextEditors'];
declare const getEditingTextEditor: TextInterface['getEditingTextEditor'];
declare const buildText: (text: string | Element$1, align?: Alignment, properties?: Partial<CustomText>) => slate.BaseElement | {
    children: {
        bold?: boolean | undefined;
        italic?: boolean | undefined;
        strike?: boolean | undefined;
        code?: boolean | undefined;
        text: string;
        underlined?: boolean | undefined;
        color?: string | undefined;
        "font-size"?: string | undefined;
    }[];
    type: string;
};
declare const getLineHeightByFontSize: (fontSize: number) => number;

interface CommonImageItem {
    url: string;
    width: number;
    height: number;
}
declare const selectImage: (board: PlaitBoard, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void, acceptImageTypes?: string[]) => void;
declare const buildImage: (board: PlaitBoard, imageFile: File, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void) => Promise<void>;
declare const getElementOfFocusedImage: (board: PlaitBoard) => PlaitElement | undefined;
declare const addElementOfFocusedImage: (board: PlaitBoard, element: PlaitElement) => void;
declare const removeElementOfFocusedImage: (board: PlaitBoard) => void;

declare class PointNode {
    data: Point;
    distance: number;
    adjacentNodes: PointNode[];
    constructor(data: Point);
}
declare class PointGraph {
    private index;
    add(p: Point): void;
    connect(a: Point, b: Point): void;
    has(p: Point): boolean;
    get(p: Point): PointNode | null;
}

declare class AStar {
    private graph;
    cameFrom: Map<PointNode, PointNode>;
    constructor(graph: PointGraph);
    heuristic(a: Point, b: Point): number;
    search(start: Point, end: Point, previousStart: Point): void;
    getRoute(start: Point, end: Point): Point[];
}

declare class PriorityQueue {
    list: {
        node: PointNode;
        priority: number;
    }[];
    constructor();
    enqueue(item: {
        node: PointNode;
        priority: number;
    }): void;
    dequeue(): {
        node: PointNode;
        priority: number;
    } | undefined;
}

interface ElbowLineRouteOptions {
    sourcePoint: Point;
    nextSourcePoint: Point;
    sourceRectangle: RectangleClient;
    sourceOuterRectangle: RectangleClient;
    targetPoint: Point;
    nextTargetPoint: Point;
    targetOuterRectangle: RectangleClient;
    targetRectangle: RectangleClient;
}
interface RouteAdjustOptions {
    centerX?: number;
    centerY?: number;
    sourceRectangle: RectangleClient;
    targetRectangle: RectangleClient;
}
interface AdjustOptions {
    parallelPaths: [Point, Point][];
    pointOfHit: Point;
    sourceRectangle: RectangleClient;
    targetRectangle: RectangleClient;
}
declare const generateElbowLineRoute: (options: ElbowLineRouteOptions, board?: PlaitBoard) => Point[];
declare const routeAdjust: (path: Point[], options: RouteAdjustOptions, board?: PlaitBoard) => Point[];
declare const getGraphPoints: (options: ElbowLineRouteOptions) => Point[];
declare const createGraph: (points: Point[]) => PointGraph;
declare const reduceRouteMargin: (sourceRectangle: RectangleClient, targetRectangle: RectangleClient) => {
    sourceOffset: number[];
    targetOffset: number[];
};
declare const getNextPoint: (point: Point, outerRectangle: RectangleClient, direction: Direction) => Point;
declare const getSourceAndTargetOuterRectangle: (sourceRectangle: RectangleClient, targetRectangle: RectangleClient) => {
    sourceOuterRectangle: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    targetOuterRectangle: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
};
declare const isSourceAndTargetIntersect: (options: ElbowLineRouteOptions) => boolean;

declare const memorizeLatest: <T extends PlaitElement = PlaitElement>(memorizedKey: string, propertyKey: keyof T, propertyValue: T[keyof T]) => void;
declare const getMemorizedLatest: <T extends PlaitElement = PlaitElement>(memorizedKey: string) => T;

declare function getUnitVectorByPointAndPoint(point1: Point, point2: Point): Point;
declare function getPointByVectorComponent(point: Point, vector: Vector, component: number): Point;
declare function getPointByVectorDirectionComponent(point: Point, unitVector: Vector, directionComponent: number, isHorizontal: boolean): Point;
declare function rotateVectorAnti90(vector: Vector): Vector;
declare function rotateVector(vector: Vector, angle: number): Vector;

declare function isPointOnSegment(point: Point, startPoint: Point, endPoint: Point): boolean;
declare const getCrossingPointsBetweenPointAndSegment: (point: Point, startPoint: Point, endPoint: Point) => Point[];

declare const drawHandle: (board: PlaitBoard, centerPoint: Point) => SVGGElement;
declare function drawFillPrimaryHandle(board: PlaitBoard, point: Point): SVGGElement;
declare function drawPrimaryHandle(board: PlaitBoard, point: Point): SVGGElement;

declare const drawRotateHandle: (board: PlaitBoard, rectangle: RectangleClient) => SVGGElement;

interface RotateRef<T extends PlaitElement = PlaitElement> {
    elements: T[];
    startPoint: Point;
    angle?: number;
}

declare const IS_ROTATING: WeakMap<PlaitBoard, RotateRef<_plait_core.PlaitElement>>;
declare const isRotating: (board: PlaitBoard) => boolean;
declare const addRotating: (board: PlaitBoard, rotateRef: RotateRef) => void;
declare const removeRotating: (board: PlaitBoard) => void;

declare const getElementArea: (board: PlaitBoard, element: PlaitElement) => number;
declare const sortElementsByArea: (board: PlaitBoard, elements: PlaitElement[], direction?: "desc" | "asc") => PlaitElement[];
declare const isFilled: (fill: string) => boolean | "";

type AnimateOption = {
    stop: () => void;
    start: () => void;
};
declare function animate(tween: (t: number) => void, duration: number, ease: Function, callback: Function): AnimateOption;
declare function getTimestamp(): number;
declare function linear(t: number): number;

declare const getStrokeLineDash: (strokeStyle: StrokeStyle, strokeWidth: number) => number[] | undefined;

declare const buildClipboardData: (board: PlaitBoard, elements: PlaitElement[], startPoint: Point, elementBuilder?: (element: PlaitElement) => PlaitElement | undefined) => (PlaitElement | {
    points: number[][];
    id: string;
    children?: PlaitElement[];
    type?: string;
    groupId?: string;
    angle?: number;
})[];
declare const insertClipboardData: (board: PlaitBoard, elements: PlaitElement[], startPoint: Point, elementHandler?: (element: PlaitElement, idsMap: Record<string, string>) => void) => void;

declare const moveXOfPoint: (point: Point, distance: number, direction?: Direction) => Point;
declare const moveYOfPoint: (point: Point, distance: number, direction?: Direction) => Point;
declare const getDirectionByIndex: (index: number) => Direction;
declare const getXDistanceBetweenPoint: (point1: Point, point2: Point, isHorizontal: boolean) => number;

interface PlaitImageBoard {
    renderImage: (container: Element | DocumentFragment, props: ImageProps) => ImageComponentRef;
}
declare const withImage: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitImageBoard;
type ImageComponentRef = RenderComponentRef<ImageProps>;
interface ImageProps {
    board: PlaitBoard;
    imageItem: CommonImageItem;
    element: PlaitElement;
    isFocus?: boolean;
    getRectangle: () => RectangleClient;
}

declare const FOREIGN_OBJECT_IMAGE_CLASS_NAME = "foreign-object-image";
interface ImageGeneratorOptions<T> {
    getRectangle: (element: T) => RectangleClient;
    getImageItem: (element: T) => CommonImageItem;
}
declare class ImageGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, GeneratorExtraData, ImageGeneratorOptions<T> & GeneratorOptions> {
    board: PlaitBoard;
    options: ImageGeneratorOptions<T>;
    static key: string;
    foreignObject: SVGForeignObjectElement;
    imageComponentRef: ImageComponentRef;
    activeGenerator: ActiveGenerator;
    isFocus: boolean;
    element: T;
    constructor(board: PlaitBoard, options: ImageGeneratorOptions<T>);
    canDraw(element: T): boolean;
    draw(element: T): SVGGElement;
    updateImage(nodeG: SVGGElement, previous: T, current: T): void;
    setFocus(element: PlaitElement, isFocus: boolean): void;
    destroy(): void;
}

interface SetOptions<T extends PlaitElement = PlaitElement> {
    callback?: (element: T, path: Path) => void;
    getMemorizeKey?: (element: T) => string;
    match?: (element: T) => boolean;
}
declare const setProperty: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, properties: Partial<T>, options?: SetOptions<T>) => void;
declare const PropertyTransforms: {
    setFillColor: (board: PlaitBoard, fill: string | null, options: SetOptions) => void;
    setStrokeStyle: (board: PlaitBoard, strokeStyle: string, options: SetOptions) => void;
    setProperty: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, properties: Partial<T>, options?: SetOptions<T>) => void;
    setStrokeWidth: (board: PlaitBoard, strokeWidth: number, options: SetOptions) => void;
    setStrokeColor: (board: PlaitBoard, strokeColor: string | null, options: SetOptions) => void;
};

declare const alignTop: (board: PlaitBoard) => void;
declare const alignBottom: (board: PlaitBoard) => void;
declare const alignLeft: (board: PlaitBoard) => void;
declare const alignHorizontalCenter: (board: PlaitBoard) => void;
declare const alignVerticalCenter: (board: PlaitBoard) => void;
declare const alignRight: (board: PlaitBoard) => void;
declare const distributeHorizontal: (board: PlaitBoard) => void;
declare const distributeVertical: (board: PlaitBoard) => void;
interface AlignTransform {
    alignTop: (board: PlaitBoard) => void;
    alignHorizontalCenter: (board: PlaitBoard) => void;
    alignBottom: (board: PlaitBoard) => void;
    alignLeft: (board: PlaitBoard) => void;
    alignVerticalCenter: (board: PlaitBoard) => void;
    alignRight: (board: PlaitBoard) => void;
    distributeHorizontal: (board: PlaitBoard) => void;
    distributeVertical: (board: PlaitBoard) => void;
}
declare const AlignTransform: AlignTransform;

declare const normalizeShapePoints: (points: [Point, Point], shift?: boolean) => [Point, Point];

declare const withResize: <T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions>(board: PlaitBoard, options: WithResizeOptions<T, K, P>) => PlaitBoard;

declare function withGroup(board: PlaitBoard): PlaitBoard;

declare abstract class ImageBaseComponent {
    _isFocus: boolean;
    element: PlaitElement;
    board: PlaitBoard;
    set isFocus(value: boolean);
    get isFocus(): boolean;
    abstract nativeElement(): HTMLElement;
}

declare const getElementSize: (board: PlaitBoard | null, element: ParagraphElement, options: {
    fontSize: number;
    fontFamily: string;
}, containerMaxWidth?: number) => ElementSize;
declare const updateElementSizeCache: (board: PlaitBoard | null, element: ParagraphElement, size: ElementSize) => void;
declare const clearElementSizeCache: (board: PlaitBoard | null, element: ParagraphElement) => void;
declare function measureElement(board: PlaitBoard | null, element: ParagraphElement, options: {
    fontSize: number;
    fontFamily: string;
}, containerMaxWidth?: number): {
    width: number;
    height: number;
};

declare class PlaitCommonElementRef implements PlaitElementRef {
    private textManages;
    private generatorMap;
    addGenerator<T extends Object = Generator>(key: string, generator: T): void;
    getGenerator<T extends Object = Generator>(key: string): T;
    initializeTextManage(textManage: TextManage | TextManage[]): void;
    getTextManages(): TextManage[];
    updateActiveSection: () => void;
    destroyTextManage(): void;
}

declare class CommonElementFlavour<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard, R extends PlaitCommonElementRef = PlaitCommonElementRef> extends ElementFlavour<T, K, R> {
    constructor(elementRef?: PlaitCommonElementRef);
}

declare class GroupGenerator extends Generator<PlaitGroup> {
    static key: string;
    canDraw(element: PlaitGroup): boolean;
    draw(element: PlaitGroup, partialSelected: boolean): SVGGElement;
}

declare class GroupComponent extends CommonElementFlavour<PlaitGroup, PlaitBoard> implements OnContextChanged<PlaitGroup, PlaitBoard> {
    constructor();
    activeGenerator: ActiveGenerator<PlaitGroup>;
    groupGenerator: GroupGenerator;
    initializeGenerator(): void;
    initialize(): void;
    onContextChanged(value: PlaitPluginElementContext<PlaitGroup, PlaitBoard>, previous: PlaitPluginElementContext<PlaitGroup, PlaitBoard>): void;
}

export { AStar, ActiveGenerator, AlignTransform, Alignment, BASE, BoardCreationMode, CommonElementFlavour, DEFAULT_FILL, DEFAULT_FONT_FAMILY, DEFAULT_ROUTE_MARGIN, FOREIGN_OBJECT_IMAGE_CLASS_NAME, Generator, GroupComponent, IS_RESIZING, IS_ROTATING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PlaitCommonElementRef, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, ResizeHandle, StrokeStyle, TRANSPARENT, TextManage, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, addRotating, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, animate, buildClipboardData, buildCompositionData, buildImage, buildText, calculatePolylineLength, clearElementSizeCache, createActiveGenerator, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, drawRotateHandle, findFirstTextEditor, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirectionBetweenPointAndPoint, getDirectionByIndex, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByDirectionComponent, getEditingTextEditor, getElementArea, getElementOfFocusedImage, getElementSize, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getLineHeightByFontSize, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByVectorComponent, getPointByVectorDirectionComponent, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getRotatedResizeCursorClassByAngle, getSourceAndTargetOuterRectangle, getStrokeLineDash, getSymmetricHandleIndex, getTextEditors, getTextEditorsByElement, getTextManages, getTimestamp, getUnitVectorByPointAndPoint, getXDistanceBetweenPoint, hasAfterDraw, hasMoreThanOnePoint, hasResizeHandle, insertClipboardData, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isFilled, isPointOnSegment, isResizing, isResizingByCondition, isRotating, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, linear, measureElement, memorizeLatest, moveXOfPoint, moveYOfPoint, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, removeRotating, resetPointsAfterResize, rotateVector, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, sortElementsByArea, updateElementSizeCache, withGroup, withImage, withResize, withText };
export type { ActiveGeneratorExtraData, ActiveGeneratorOptions, AdjustOptions, AfterDraw, AnimateOption, CommonImageItem, CustomElement, CustomText, ElbowLineRouteOptions, ElementSize, GeneratorExtraData, GeneratorOptions, ImageComponentRef, ImageGeneratorOptions, ImageProps, LinkElement, ParagraphElement, PlaitElementOrArray, PlaitImageBoard, PlaitTextBoard, RenderComponentRef, ResizeHitTestRef, ResizeOptions, ResizeRef, ResizeState, RotateRef, RouteAdjustOptions, SetOptions, TextChangeData, TextComponentRef, TextInterface, TextManageChangeData, TextPlugin, TextProps, WithResizeOptions, WithTextPluginOptions };