import { Circle } from 'konva/lib/shapes/Circle';
import { Line } from 'konva/lib/shapes/Line';
import * as konva_lib_Group from 'konva/lib/Group';
import { Group } from 'konva/lib/Group';
import * as konva_lib_Shape from 'konva/lib/Shape';
import { Shape } from 'konva/lib/Shape';
import { Layer } from 'konva/lib/Layer';
import { Stage } from 'konva/lib/Stage';
import * as mitt from 'mitt';
import { Emitter } from 'mitt';
import * as konva_lib_Node from 'konva/lib/Node';
import { KonvaEventObject, Node } from 'konva/lib/Node';
import * as vue from 'vue';
import { Ref } from 'vue';
import * as three from 'three';
import { Matrix4 } from 'three';
import { Transform } from 'konva/lib/Util';
import { Label } from 'konva/lib/shapes/Label';
import { History } from 'stateshot';
import { Map } from 'ol';

type ShapeType = Group | Layer | Stage | Shape;
interface GetSet<Type, This> {
    (a: Type): This;
}
type GetSetPick<T extends Shape | Group> = {
    [key in keyof T]?: T[key] extends GetSet<infer V, T> ? V : never;
};
type ShapeStylesStatusKey = "common" | "hover" | "active" | "draging";
type ShapeStylesStatus = {
    draging: boolean;
    hover: boolean;
    active: boolean;
    common: boolean;
};
type ShapeStyles = {
    common: (ev?: KonvaEventObject<any>) => void;
    bus?: Emitter<{
        statusChange: Partial<ShapeStylesStatus> | null;
        shapeStatusChange: {
            type?: "click" | "mouse";
            current: ShapeStylesStatusKey;
            before: ShapeStylesStatusKey;
        };
    }>;
    getStatus?: (status: ShapeStylesStatus, ev: KonvaEventObject<any>) => ShapeStylesStatusKey | null;
    hover?: (ev?: KonvaEventObject<any>) => void;
    active?: (ev?: KonvaEventObject<any>) => void;
    draging?: (ev?: KonvaEventObject<any>) => void;
};
type Attrib = {
    id: string;
};
type CustomizeShape<T, R = Shape | Group, Attach = {}> = {
    shape: R;
    setData: (data: T) => void;
} & ShapeStyles & Attach;
type CustomizeShapeFactory<R, T, S = Shape | Group, A = any, Attach = {}> = (data: R, tree: A) => CustomizeShape<T, S, Attach>;
type Plugin = {
    setTree(tree: Container): any;
    destory?: () => void;
};

declare const point: {
    fill: string;
    radius: number;
    stroke: string;
    strokeWidth: number;
    zIndex: number;
    hitStrokeWidth: number;
    activeFill: string;
    activeStroke: string;
};
declare const pointShapeFactory: () => {
    shape: Circle;
    setData(data: number[]): void;
    common: () => void;
    hover: () => void;
    active: () => void;
    draging: () => void;
};
declare const line: {
    strokeWidth: number;
    hitStrokeWidth: number;
    stroke: string;
    zIndex: number;
    activeStroke: string;
};
declare const lineShapeFactory: () => {
    shape: Line<{
        strokeScaleEnabled: false;
        strokeWidth: number;
        hitStrokeWidth: number;
    }>;
    setData(data: number[]): void;
    common: () => void;
    hover: () => void;
    active: () => void;
    draging: () => void;
};
declare const polygon: {
    stroke: string;
    strokeWidth: number;
    fill: string;
    activeFill: string;
    zIndex: number;
};
type PolygonShapeProps = {
    autoClose?: boolean;
    lineFactory?: () => CustomizeShape<number[]>;
};
declare const polygonShapeFactory: (props?: PolygonShapeProps) => {
    closeLine: CustomizeShape<number[]> | {
        shape: Line<{
            strokeScaleEnabled: false;
            strokeWidth: number;
            hitStrokeWidth: number;
        }>;
        setData(data: number[]): void;
        common: () => void;
        hover: () => void;
        active: () => void;
        draging: () => void;
    };
    shape: Group;
    setData(data: number[]): void;
    common: (ev?: KonvaEventObject<any>) => void;
    hover: (ev?: KonvaEventObject<any>) => void;
    active: (ev: KonvaEventObject<any>) => void;
    draging: (ev: KonvaEventObject<any>) => void;
};

declare const style_d_line: typeof line;
declare const style_d_lineShapeFactory: typeof lineShapeFactory;
declare const style_d_point: typeof point;
declare const style_d_pointShapeFactory: typeof pointShapeFactory;
declare const style_d_polygon: typeof polygon;
declare const style_d_polygonShapeFactory: typeof polygonShapeFactory;
declare namespace style_d {
  export { style_d_line as line, style_d_lineShapeFactory as lineShapeFactory, style_d_point as point, style_d_pointShapeFactory as pointShapeFactory, style_d_polygon as polygon, style_d_polygonShapeFactory as polygonShapeFactory };
}

declare const disableMouse: () => void;
declare const enableMouse: () => void;
declare const getActiveKey: (status: Partial<ShapeStylesStatus>, excludes?: string[]) => "common" | "hover" | "active" | "draging";
declare const openShapeMouseStyles: <T extends Group | Shape<konva_lib_Shape.ShapeConfig>>(shape: T, styles: ShapeStyles, namespace?: string) => () => void;
type DragHandlers<T> = {
    readyHandler?: (ev: KonvaEventObject<any>) => T;
    moveHandler: (move: number[], readyData: T, ev: KonvaEventObject<any>) => void;
    endHandler?: (readyData: T, ev: KonvaEventObject<any>) => void;
};
declare const openShapeDrag: <T extends Group | Shape<konva_lib_Shape.ShapeConfig>, D>(shape: T, handler: DragHandlers<D>, transform?: boolean, tfIncludeSelf?: boolean) => () => void;
type EntityDragHandlers<R extends Attrib, T> = {
    readyHandler?: (attrib: R, ev: KonvaEventObject<any>) => T;
    moveHandler: (attrib: R, move: number[], readyData: T, ev: KonvaEventObject<any>) => void;
    endHandler?: (attrib: R, readyData: T, ev: KonvaEventObject<any>) => void;
};
declare const openEntityDrag: <T extends Attrib, S extends ShapeType, R>(entity: Entity<T, S>, handler: EntityDragHandlers<T, R>) => void;
declare const shapeTreeEq: (parent: ShapeType, eq: (shape: ShapeType) => boolean) => ShapeType;
declare const shapeParentsEq: (target: ShapeType, eq: (shape: ShapeType) => boolean) => ShapeType;
declare const shapeTreeContain: (parent: ShapeType, target: ShapeType) => boolean;

declare const entityFactory: <T extends Attrib, S extends ShapeType, C extends EntityType<T, S, {
    attrib: T;
}>>(attrib: T, Type: C, parent?: Entity<any, any>, extra?: (self: InstanceType<C>) => void, created?: (self: InstanceType<C>) => void) => InstanceType<C>;
type IncEntitysFactory<T extends Attrib, E extends Entity<T, any>> = (attribs: T[] | T) => IncEntitys<T, E>;
type IncEntitys<T extends Attrib, E extends Entity<T, any>> = {
    adds: E[];
    dels: E[];
    upds: E[];
};
declare const incEntitysFactoryGenerate: <T extends Attrib, S extends ShapeType, C extends EntityType<T, S, {
    attrib: T;
}, any>>(Type: C, parent?: Entity<any, any, any>, extra?: (self: InstanceType<C>) => void, created?: (self: InstanceType<C>) => void) => (attribsRaw: T | T[]) => {
    adds: InstanceType<C>[];
    dels: InstanceType<C>[];
    upds: InstanceType<C>[];
};
type CopyProps<T extends Entity = Entity> = {
    entity: T;
    count?: number;
    dire?: number[];
    size: number[];
    factoryAttrib(pos: number[]): any;
};
declare const copyEntityAttrib: <T extends Entity<Attrib, ShapeType, EntityEvent> = Entity<Attrib, ShapeType, EntityEvent>>(props: CopyProps<T>) => void;
declare const addEntityAttrib: (container: Container, factoryAttrib: (pos: number[]) => any) => {
    promise: Promise<any>;
    interrupt: () => void;
};
declare const updateEntityStatus: (entity: Entity, status: ShapeStylesStatusKey) => void;
declare const entityActiveDualControl: (entity: Entity) => {
    light: vue.Ref<boolean>;
    active: vue.Ref<boolean>;
    stop: vue.WatchStopHandle;
};
declare const entitysActiveDualControl: (entitys: Entity[]) => void;

/**
 * 点是否相同
 * @param p1 点1
 * @param p2 点2
 * @returns 是否相等
 */
declare const eqPoint: (p1: number[], p2: number[]) => boolean;
/**
 * 获取两点距离
 * @param p1 点1
 * @param p2 点2
 * @returns 距离
 */
declare const getLineDist: (p1: number[], p2: number[]) => number;
declare const getDireDist: (dire: number[]) => number;
/**
 * 获取线段方向
 * @param line 线段
 * @returns 方向
 */
declare const getLineDire: (line: number[]) => three.Vector2Tuple;
/**
 * 获取向量的垂直向量
 * @param dire 原方向
 * @returns 垂直向量
 */
declare const getVerticalDire: (dire: number[]) => three.Vector2Tuple;
/**
 * 获取旋转指定度数后的向量
 * @param dire 远向量
 * @param angleRad 旋转角度
 * @returns 旋转后向量
 */
declare const getRotateDire: (dire: number[], angleRad: number) => three.Vector2Tuple;
/**
 * 创建线段
 * @param dire 向量
 * @param start 起始点
 * @param dis 长度
 * @returns 线段
 */
declare const createLineByDire: (dire: number[], start: number[], dis: number) => number[];
/**
 * 获取线段的垂直方向向量
 * @param line 原线段
 * @returns 垂直向量
 */
declare const getVerticaLineDire: (line: number[]) => three.Vector2Tuple;
/**
 * 获取向量的垂直线段
 * @param dire 向量
 * @param origin 线段原点
 * @param len 线段长度
 */
declare const getVerticalDireLine: (dire: number[], origin?: number[], len?: number) => number[];
/**
 * 获取两向量角度(从向量a出发)
 * @param dire1 向量a
 * @param dire2 向量b
 * @returns 两向量夹角弧度， 逆时针为正，顺时针为负
 */
declare const getDire2Angle: (dire1: number[], dire2: number[]) => number;
/**
 * 获取两线段角度(从线段a出发)
 * @param line1 线段a
 * @param line2 线段b
 * @returns 两线段夹角弧度
 */
declare const getLine2Angle: (line1: number[], line2: number[]) => number;
/**
 * 获取线段与方向的夹角弧度
 * @param line 线段
 * @param dire 方向
 * @returns 线段与方向夹角弧度
 */
declare const getLineDireAngle: (line: number[], dire: number[]) => number;
/**
 * 获取线段中心点
 * @param line
 * @returns
 */
declare const getLineCenter: (line: number[]) => number[];
/**
 * 四舍五入
 * @param num
 * @param b 保留位数
 * @returns
 */
declare const round: (num: number, b?: number) => number;
declare enum RelationshipEnum {
    Overlap = "Overlap",
    Intersect = "Intersect",
    ExtendIntersect = "ExtendIntersect",
    Parallel = "Parallel",
    Join = "Join",
    Equal = "Equal",
    None = "None"
}
/**
 * 获取两线段是什么关系，（重叠、相交、平行、首尾相接等）
 * @param line1
 * @param line2
 * @returns RelationshipEnum
 */
declare const getLineRelationship: (line1: number[], line2: number[]) => RelationshipEnum.Overlap | RelationshipEnum.Intersect | RelationshipEnum.ExtendIntersect | RelationshipEnum.Parallel | RelationshipEnum.Join | RelationshipEnum.Equal;
/**
 * 获取两线段交点
 * @param line1 线段1
 * @param line2 线段2
 * @returns 交点坐标
 */
declare const getLineIntersection: (line1: number[], line2: number[], needIntersects?: RelationshipEnum[]) => three.Vector2Tuple;
/**
 * 获取点在线段上的投影
 * @param line 线段
 * @param position 点
 * @returns 投影信息
 */
declare const getLineProjection: (line: number[], position: number[]) => {
    point: three.Vector2Tuple;
    len: number;
};
/**
 * 通过一个点获取到直线上最近的点
 * @param line 直线
 * @param point 参考点
 * @returns 最近的点
 */
declare const getLineNearPoint: (line: number[], point: number[]) => number[];
/**
 * 获取点距离线段最近距离
 * @param line 直线
 * @param point 参考点
 * @returns 距离
 */
declare const getLineNearPointDist: (line: number[], point: number[]) => number;
/**
 * 计算多边形是否为逆时针
 * @param points 多边形顶点
 * @returns true | false
 */
declare const polygonCounterclockwise: (points: number[][]) => boolean;
declare const getLineInnerContinuityPoints: (line: number[], unitSize: number[], count?: number) => number[][];
declare const isLineIntersectingPolygon: (polygonPoints: number[][], line: number[]) => boolean;

declare const objectToString: () => string;
declare const toTypeString: (value: unknown) => string;
declare const toRawType: (value: unknown) => string;
declare const inRevise: (raw1: any, raw2: any) => any;

declare const setShapeConfig: <T extends Group | Shape<konva_lib_Shape.ShapeConfig>>(shape: T, config: GetSetPick<T>) => void;
declare const getChangePart: <T>(newIds: T[], oldIds?: T[]) => {
    addPort: T[];
    delPort: T[];
    holdPort: T[];
};
declare const getChangeAllPoart: <T extends Attrib>(newAttribs: T[], oldAttribs: T[]) => {
    changePort: string[];
    addPort: string[];
    delPort: string[];
    holdPort: string[];
};
type AttribsChange = ReturnType<typeof getChangePart> & {
    changePort: string[];
};
declare const watchAttribs: (attribs: Attrib[], callback: (data: AttribsChange) => void, immediate?: boolean) => vue.WatchStopHandle;
declare const deptComputed: <T extends Record<string, any>>(getter: () => T) => {
    data: T;
    stop: vue.WatchStopHandle;
};
declare const partialComputed: <T extends Attrib>(getter: () => T[]) => {
    data: T[];
    stop: vue.WatchStopHandle;
};
declare const depPartialUpdate: <T>(newData: T, oldData: T) => T;
declare const testPoint: (stage: Stage, points: number[][]) => void;
declare const getFlatChildren: (root: Entity<Attrib, ShapeType, any>) => Entity<Attrib, ShapeType, EntityEvent>[];
declare const generateId: (attribs: Attrib[]) => string;
declare const mergeFuns: (...fns: (() => void)[] | (() => void)[][]) => () => void;

declare const getAbsoluteTransform: (shape: Node, includeSelf?: boolean) => Transform;
declare function getTfScaleFactors(tf: Transform): {
    x: number;
    y: number;
};
declare const getRealAbsoluteSize: (shape: Node, size: number[], includeSelf?: boolean) => number[];

type SVGPaths = (string | {
    fill?: string;
    stroke?: string;
    strokeWidth?: number;
    data: string;
})[];
declare const analysisSvg: (svgString: string) => Pick<PathsToActShapeProps, "paths" | "size">;
type PathsToActShapeProps = {
    paths: SVGPaths;
    size: number[];
    realWidth?: number;
    offset?: number[];
    strokeWidth?: number;
    fixed?: boolean;
    strokeColor?: string;
};
declare const pathsToActShape: (props: PathsToActShapeProps, test?: boolean) => {
    getSize: () => number[];
    shape: Group;
    setData(data: any): void;
    common: () => void;
};
declare const getTouchOffset: (ev: KonvaEventObject<any>) => {
    offsetX: number;
    offsetY: number;
};

type ContainerProps<T extends string = string, R extends Attrib = Attrib, S extends ShapeType = ShapeType, C extends EntityType<R, S> = EntityType<R, S>, TYPES extends {
    [key in T]: C;
} = {
    [key in T]: C;
}, DATA extends {
    [key in T]?: R | R[];
} = {
    [key in T]?: R | R[];
}> = {
    types: TYPES;
    data?: DATA;
    dom: HTMLDivElement;
} & Omit<EntityProps<Attrib & {
    data: DATA;
}>, "attrib">;
type ContainerEvent = EntityEvent & {
    active: {
        active: boolean;
        entity: Entity;
    };
    dataChange: void;
    dataChangeBefore: void;
    viewChange: {
        mat: Transform;
        size: number[];
    };
    dataChangeAfter: void;
};
declare class Container<T extends string = string, R extends Attrib = Attrib, S extends ShapeType = ShapeType, C extends EntityType<R, S> = EntityType<R, S>, TYPES extends {
    [key in T]: C;
} = {
    [key in T]: C;
}, DATA extends {
    [key in T]?: R | R[];
} = {
    [key in T]?: R | R[];
}, ENTRYS extends {
    [key in T]: InstanceType<TYPES[key]>[];
} = {
    [key in T]: InstanceType<TYPES[key]>[];
}> extends Entity<Attrib & {
    data: DATA;
}, Layer, ContainerEvent> {
    tempLayer: Layer;
    config: ContainerProps<T, R, S, C, TYPES, DATA>;
    entrys: ENTRYS;
    stage: Stage;
    incFactorys: { [key in T]: IncEntitysFactory<R, InstanceType<C>>; };
    constructor(config: ContainerProps<T, R, S, C, TYPES, DATA>);
    initShape(): Layer;
    init(): void;
    initIncFactory(): void;
    diffRedraw(): { [key in T]: IncEntitys<R, InstanceType<C>>; };
    initReactive(): () => void;
    tempDraw(...shapes: Entity<Attrib, Group | Shape>[]): () => void;
    getPixelFromStage(pos: number[]): number[];
    getRealFromStage(pos: number[]): number[];
    private prevCursor;
    setCursor(ico: string | null): () => void;
    getSameLevelData<T extends Entity>(entity: T): T extends {
        attrib: infer A;
    } ? A[] : never;
    constant: {
        addConstant: (key: string, value: number) => void;
        updateConstantScale: (scale: number) => void;
        use(): void;
        unuse(): void;
    };
    updateViewMat(mat: Matrix4): void;
}

type EntityBaseProps = {
    reactive?: boolean;
    readonly?: boolean;
};
type EntityProps<T extends Attrib> = EntityBaseProps & {
    name?: string;
    attrib: T;
    zIndex?: number;
    teleport?: ShapeType;
};
type ParentShapeType<T extends ShapeType> = T extends Layer ? Stage : T extends Stage ? null : Group;
type EntityTypeEvent<T extends string, R> = {
    [key in T]: R;
};
type EntityEvent = {
    created: void;
    mounted: void;
    destroyed: void;
    statusChange: Partial<ShapeStylesStatus> | null;
    updateAttrib: void;
    shapeStatusChange: {
        type?: "click" | "mouse";
        current: ShapeStylesStatusKey;
        before: ShapeStylesStatusKey;
    };
    "*": void;
};
type EntityType<T extends Attrib, S extends ShapeType, P extends EntityProps<T> = EntityProps<T>, K extends Entity<T, S> = Entity<T, S, any>, EK extends string = string, ER = any> = (new (props: P) => K) & {
    EventHandler?: {
        [key in EK]: ER;
    };
};
declare abstract class Entity<T extends Attrib = Attrib, S extends ShapeType = ShapeType, E extends EntityEvent = EntityEvent> {
    props: EntityProps<T>;
    bus: mitt.Emitter<E>;
    container: Container<string, Attrib, ShapeType, EntityType<Attrib, ShapeType>>;
    attrib: T;
    shape: S;
    name: string;
    private zIndex;
    teleport: ParentShapeType<S>;
    children: Entity<Attrib, ShapeType, any>[];
    parent: Entity<Attrib, ShapeType>;
    constructor(props: EntityProps<T>);
    abstract initShape(): S;
    getShape(): S;
    abstract diffRedraw(): void;
    redraw(): void;
    setAttrib(newAttrib: Partial<T>): void;
    private destoryReactive;
    private flush;
    protected initReactive(flush?: "pre" | "post" | "sync"): () => void;
    init(): void;
    mount(tel?: ParentShapeType<S>): void;
    isMounted: boolean;
    mounted(): void;
    setParent(parent: Entity<any, any> | null): void;
    private getLevelNdx;
    setZIndex(index: number): void;
    private dragDestory;
    enableDrag<S>(draghandler: DragHandlers<S>): void;
    disableDrag(): void;
    activeDestory: () => void;
    enableActive(activeCallback: (isActive: boolean) => void): void;
    disableActive(): void;
    private mouseActDestory;
    enableMouseAct(styles: ShapeStyles): void;
    disableMouseAct(): void;
    visible(visibled: boolean): void;
    destory(): void;
    find(name: string): Entity;
}

type WholeLinePointAttrib = Attrib & {
    x: number;
    y: number;
};
type WholeLinePointProps<T extends WholeLinePointAttrib = WholeLinePointAttrib> = EntityProps<T>;
declare class WholeLinePoint<T extends WholeLinePointAttrib = WholeLinePointAttrib, R extends ShapeType = Circle> extends Entity<T, R> {
    static namespace: string;
    actShape: CustomizeShape<number[], R>;
    actShapeFactory: CustomizeShapeFactory<T, number[], R>;
    constructor(props: WholeLinePointProps<T>);
    setActShapeFactory(actShapeFactory: CustomizeShapeFactory<T, number[], R>): void;
    initShape(): R;
    diffRedraw(): void;
    mounted(): void;
}

type WholeLineLineAttrib = Attrib & {
    pointIds: string[];
};
type WholeLineLineProps<T extends WholeLineLineAttrib = WholeLineLineAttrib> = EntityProps<T>;
declare class WholeLineLine<T extends WholeLineLineAttrib = WholeLineLineAttrib, R extends ShapeType = Line> extends Entity<T, R> {
    static namespace: string;
    private config;
    actShape: CustomizeShape<number[], R>;
    actShapeFactory: CustomizeShapeFactory<T, number[], R, any, {}>;
    constructor(props: WholeLineLineProps<T>);
    setActShapeFactory(actShapeFactory: CustomizeShapeFactory<T, number[], R>): void;
    initShape(): R;
    diffRedraw(): void;
    setConfig(config: WholeLineAttrib): void;
    getCoords(): number[];
    protected initReactive(): () => void;
    mounted(): void;
}

type WholeLinePolygonAttrib = Attrib & {
    lineIds: string[];
};
type WholeLinePolygonProps<T extends WholeLinePolygonAttrib = WholeLinePolygonAttrib> = EntityProps<T>;
declare class WholeLinePolygon<T extends WholeLinePolygonAttrib = WholeLinePolygonAttrib, R extends Shape | Group = Line> extends Entity<T, R> {
    static namespace: string;
    private config;
    actShape: CustomizeShape<number[], R>;
    actShapeFactory: CustomizeShapeFactory<T, number[], R>;
    constructor(props: WholeLinePolygonProps<T>);
    setActShapeFactory(actShapeFactory: CustomizeShapeFactory<T, number[], R>): void;
    initShape(): R;
    diffRedraw(): void;
    setConfig(config: WholeLineAttrib): void;
    getCoords(): number[];
    mounted(): void;
}

type WholeLineAttrib<P extends WholeLinePointAttrib = WholeLinePointAttrib, L extends WholeLineLineAttrib = WholeLineLineAttrib, PY extends WholeLinePolygonAttrib = WholeLinePolygonAttrib> = Attrib & {
    points: P[];
    lines: L[];
    polygons: PY[];
};
type WholeLineProps<W extends WholeLineAttrib<P, L, PY>, P extends WholeLinePointAttrib = WholeLinePointAttrib, L extends WholeLineLineAttrib = WholeLineLineAttrib, PY extends WholeLinePolygonAttrib = WholeLinePolygonAttrib> = EntityProps<W>;
type WLP<W extends WholeLineAttrib> = W extends WholeLineAttrib<infer P> ? P : never;
type WLL<W extends WholeLineAttrib> = W extends WholeLineAttrib<WholeLinePointAttrib, infer L> ? L : never;
type WLPY<W extends WholeLineAttrib> = W extends WholeLineAttrib<WholeLinePointAttrib, WholeLineLineAttrib, infer PY> ? PY : never;
type WholeLineInc<W extends WholeLineAttrib = WholeLineAttrib> = {
    pointEntityInc: IncEntitys<WLP<W>, WholeLinePoint<WLP<W>>>;
    lineEntityInc: IncEntitys<WLL<W>, WholeLineLine<WLL<W>>>;
    polygonEntityInc: IncEntitys<WLPY<W>, WholeLinePolygon<WLPY<W>>>;
};
declare class WholeLine<W extends WholeLineAttrib = WholeLineAttrib, EV extends EntityEvent = EntityEvent, PS extends ShapeType = ShapeType, LS extends ShapeType = ShapeType, PYS extends ShapeType = ShapeType> extends Entity<W, Group, EV> {
    static namespace: string;
    incLinesFactory: IncEntitysFactory<WLL<W>, WholeLineLine<WLL<W>, LS>>;
    incPointsFactory: IncEntitysFactory<WLP<W>, WholeLinePoint<WLP<W>, PS>>;
    incPolygonFactory: IncEntitysFactory<WLPY<W>, WholeLinePolygon<WLPY<W>, PYS>>;
    private incLinesHelperFactory;
    private incPointsHelperFactory?;
    constructor(props: WholeLineProps<W>);
    initIncFactory(): void;
    init(): void;
    initShape(): Group;
    getRedrawLines(): WLL<W>[];
    diffRedraw(): {
        lineEntityInc: IncEntitys<WLL<W>, WholeLineLine<WLL<W>, LS>>;
        pointEntityInc: IncEntitys<WLP<W>, WholeLinePoint<WLP<W>, PS>>;
        polygonEntityInc: IncEntitys<WLPY<W>, WholeLinePolygon<WLPY<W>, PYS>>;
    };
    initReactive(): vue.WatchStopHandle;
}

declare const setGenerateStartId: (id: number) => number;
declare const generateWholeLineLineId: (config: WholeLineAttrib) => string;
declare const generateWholeLinePointId: (config: WholeLineAttrib) => string;
declare const generateWholeLinePoygonId: (config: WholeLineAttrib, eIds?: string[]) => string;
declare const getWholeLinePoint: (config: WholeLineAttrib, id: string) => WholeLinePointAttrib;
declare const getWholeLinePoints: (config: WholeLineAttrib, ids?: string[]) => WholeLinePointAttrib[];
declare const getWholeLineLinesRawByPointId: (config: WholeLineAttrib, pointId: string) => WholeLineLineAttrib[];
declare const getWholeLineLinesRawByPointIds: (config: WholeLineAttrib, qpointIds: string[], will?: boolean) => WholeLineLineAttrib[];
declare const getWholeLineLinesRawByPoint: (config: WholeLineAttrib, point: WholeLinePointAttrib) => WholeLineLineAttrib[];
declare const getWholeLineLineRaw: (config: WholeLineAttrib, lineId: string) => WholeLineLineAttrib;
declare const getWholeLineLinesRaw: (config: WholeLineAttrib, lineIds: string[]) => WholeLineLineAttrib[];
declare const getWholeLineLine: (config: WholeLineAttrib, lineId: string) => WholeLinePointAttrib[];
declare const getWholeLineLines: (config: WholeLineAttrib) => WholeLinePointAttrib[][];
declare const getWholeLinePolygonRaw: (config: WholeLineAttrib, id: string) => WholeLinePolygonAttrib;
declare const getWholeLinePolygonLines: (config: WholeLineAttrib, polygonId: string) => WholeLinePointAttrib[][];
declare const getWholeLinePolygonLinesRaw: (config: WholeLineAttrib, polygonId: string) => WholeLineLineAttrib[];
declare const getWholeLineLinesByPointId: (config: WholeLineAttrib, pointId: string) => WholeLinePointAttrib[][];
declare const getWholeLinePolygonLinesByPoint: (config: WholeLineAttrib, pointId: string) => {
    polygonId: string;
    lines: WholeLinePointAttrib[][];
}[];
declare const getWholeLinePolygonByPoint: (config: WholeLineAttrib, pointId: string) => WholeLinePolygonAttrib[];
declare const getWholeLinePolygonPoints: (config: WholeLineAttrib, polygonId: string) => WholeLinePointAttrib[];
type WholeLineChange = {
    lineChange?: {
        del?: WholeLineLineAttrib[];
        update?: {
            before: WholeLineLineAttrib;
            after: WholeLineLineAttrib;
        }[];
        add?: WholeLineLineAttrib[];
    };
    polygonChange?: {
        add?: WholeLinePolygonAttrib[];
        update?: {
            before: WholeLinePolygonAttrib;
            after: WholeLinePolygonAttrib;
        }[];
        del?: WholeLinePolygonAttrib[];
    };
    pointChange?: {
        add?: WholeLinePointAttrib[];
        del?: WholeLinePointAttrib[];
    };
};
declare const mergeChange: (...mchanges: WholeLineChange[]) => WholeLineChange;
declare const getWholeLineLineNdxByPointIds: (config: WholeLineAttrib, qPointIds: string[]) => number;
/**
 * 添加线段，只有config.lines不存在时会添加
 * @param config WholeLine
 * @param addPointIds 线段点id[]
 * @returns 变化
 */
declare const wholeLineAddLineByPointIds: (config: WholeLineAttrib, addPointIds: string[]) => {
    line: WholeLineLineAttrib;
    change: WholeLineChange;
};
/**
 * 删除线段，只有polygon没有引用时会删除
 * @param config WholeLine
 * @param delPointIds 线段点id[]
 * @returns 变化
 */
declare const wholeLineDelLineByPointIds: (config: WholeLineAttrib, delPointIds: string[], realDelPoint?: boolean) => {
    change: WholeLineChange;
    line?: undefined;
} | {
    line: WholeLineLineAttrib;
    change: WholeLineChange;
};
/**
 * 删除多边形
 * @param config
 * @param polygonIds
 */
declare const wholeLineDelPolygon: (config: WholeLineAttrib, polygonId: string) => void;
/**
 * 删除点，会影响polygons 和lines points
 * @param config WholeLine
 * @param delPointIds 要删除的点ids
 * @returns 变化
 */
declare const wholeLineDelPointByPointIds: (config: WholeLineAttrib, delPointIds: string | string[], realDelPoint?: boolean) => WholeLineChange;
/**
 * 线段加点
 * @param config
 * @param polygonLine
 * @param addPoint
 * @param effectLines 要修改对应影响的线
 */
declare const wholeLineLineAddPoint: (config: WholeLineAttrib, line: WholeLinePointAttrib[], pointId: string) => {
    addedPoints: string[];
    change: WholeLineChange;
};
/**
 * 替换点
 * @param config WholeLine
 * @param originPointIds 原有点集合
 * @param replacePointId 最要点id
 * @returns 变化
 */
declare const wholeLineReplacePoint: (config: WholeLineAttrib, originPointIds: string[], replacePointId: string) => WholeLineChange;
/**
 * 线段点脱离
 * @param config
 * @param polygonLine
 * @param addPoint
 */
declare const wholeLineLineIsolatePoint: (config: WholeLineAttrib, line: WholeLinePointAttrib[], isolateId: string, addPointId: string) => {
    change: WholeLineChange;
};

declare const repeatablePushWholeLinePoint: (config: WholeLineAttrib) => (point: Omit<WholeLinePointAttrib, "id">) => {
    id: string;
    x: number;
    y: number;
};
/**
 * 重复获取线段与其他线段的交点，加入缓存，提速
 */
type IntersectionsResult = {
    passive: {
        polygonId: string;
        line: WholeLinePointAttrib[];
    };
    intersection: WholeLinePointAttrib;
};
declare const repeatableWholeLineLineIntersections: (config: WholeLineAttrib) => (line: WholeLinePointAttrib[]) => IntersectionsResult[];
/**
 * 通过参考线进行多边形相交线段切割
 * @param config
 * @param refLines 参考线
 */
declare const spliceWholeLineLineByLines: (config: WholeLineAttrib, splitLines: WholeLinePointAttrib[][]) => void;
/**
 * 根据点来进行多边形相交线段切割
 * @param config wholeLine
 * @param pointId 操作点id
 */
declare const spliceWholeLineLineByPoint: (config: WholeLineAttrib, pointId: string) => void;
type PointMergeResult = {
    main: WholeLinePointAttrib;
    merges: WholeLinePointAttrib[];
    mergeAfterPosition: number[];
};
/**
 * 获取需要合并的点
 * @param config WholeLine
 * @param point 操作点
 */
declare const getWholeLinePointMerge: (config: WholeLineAttrib, point: WholeLinePointAttrib) => {
    main: WholeLinePointAttrib;
    merges: WholeLinePointAttrib[];
    mergeAfterPosition: number[];
};
/**
 * 通过点id合并距离小于阈值的点
 * @param config wholeLine
 * @param pointId 操作点id
 */
declare const mergeWholeLinePointsByPoint: (config: WholeLineAttrib, pointId: string) => {
    info: {
        main: WholeLinePointAttrib;
        merges: WholeLinePointAttrib[];
        mergeAfterPosition: number[];
    };
    change: WholeLineChange;
};
/**
 * 获取挪动线段当前线段两点的位置
 * @param config
 * @param lineAttrib
 * @param initPosition 线段初始位置
 * @param move 移动向量
 */
declare const repeatMoveWholeLineLine: (config: WholeLineAttrib, lineAttrib: WholeLineLineAttrib, initPosition: number[][], angleRang?: number[]) => (move: number[]) => void;
/**
 * 修复config数据， 重合点删除，重合线删除
 * @param config
 */
declare const fixWholeLineConfig: (config: WholeLineAttrib) => void;

type MPoint = Omit<WholeLinePointAttrib, "id"> & {
    id?: string;
};
declare const wholeLineAddPoint: <T extends MPoint>(config: WholeLineAttrib, pointAttrib: T) => WholeLinePointAttrib;
/**
 * 线段加点
 */
declare const wholeLineFixLineAddPoint: <T extends MPoint>(config: WholeLineAttrib, lineId: string, position: T) => {
    change: WholeLineChange;
    addedPoints: string[];
};
/**
 * 末尾加点
 */
declare const wholeLinePolygonLastAddPoint: <T extends MPoint>(config: WholeLineAttrib, polygonId: string, pointAttribRaw: T) => {
    line: WholeLineLineAttrib;
    change: WholeLineChange;
};
/**
 * 基于某一点追加点
 */
declare const wholeLinePolygonAddPoint: <T extends MPoint>(config: WholeLineAttrib, polygonId: string, prevLineId: string | null, pointAttribRaw: T) => {
    line: WholeLineLineAttrib;
    change: WholeLineChange;
};

type PenWholeLinePoygonsEditProps<P extends Omit<WholeLinePointAttrib, "id">> = {
    tree: Container;
    onChange?: (change: WholeLineChange) => void;
    config: WholeLineAttrib<P & Attrib>;
    polygonId?: string;
    adsorbRadius?: number;
    autoAdd?: boolean;
    closeAutoQuit?: boolean;
    pointAttribFactory?: (pos: number[]) => Omit<P, "id">;
    quotePoint?: boolean | ((point: WholeLinePointAttrib) => boolean);
    canOper?: (tree: WholeLineLine | WholeLinePoint, operShape: ShapeType) => boolean;
    canDelPoint?: (point: P, evt: KonvaEventObject<any>) => boolean;
    changePolygon?: (polygonId: string) => void;
    autoClose?: boolean;
};
/**
 * 钢笔模式编辑多边形
 * @param polygonId
 */
declare const penWholeLinePoygonsEdit: <P extends Omit<WholeLinePointAttrib, "id">>({ tree, config, polygonId, pointAttribFactory, quotePoint, canOper, autoAdd, adsorbRadius, canDelPoint, closeAutoQuit, changePolygon, autoClose, }: PenWholeLinePoygonsEditProps<P>) => {
    continuous: (evt: KonvaEventObject<any>) => {
        change: WholeLineChange;
        isClose?: boolean;
    };
    end: () => void;
    getStatus: () => {
        newMode: boolean;
        polyginAttribId: string;
        prevId: string;
        config: WholeLineAttrib<P & Attrib>;
    };
    setStatus: (status: {
        newMode: boolean;
        polyginAttribId: string;
        prevId: string;
        config: WholeLineAttrib<P & Attrib>;
    }) => void;
};

type WholeLineHelperInfo = {
    change: WholeLineChange;
    config: WholeLineAttrib;
};
type WholeLineHelperInfoAL = ReturnType<typeof wholeLineAnalysisHelperInfo>;
/**
 * 鼠标绑定钢笔模式编辑多边形，并返回辅助信息
 * @param props
 * @returns
 */
declare const penWholeLinePoygonsEditWithHelperMouse: <P extends Omit<WholeLinePointAttrib, "id">>(props: PenWholeLinePoygonsEditProps<P> & {
    quitHandler?: () => void;
    closeAutoQuit?: boolean;
}) => {
    helperInfo: vue.Ref<WholeLineHelperInfo>;
    destory(): void;
};
/**
 * 判断是否需要更新多边形闭合线
 * @param change 变化内容
 * @param polygonId 判断的多边形
 * @returns false | 'after' | 'before'
 */
declare const needUpdatePolygonClose: (change: WholeLineChange, polygonId: string) => false | "after" | "before";
/**
 * 解析辅助信息
 * @param useConfig 当前正在使用的attrib
 * @param helpInfo 辅助信息
 * @param needClose 是否要解析闭合线
 */
declare const wholeLineAnalysisHelperInfo: (helpInfo: WholeLineHelperInfo, needClose?: boolean) => {
    addLines: number[][];
    delLines: string[];
    addPoints: number[][];
    delPoints: string[];
    cloneLines: {
        [x: string]: number[];
    };
};
declare const penWholeLinePoygonsEditWithHelperShapesMouse: <W extends WholeLineAttrib>(props: PenWholeLinePoygonsEditProps<WLP<W>> & {
    quitHandler?: () => void;
}, tel: Group | Layer) => () => void;

declare class WholeLineLineHelper extends Entity<WholeLineLineAttrib, Group> {
    static namespace: string;
    private config;
    constructor(props: WholeLineLineProps);
    setConfig(config: WholeLineAttrib): void;
    initShape(): Group;
    diffRedraw(): void;
}

declare class WholeLinePointHelper extends Entity<WholeLinePointAttrib, Label> {
    static namespace: string;
    constructor(props: WholeLinePointProps);
    initShape(): Label;
    diffRedraw(): void;
}

declare class EditWholeLine<W extends WholeLineAttrib = WholeLineAttrib, EV extends EntityEvent = EntityEvent, PS extends ShapeType = ShapeType, LS extends ShapeType = ShapeType, PYS extends ShapeType = ShapeType> extends WholeLine<W, EV, PS, LS, PYS> {
    points: WholeLinePoint[];
    lines: WholeLineLine[];
    lineDragHandler: Required<EntityDragHandlers<WholeLineLineAttrib, (move: number[]) => void>>;
    pointDragHandler: Required<EntityDragHandlers<WholeLinePointAttrib, number[][][]>>;
    diffRedraw(): {
        lineEntityInc: IncEntitys<WLL<W>, WholeLineLine<WLL<W>, LS>>;
        pointEntityInc: IncEntitys<WLP<W>, WholeLinePoint<WLP<W>, PS>>;
        polygonEntityInc: IncEntitys<WLPY<W>, WholeLinePolygon<WLPY<W>, PYS>>;
    };
    getChildByPointsAttrib(pointsAttrib: WholeLinePointAttrib[]): Entity<Attrib, ShapeType, any>[];
    /**
     * 开始绘制多边形
     */
    private endCreatePolygon;
    editPolygon(polygonId?: string): {
        bus: mitt.Emitter<{
            penStart: void;
        }>;
        submit: any;
        cancel: () => void;
        promise: Promise<string>;
    };
    createPolygon(): {
        bus: mitt.Emitter<{
            penStart: void;
        }>;
        submit: any;
        cancel: () => void;
        promise: Promise<string>;
    };
    pointAfterHandler(pointAttrib: WholeLinePointAttrib): void;
    lineAfterHandler(lineAttrib: WholeLineLineAttrib): void;
    polygonAfterHandler(polygonAttrib: WholeLinePolygonAttrib): void;
    init(): void;
    destory(): void;
}

declare const penLineActShapeFactory: <T extends WholeLineLineAttrib>(attrib: T, tree: any) => CustomizeShape<number[]>;
declare const closePenPolygonActShapeFactory: (attrib: WholeLinePolygonAttrib, tree: any) => {
    shape: konva_lib_Group.Group;
    setData(data: number[]): void;
    common: (ev?: KonvaEventObject<any>) => void;
};
declare const penPolygonActShapeFactory: (attrib: WholeLinePolygonAttrib, tree: any) => {
    shape: konva_lib_Group.Group;
    setData(data: number[]): void;
    common: (ev?: KonvaEventObject<any>) => void;
};
type PenEnterEditProps<P extends WholeLinePointAttrib> = {
    polygonId?: string;
    canOper?: (tree: WholeLineLine | WholeLinePoint, operShape: ShapeType) => boolean;
    pointAttribFactory?: (pos: number[]) => Omit<P, "id">;
    canDelPoint?: (p: P, evt: KonvaEventObject<any>) => boolean;
    quitHandler?: () => void;
    quotePoint?: boolean;
};
declare class PenEditWholeLine<W extends WholeLineAttrib = WholeLineAttrib, EV extends EntityEvent = EntityEvent> extends WholeLine<W, EV> {
    editPolygonId: Ref<string>;
    helperInfo?: Ref<WholeLineHelperInfoAL>;
    autoClose: boolean;
    dragAttach(inc: WholeLineInc<W>): void;
    diffRedraw(): {
        lineEntityInc: IncEntitys<WLL<W>, WholeLineLine<WLL<W>, ShapeType>>;
        pointEntityInc: IncEntitys<WLP<W>, WholeLinePoint<WLP<W>, ShapeType>>;
        polygonEntityInc: IncEntitys<WLPY<W>, WholeLinePolygon<WLPY<W>, ShapeType>>;
    };
    initIncFactory(): void;
    private _leaveEditMode;
    enterEditMode(props: PenEnterEditProps<WLP<W>>): void;
    leaveEditMode(): void;
    destory(): void;
}

type PoiData = {
    x: number;
    y: number;
    intersect?: boolean;
    rotate?: number;
    type: string;
};
type PoiAttrib = Attrib & PoiData;
declare class Poi<T extends PoiAttrib = PoiAttrib> extends Entity<T, ShapeType> {
    static namespace: string;
    showLabel: boolean;
    constructor(props: EntityProps<T>);
    setShowLabel(showLabel: any): void;
    actShape: CustomizeShape<PoiData, ShapeType, {
        getSize: () => number[];
    }>;
    initShape(): ShapeType;
    diffRedraw(): void;
    mounted(): void;
}

declare class EditPoi<T extends PoiAttrib = PoiAttrib> extends Poi<T> {
    initShape(): Group;
    isIntersecting(): any;
    diffRedraw(): void;
    mounted(): void;
    del(): void;
    copy(props?: Pick<CopyProps, "count" | "dire">): void;
}

declare const defaultPoiShapeFactory: () => {
    getSize: () => number[];
    shape: Circle;
    common(): void;
    setData(data: {
        x: number;
        y: number;
        rotate?: number;
    }): void;
};
declare const poiTypes: {
    [key in string]: CustomizeShapeFactory<PoiAttrib, {
        x: number;
        y: number;
    }, ShapeType, any, {
        getSize: () => number[];
    }>;
};
declare const injectPoiType: <T = Poi<PoiAttrib>>(type: string, factory: CustomizeShapeFactory<PoiAttrib, {
    x: number;
    y: number;
}, ShapeType, T, {
    getSize: () => number[];
}>) => void;

declare const register: <T extends string, R extends Attrib, S extends ShapeType, PT extends {
    [x: string]: Plugin;
}, TYPE extends EntityType<R, S> = EntityType<R, S>, TYPES extends { [key in T]: TYPE; } = { [key_1 in T]: TYPE; }, DATA extends { [key_2 in T]?: R | R[]; } = { [key_3 in T]?: R | R[]; }>(types: TYPES, plugins?: PT) => (dom?: HTMLDivElement, data?: DATA, readonly?: boolean) => {
    types: TYPES;
    tree: Container<string, Attrib, ShapeType, EntityType<Attrib, ShapeType>, TYPES, DATA, {
        [x: string]: InstanceType<TYPES[string]>[];
    }>;
    setData(newData: Partial<DATA>): void;
    getData(): DATA;
    destory(): void;
    mountedDom: HTMLDivElement;
    mount: (dom: HTMLDivElement) => void;
} & PT;

type BoundQueryPluginProps = {
    move?: boolean;
    wheel?: boolean;
    bound?: number[];
};
declare class BoundQueryPlugin {
    tree: Container;
    props: Omit<BoundQueryPluginProps, "bound">;
    bound?: number[];
    constructor(props?: BoundQueryPluginProps);
    private dragDestory?;
    disableMove(): void;
    enableMove(moveHandler?: (newBound: number[], move: number[]) => boolean | number[]): void;
    private wheelDestory?;
    disableWheel(): void;
    enableWheel(wheelHandler?: (newBound: number[], center: number[], scale: number) => boolean | number[]): void;
    setBound(bound: number[]): void;
    setSize(width: number, height: number): void;
    setTree(tree: Container): void;
    update(): void;
}

declare class HistoryPlugin<T = any> {
    tree: Container;
    history: History;
    state: {
        hasUndo: boolean;
        hasRedo: boolean;
    };
    disabled: boolean;
    setDisable(disabled: boolean): void;
    private syncState;
    setTree(tree: Container): void;
    undo(): void;
    redo(): void;
    push(data: T): void;
    clear(): void;
    private timelyPushDestory;
    private timelyPush;
}

type CameraQueryPluginProps = {
    move?: boolean;
    wheel?: boolean;
    bound?: number[];
    padding?: number | number[];
    size?: number[];
    retainScale?: boolean;
};
declare class CameraQueryPlugin {
    retainScale: boolean;
    bound: number[];
    padding: number[];
    tree: Container;
    props: Omit<CameraQueryPluginProps, "bound">;
    cameraMat: Matrix4;
    clipMat: Matrix4;
    bus: mitt.Emitter<{
        cameraChange: number[];
    }>;
    constructor(props?: CameraQueryPluginProps);
    private dragDestory?;
    disableMove(): void;
    enableMove(): void;
    private wheelDestory?;
    disableWheel(): void;
    enableWheel(): void;
    move(movePosition: number[], initMat?: Matrix4): void;
    scale(center: number[], scale: number, initMat?: Matrix4): void;
    rotate(center: number[], angleRad: number, initMat?: Matrix4): void;
    mutMat(mat: number[] | Matrix4, initMat?: Matrix4): void;
    setCameraMat(mat: number[] | Matrix4): void;
    autoBound(padding?: number | number[], stageNames?: string[]): void;
    realBound: number[];
    setBound(bound: number[], padding?: number | number[]): void;
    private updateSelfBound;
    setRetainScale(retainScale: boolean): void;
    setSize(width: number, height: number): void;
    setTree(tree: Container): void;
    update(): void;
}

declare let DEV: boolean;
declare const changeEnv: (dev: boolean) => boolean;
declare const isMobile: boolean;
declare const isTablet: boolean;
declare const hasTouchEvents: boolean;

declare enum PointTypeEnum {
    border = "\u8FB9\u754C\u70B9",
    center = "\u4E2D\u5FC3\u70B9",
    marker = "\u6807\u5FD7\u70B9",
    mapSelect = "\u5730\u56FE\u9009\u70B9",
    other = "\u5176\u4ED6"
}
declare const pointColorMap: {
    边界点: string;
    中心点: string;
    标志点: string;
    地图选点: string;
    其他: string;
};
type PolygonsPointAttrib = WholeLinePointAttrib & {
    type?: PointTypeEnum;
    rtk: boolean;
    title?: string;
};
type PolygonsLineAttrib = WholeLineLineAttrib;
type PolygonAttrib = WholeLinePolygonAttrib & {
    name?: string;
};
type PolygonsAttrib = {
    id: string;
    lines: PolygonsLineAttrib[];
    polygons: PolygonAttrib[];
    points: PolygonsPointAttrib[];
};

type PolygonsStatus = {
    newModel: boolean;
    lightPolygonId?: string;
    activePolygonId?: string;
    lightPointId?: string;
    editPolygonId?: string;
    selectPoiIds: string[];
};
declare class Polygons extends WholeLine<PolygonsAttrib & Attrib, EntityEvent & {
    clickPoint: PolygonsPointAttrib;
    activePolygonId: string;
    penEndHandler: void;
}> {
    status: PolygonsStatus;
    removePolygon(polygonId: string): void;
    initIncFactory(): void;
    private endEditPolygon;
    editPolygon(polygonId?: string): () => void;
    destory(): void;
}

type ScaleAttrib = {
    id: string;
    left?: number;
    top?: number;
    right?: number;
    bottom?: number;
    minWidth: number;
    maxWidth: number;
};
declare class Scale extends Entity<ScaleAttrib, Group> {
    private mat;
    pixelScale: number;
    allowable: number;
    private fontSize;
    private padding;
    get height(): number;
    constructor(props: EntityProps<ScaleAttrib>);
    getScaleUnit: (pixelScale: number[]) => number;
    getScaleText: (value: number) => string;
    initShape(): Group;
    setColor(color: string): void;
    diffRedraw(): void;
    setPixelScale(mat: Transform, size: number[]): void;
    protected initReactive(): () => void;
    mounted(): void;
}

declare class PoPath extends WholeLinePolygon<WholeLinePolygonAttrib, Group> {
    actShapeFactory: () => {
        common(): void;
        hover(): void;
        active(): void;
        closeLine: CustomizeShape<number[]> | {
            shape: Line<{
                strokeScaleEnabled: false;
                strokeWidth: number;
                hitStrokeWidth: number;
            }>;
            setData(data: number[]): void;
            common: () => void;
            hover: () => void;
            active: () => void;
            draging: () => void;
        };
        shape: Group;
        setData(data: number[]): void;
        draging: (ev: konva_lib_Node.KonvaEventObject<any>) => void;
    };
    init(): void;
    protected initReactive(): () => void;
}

declare class PoPoint extends WholeLinePoint<PolygonsPointAttrib, Group> {
    actShape: CustomizeShape<number[], Group, {
        setNdx: (ndx: number) => void;
    }>;
    get editPolygonNdx(): number;
    init(): void;
    protected initReactive(): () => void;
}

declare const createBoard: (props?: {
    dom?: HTMLDivElement;
    store?: PolygonsAttrib & {
        id: string;
    };
    map?: Map;
}) => {
    raw: {
        types: {
            polygons: typeof Polygons;
            compass: typeof Poi;
            scale: typeof Scale;
        };
        tree: Container<string, Attrib, ShapeType, EntityType<Attrib, ShapeType>, {
            polygons: typeof Polygons;
            compass: typeof Poi;
            scale: typeof Scale;
        }, {
            [x: string]: Attrib | Attrib[];
        }, {
            [x: string]: any[];
        }>;
        setData(newData: Partial<{
            [x: string]: Attrib | Attrib[];
        }>): void;
        getData(): {
            [x: string]: Attrib | Attrib[];
        };
        destory(): void;
        mountedDom: HTMLDivElement;
        mount: (dom: HTMLDivElement) => void;
    } & {
        bound: BoundQueryPlugin;
    };
    scale: Scale;
    setProps: (props?: {
        dom?: HTMLDivElement;
        map?: Map;
    }) => void;
    getData(): any;
    setData(polygon: PolygonsAttrib & {
        id: string;
    }): void;
    destory(): void;
    readonly polygon: Polygons;
    getPixelFromCoordinate(point: number[]): number[];
    toDataURL(pixelRatio?: number): Promise<string>;
};

export { type Attrib, BoundQueryPlugin, type BoundQueryPluginProps, CameraQueryPlugin, type CameraQueryPluginProps, Container, type ContainerEvent, type ContainerProps, type CopyProps, type CustomizeShape, type CustomizeShapeFactory, DEV, type DragHandlers, EditPoi, EditWholeLine, Entity, type EntityBaseProps, type EntityDragHandlers, type EntityEvent, type EntityProps, type EntityType, type EntityTypeEvent, type GetSetPick, HistoryPlugin, type IncEntitys, type IncEntitysFactory, type IntersectionsResult, type MPoint, type PathsToActShapeProps, PenEditWholeLine, type PenEnterEditProps, type PenWholeLinePoygonsEditProps, type Plugin, PoPath, PoPoint, Poi, type PoiAttrib, type PointMergeResult, PointTypeEnum, type PolygonAttrib, Polygons, type PolygonsAttrib, type PolygonsLineAttrib, type PolygonsPointAttrib, type PolygonsStatus, RelationshipEnum, type SVGPaths, type ShapeStyles, type ShapeStylesStatus, type ShapeStylesStatusKey, type ShapeType, type WLL, type WLP, type WLPY, WholeLine, type WholeLineAttrib, type WholeLineChange, type WholeLineHelperInfo, type WholeLineHelperInfoAL, type WholeLineInc, WholeLineLine, type WholeLineLineAttrib, WholeLineLineHelper, type WholeLineLineProps, WholeLinePoint, type WholeLinePointAttrib, WholeLinePointHelper, type WholeLinePointProps, WholeLinePolygon, type WholeLinePolygonAttrib, type WholeLinePolygonProps, type WholeLineProps, addEntityAttrib, analysisSvg, changeEnv, closePenPolygonActShapeFactory, copyEntityAttrib, createBoard, createLineByDire, defaultPoiShapeFactory, depPartialUpdate, deptComputed, disableMouse, enableMouse, entityActiveDualControl, entityFactory, entitysActiveDualControl, eqPoint, fixWholeLineConfig, generateId, generateWholeLineLineId, generateWholeLinePointId, generateWholeLinePoygonId, getAbsoluteTransform, getActiveKey, getChangeAllPoart, getChangePart, getDire2Angle, getDireDist, getFlatChildren, getLine2Angle, getLineCenter, getLineDire, getLineDireAngle, getLineDist, getLineInnerContinuityPoints, getLineIntersection, getLineNearPoint, getLineNearPointDist, getLineProjection, getLineRelationship, getRealAbsoluteSize, getRotateDire, getTfScaleFactors, getTouchOffset, getVerticaLineDire, getVerticalDire, getVerticalDireLine, getWholeLineLine, getWholeLineLineNdxByPointIds, getWholeLineLineRaw, getWholeLineLines, getWholeLineLinesByPointId, getWholeLineLinesRaw, getWholeLineLinesRawByPoint, getWholeLineLinesRawByPointId, getWholeLineLinesRawByPointIds, getWholeLinePoint, getWholeLinePointMerge, getWholeLinePoints, getWholeLinePolygonByPoint, getWholeLinePolygonLines, getWholeLinePolygonLinesByPoint, getWholeLinePolygonLinesRaw, getWholeLinePolygonPoints, getWholeLinePolygonRaw, hasTouchEvents, inRevise, incEntitysFactoryGenerate, injectPoiType, isLineIntersectingPolygon, isMobile, isTablet, mergeChange, mergeFuns, mergeWholeLinePointsByPoint, needUpdatePolygonClose, objectToString, openEntityDrag, openShapeDrag, openShapeMouseStyles, partialComputed, pathsToActShape, penLineActShapeFactory, penPolygonActShapeFactory, penWholeLinePoygonsEdit, penWholeLinePoygonsEditWithHelperMouse, penWholeLinePoygonsEditWithHelperShapesMouse, poiTypes, pointColorMap, polygonCounterclockwise, register, repeatMoveWholeLineLine, repeatablePushWholeLinePoint, repeatableWholeLineLineIntersections, round, setGenerateStartId, setShapeConfig, shapeParentsEq, shapeTreeContain, shapeTreeEq, spliceWholeLineLineByLines, spliceWholeLineLineByPoint, testPoint, toRawType, toTypeString, updateEntityStatus, watchAttribs, wholeLineAddLineByPointIds, wholeLineAddPoint, wholeLineAnalysisHelperInfo, wholeLineDelLineByPointIds, wholeLineDelPointByPointIds, wholeLineDelPolygon, wholeLineFixLineAddPoint, wholeLineLineAddPoint, wholeLineLineIsolatePoint, wholeLinePolygonAddPoint, wholeLinePolygonLastAddPoint, wholeLineReplacePoint, style_d as wholeLineStyle };
