interface ILayerInfoInit {
    readonly id: string;
    readonly name: string;
}
interface ILayerInits {
    readonly info: ILayerInfoInit;
    readonly onscreen?: HTMLCanvasElement;
}
interface ILayerInfo {
    id: string;
    name: string;
}
interface ILayer {
    readonly name: string;
    readonly info: ILayerInfo;
    readonly onscreen: HTMLCanvasElement;
    readonly offscreen: HTMLCanvasElement;
    readonly ctx: CanvasRenderingContext2D;
    readonly octx: CanvasRenderingContext2D;
    opacity: number;
}
declare class LayerInfo implements ILayerInfo {
    id: string;
    name: string;
    constructor(inits: ILayerInfoInit);
}
declare class Layer implements ILayer {
    protected _info: ILayerInfo;
    protected _onscreen: HTMLCanvasElement;
    protected _offscreen: HTMLCanvasElement;
    protected _ctx: CanvasRenderingContext2D;
    protected _octx: CanvasRenderingContext2D;
    get name(): string;
    get info(): ILayerInfo;
    get onscreen(): HTMLCanvasElement;
    get offscreen(): HTMLCanvasElement;
    get ctx(): CanvasRenderingContext2D;
    get octx(): CanvasRenderingContext2D;
    get opacity(): number;
    set opacity(v: number);
    get id(): string;
    private _own_onscreen;
    private _own_offscreen;
    constructor(inits: ILayerInits);
    get width(): number;
    set width(v: number);
    get height(): number;
    set height(v: number);
    destory(): void;
}

declare enum ShapeEnum {
    Invalid = 0,
    Pen = 1,
    Rect = 2,
    Oval = 3,
    Text = 4,
    Polygon = 5,
    Tick = 6,
    Cross = 7,
    HalfTick = 8,
    Lines = 9,
    Img = 10
}
type ShapeType = ShapeEnum | string;
declare const getShapeName: (value: ShapeType) => string;

interface IShapeStatus {
    /**
     * visible 值为0时表示不可见
     */
    v?: 0;
    /**
     * selected 值为1时表示被选择
     */
    s?: 1;
    /**
     * editing 值为1时表示编辑中
     */
    e?: 1;
    /**
     * locked 值为1时表示被锁定
     */
    f?: 1;
    /**
     * ghost 值为1时表示不可被触摸
     */
    g?: 1;
}

interface IShapeStyle {
    /**
     * strokeStyle
     */
    a?: CanvasFillStrokeStyles['strokeStyle'];
    /**
     * fillStyle
     */
    b?: CanvasFillStrokeStyles['fillStyle'];
    /**
     * lineCap
     */
    c?: CanvasLineCap;
    /**
     * lineDash
     */
    d?: number[];
    /**
     * lineDashOffset
     */
    e?: number;
    /**
     * lineJoin
     */
    f?: CanvasLineJoin;
    /**
     * lineWidth
     */
    g?: number;
    /**
     * miterLimit
     */
    h?: number;
}
declare class ShapeStyle implements IShapeStyle {
    /**
     * strokeStyle
     */
    a?: CanvasFillStrokeStyles['strokeStyle'];
    /**
     * fillStyle
     */
    b?: CanvasFillStrokeStyles['fillStyle'];
    /**
     * lineCap
     */
    c?: CanvasLineCap;
    /**
     * lineDash
     */
    d?: number[];
    /**
     * lineDashOffset
     */
    e?: number;
    /**
     * lineJoin
     */
    f?: CanvasLineJoin;
    /**
     * lineWidth
     */
    g?: number;
    /**
     * miterLimit
     */
    h?: number;
    get fillStyle(): string | CanvasGradient | CanvasPattern;
    set fillStyle(v: string | CanvasGradient | CanvasPattern);
    get strokeStyle(): string | CanvasGradient | CanvasPattern;
    set strokeStyle(v: string | CanvasGradient | CanvasPattern);
    get lineCap(): CanvasLineCap;
    set lineCap(v: CanvasLineCap);
    get lineDash(): number[];
    set lineDash(v: number[]);
    get lineDashOffset(): number;
    set lineDashOffset(v: number);
    get lineJoin(): CanvasLineJoin;
    set lineJoin(v: CanvasLineJoin);
    get lineWidth(): number;
    set lineWidth(v: number);
    get miterLimit(): number;
    set miterLimit(v: number);
    merge(o: Partial<IShapeStyle>): this;
    read(o: Partial<IShapeStyle>): this;
    copy(): typeof this;
}

interface IShapeData {
    /** style */
    a?: IShapeStyle;
    /** status */
    b?: IShapeStatus;
    /** scale x */
    c?: number;
    /** scale y */
    d?: number;
    /** group id */
    g?: string;
    h: number;
    /** id */
    i: string;
    /** layerId */
    l?: string;
    /** rotation */
    r?: number;
    /** ShapeType */
    t: ShapeType;
    /** width */
    w: number;
    /** position x */
    x: number;
    /** position y */
    y: number;
    /** z-index */
    z: number;
}

declare enum ToolEnum {
    Invalid = "",
    Selector = "TOOL_SELECTOR",
    Pen = "TOOL_PEN",
    Rect = "TOOL_RECT",
    Oval = "TOOL_OVAL",
    Text = "TOOL_TEXT",
    Polygon = "TOOL_POLYGON",
    Tick = "TOOL_TICK",
    Cross = "TOOL_CROSS",
    HalfTick = "TOOL_HALFTICK",
    Lines = "TOOL_Lines",
    Img = "TOOL_Img",
    Eraser = "TOOL_Eraser"
}
type ToolType = ToolEnum | string;
declare const getToolName: (value: string) => string;

/**
 * 数组类型相关的工具函数
 */
declare namespace Arrays {
    type Unsafe<T> = T | null | undefined | void;
    function firstOf<T, R>(arr: T[], transform: (it: T) => Unsafe<R>): R | null;
}

interface IBinaryRange {
    from: number;
    to: number;
}
declare class BinaryRange implements IBinaryRange {
    from: number;
    to: number;
    constructor(f: number, t: number);
    set(range: IBinaryRange): void;
    get mid(): number;
    hit(other: IBinaryRange): boolean;
}

interface ITree<T = any> {
    get itemCount(): number;
    get level(): number;
    get items(): T[];
    get parent(): ITree<T> | undefined;
    split(): void;
    insert(item: T): ITree<T>;
    remove(item: T): boolean;
}

type BinaryTreeOptions<T = any> = {
    range: IBinaryRange;
    getItemRange: (item: T) => IBinaryRange;
    getTree?: (item: T) => BinaryTree<T> | undefined;
    onTreeChanged?: (item: T, from: BinaryTree<T>, to: BinaryTree<T>) => void;
    maxItems?: number;
};
declare class BinaryTree<T = any> implements ITree<T> {
    private _range;
    private _items;
    private _child0;
    private _child1;
    private _childRange0;
    private _childRange1;
    private _itemCount;
    private _level;
    private _parent;
    private _opts;
    constructor(opts: BinaryTreeOptions<T>);
    get children(): (BinaryTree<T> | undefined)[];
    get maxItems(): number;
    get parent(): BinaryTree<T> | undefined;
    get level(): number;
    get itemCount(): number;
    get range(): BinaryRange;
    get items(): T[];
    get child0(): BinaryTree<T> | undefined;
    get child1(): BinaryTree<T> | undefined;
    private get genChild0();
    private get genChild1();
    private get childRange0();
    private get childRange1();
    split(): void;
    insert(item: T): BinaryTree<T>;
    removeOnlyUnderMe(item: T): boolean;
    remove(item: T): boolean;
    merge(): void;
}

interface IVector {
    x: number;
    y: number;
}

interface IDot extends IVector {
    p: number;
}

interface IPolygon {
    dots: IVector[];
}

interface IRect {
    x: number;
    y: number;
    w: number;
    h: number;
}

interface IRotatedRect extends IRect {
    r?: number;
}

/**
 * 数字类型相关的工具函数
 */
declare namespace Numbers {
    /**
     * 判断两个数值是否相等
     *
     * 差值小于等于Number.EPSILON时，视为相等
     *
     * @export
     * @see {Number.EPSILON}
     * @param {number} a 值1
     * @param {number} b 值2
     * @return {boolean} a等于b时返回true，否则返回false
     */
    function equals(a: number, b: number): boolean;
}
/**
 * 角度弧度相关的工具函数
 */
declare namespace Degrees {
    /**
     * 弧度归一化
     *
     * 避免弧度小于0或大于等于PI*2
     *
     * @see {Math.PI}
     * @export
     * @param {number} v 弧度
     * @return {number} 归一化后的弧度值
     */
    function normalized(v: number): number;
    function normalized(v: null): null;
    function normalized(v: undefined): undefined;
    /**
     * 弧度转角度
     *
     * @export
     * @param {number} v 弧度
     * @return {number} 角度
     */
    function angle(v: number): number;
    function angle(v: null): null;
    function angle(v: undefined): undefined;
}

declare class Vector implements IVector {
    x: number;
    y: number;
    constructor(x: number, y: number);
    plus(o: IVector): this;
    set(x: number, y: number): this;
    add(x: number, y: number): this;
    read(a: IVector): this;
    toString(): string;
    rotate(radians: number, b: IVector): this;
    rotated(radians: number, b: IVector): Vector;
    static ensure(rect: IVector): Vector;
    static create(a: IVector): Vector;
    static mid(v0: IVector, v1: IVector, factor?: number): IVector;
    static pure(x: number, y: number): IVector;
    static distance(a: IVector, b: IVector): number;
    static manhattan(a: IVector, b: IVector): number;
    static dot(a: IVector, b: IVector): number;
    static multiply(a: IVector, n: number): IVector;
    static rotated(a: IVector, b: IVector, radians: number): IVector;
    static rotated2(ax: number, ay: number, bx: number, by: number, radians: number): IVector;
    static equal2(x: number, y: number, x1: number, y1: number): any;
}

declare class Polygon implements IPolygon {
    dots: Vector[];
    constructor(dots?: IVector[]);
    read(o: IPolygon): this;
    toString(): string;
    static from_rect(rect: IRotatedRect): Polygon;
    static intersect_linesegment(polygon: IVector[], ax: number, ay: number, bx: number, by: number): IVector | null;
    static contain_dot(polygon: IVector[], d: IVector): boolean;
    static contain_dot2(polygon: IVector[], x: number, y: number): boolean;
}

interface ILine {
    x0: number;
    y0: number;
    x1: number;
    y1: number;
}

declare class Rect implements IRect {
    x: number;
    y: number;
    w: number;
    h: number;
    get top(): number;
    get left(): number;
    get right(): number;
    get bottom(): number;
    set top(v: number);
    set left(v: number);
    set right(v: number);
    set bottom(v: number);
    /**
     * 获取顶点
     *
     * @readonly
     * @type {[IVector, IVector, IVector, IVector]}
     */
    get dots(): [IVector, IVector, IVector, IVector];
    constructor(x?: number, y?: number, w?: number, h?: number);
    pure(): IRect;
    set(o: IRect): void;
    hit(b: IRect | IVector): boolean;
    toString(): string;
    moveTo(x: number, y: number): this;
    mid(): IVector;
    vaild(): boolean;
    static ensure(rect: IRect): Rect;
    static create(rect: IRect): Rect;
    static pure(x: number, y: number, w: number, h: number): IRect;
    static bounds(r1: IRect, r2: IRect): IRect;
    static hit(a: IRect, b: IRect | IVector): boolean;
    static intersect(a: IRect, b: IRect): IRect;
    /**
     * 获取矩形与线段的交点
     * (与边共线视为不相交)
     *
     * @static
     * @param {IRect} rect
     * @param {ILine} line 线段
     * @return {IVector[]} 当不相交时，返回空数组，否则返回非空Vector数组
     * @memberof Rect
     */
    static line_segment_intersection(rect: IRect, line: ILine): IVector[];
}

type QuadTreeOptions<T = any> = {
    rect: IRect;
    getItemRect: (item: T) => IRect;
    maxItems?: number;
    getTree?: (item: T) => QuadTree<T> | undefined;
    onTreeChanged?: (item: T, from: QuadTree<T>, to: QuadTree<T>) => void;
};
declare class QuadTree<T = any> implements ITree<T> {
    private _items;
    private _child0;
    private _child1;
    private _child2;
    private _child3;
    private _childRect0;
    private _childRect1;
    private _childRect2;
    private _childRect3;
    private _itemCount;
    private _rect;
    private _opts;
    private _level;
    private _parent;
    constructor(opts: QuadTreeOptions<T>);
    get children(): (QuadTree<T> | undefined)[];
    get maxItems(): number;
    get parent(): QuadTree<T> | undefined;
    get level(): number;
    get itemCount(): number;
    get rect(): Rect;
    get items(): T[];
    get child0(): QuadTree<T> | undefined;
    get child1(): QuadTree<T> | undefined;
    get child2(): QuadTree<T> | undefined;
    get child3(): QuadTree<T> | undefined;
    private get genChild0();
    private get genChild1();
    private get genChild2();
    private get genChild3();
    private get childRect0();
    private get childRect1();
    private get childRect2();
    private get childRect3();
    split(): void;
    insert(item: T): QuadTree<T>;
    removeOnlyUnderMe(item: T): boolean;
    remove(item: T): boolean;
    merge(): void;
}

declare class RotatedRect implements IRotatedRect {
    x: number;
    y: number;
    w: number;
    h: number;
    private _r;
    private _cr;
    private _sr;
    private _axisX;
    private _axisY;
    get axisX(): IVector;
    get axisY(): IVector;
    set top(v: number);
    set left(v: number);
    set right(v: number);
    get right(): number;
    set bottom(v: number);
    get bottom(): number;
    get dots(): [IVector, IVector, IVector, IVector];
    get r(): number;
    set r(r: number);
    get middleX(): number;
    get middleY(): number;
    set middleX(v: number);
    set middleY(v: number);
    constructor(x?: number, y?: number, w?: number, h?: number, r?: number);
    set(o: IRotatedRect): this;
    hit(b: IRotatedRect): boolean;
    toString(): string;
    moveTo(x: number, y: number): this;
    mid(): IVector;
    static ensure(rect: IRotatedRect): RotatedRect;
    static create(rect: IRotatedRect): RotatedRect;
    static pure(x: number, y: number, w: number, h: number, r: number): IRotatedRect;
    static hit(a: IRotatedRect, b: IRotatedRect): boolean;
    projection(axis: IVector): number;
}

type Setter<T = any> = (v: T) => T;
type ValueOrSetter<T = any> = T | ((v: T) => T);
declare function getValue<T = any>(v: ValueOrSetter<T>, prev: T): T;

declare enum EventEnum {
    Invalid = "",
    ShapesAdded = "SHAPES_ADDED",
    ShapesRemoved = "SHAPES_REMOVED",
    ShapesChanging = "SHAPES_CHANGING",
    ShapesChanged = "SHAPES_CHANGED",
    ShapesDone = "SHAPES_DONE",
    ShapesGeoChanging = "SHAPES_GEO_CHANGING",
    ShapesGeoChanged = "SHAPES_GEO_CHANGED",
    ToolChanged = "TOOL_CHANGED",
    LayerAdded = "LAYER_ADDED",
    LayerRemoved = "LAYER_REMOVED",
    ShapesSelected = "SHAPES_SELECTED",
    ShapesDeselected = "SHAPES_DESELECTED",
    WorldRectChanged = "WORLD_RECT_CHANGED",
    ViewportChanged = "VIEWPORT_CHANGED"
}
type EventType = EventEnum | string;

declare namespace Events {
    interface IOperatorDetail {
        operator: string;
    }
    interface IShapesDetail extends IOperatorDetail {
        shapeDatas: IShapeData[];
    }
    interface IShagesDetail<T extends Partial<IShapeData>> extends IOperatorDetail {
        shapeType: ShapeType;
        shapeDatas: [T, T][];
    }
    interface IAnyShagesDetail extends IOperatorDetail {
        tool: ToolType;
        shapeDatas: (readonly [Partial<IShapeData>, Partial<IShapeData>])[];
    }
    interface ILayerDetail extends IOperatorDetail {
        layer: Layer;
    }
    interface IShapeGeoData {
        i: string;
        x?: number;
        y?: number;
        w?: number;
        h?: number;
        r?: number;
    }
    function pickShapePosData(data: IShapeData): IShapeGeoData;
    function pickShapeGeoData(data: IShapeData): IShapeGeoData;
    interface IToolChangedDetail {
        operator: string;
        from?: ToolType;
        to?: ToolType;
    }
    interface IRectChangeDetail {
        form: IRect;
        to: IRect;
    }
    interface EventDetailMap {
        [EventEnum.ShapesAdded]: IShapesDetail;
        [EventEnum.ShapesRemoved]: IShapesDetail;
        [EventEnum.ShapesChanging]: IShagesDetail<IShapeData>;
        [EventEnum.ShapesChanged]: IShagesDetail<IShapeData>;
        [EventEnum.ShapesDone]: IShapesDetail;
        [EventEnum.ShapesGeoChanging]: IAnyShagesDetail;
        [EventEnum.ShapesGeoChanged]: IAnyShagesDetail;
        [EventEnum.ToolChanged]: IToolChangedDetail;
        [EventEnum.LayerAdded]: ILayerDetail;
        [EventEnum.LayerRemoved]: ILayerDetail;
        [EventEnum.ShapesSelected]: IShapesDetail;
        [EventEnum.ShapesDeselected]: IShapesDetail;
        [EventEnum.WorldRectChanged]: IRectChangeDetail;
        [EventEnum.ViewportChanged]: IRectChangeDetail;
    }
    interface EventMap extends HTMLElementEventMap {
        [EventEnum.ShapesAdded]: CustomEvent<EventDetailMap[EventEnum.ShapesAdded]>;
        [EventEnum.ShapesRemoved]: CustomEvent<EventDetailMap[EventEnum.ShapesRemoved]>;
        [EventEnum.ShapesChanging]: CustomEvent<EventDetailMap[EventEnum.ShapesChanging]>;
        [EventEnum.ShapesChanged]: CustomEvent<EventDetailMap[EventEnum.ShapesChanged]>;
        [EventEnum.ShapesDone]: CustomEvent<EventDetailMap[EventEnum.ShapesDone]>;
        [EventEnum.ShapesGeoChanging]: CustomEvent<EventDetailMap[EventEnum.ShapesGeoChanging]>;
        [EventEnum.ShapesGeoChanged]: CustomEvent<EventDetailMap[EventEnum.ShapesGeoChanged]>;
        [EventEnum.ToolChanged]: CustomEvent<EventDetailMap[EventEnum.ToolChanged]>;
        [EventEnum.LayerAdded]: CustomEvent<EventDetailMap[EventEnum.LayerAdded]>;
        [EventEnum.LayerRemoved]: CustomEvent<EventDetailMap[EventEnum.LayerRemoved]>;
        [EventEnum.ShapesSelected]: CustomEvent<EventDetailMap[EventEnum.ShapesSelected]>;
        [EventEnum.ShapesDeselected]: CustomEvent<EventDetailMap[EventEnum.ShapesDeselected]>;
        [EventEnum.WorldRectChanged]: CustomEvent<EventDetailMap[EventEnum.WorldRectChanged]>;
        [EventEnum.ViewportChanged]: CustomEvent<EventDetailMap[EventEnum.ViewportChanged]>;
    }
}

/**
 * 表示图形能以何种方式被拉伸
 *
 * @export
 * @enum {number}
 */
declare enum Resizable {
    /** 禁止 */ None = 0,
    /** 水平 */ Horizontal = 1,
    /** 垂直 */ Vertical = 2,
    /** 四角 */ Corner = 4,
    /** 八向 */ All = 7
}

declare enum ResizeDirection {
    None = 0,
    Top = 1,
    TopRight = 2,
    Right = 3,
    BottomRight = 4,
    Bottom = 5,
    BottomLeft = 6,
    Left = 7,
    TopLeft = 8
}

declare class ShapeStatus implements IShapeStatus {
    /**
     * visible 值为0时表示不可见
     */
    v?: 0;
    /**
     * selected 值为1时表示被选择
     */
    s?: 1;
    /**
     * editing 值为1时表示编辑中
     */
    e?: 1;
    /**
     * locked 值为1时表示被锁定
     */
    f?: 1;
    /**
     * ghost 值为1时表示不允许selector操作
     */
    g?: 1;
    /** 是否可见 */
    get visible(): boolean;
    /** 设置是否可见 */
    set visible(v: boolean);
    /** 是否被选中 */
    get selected(): boolean;
    /** 设置是否被选中 */
    set selected(v: boolean);
    /** 设置是否被选中 */
    get editing(): boolean;
    /** 设置是否被选中 */
    set editing(v: boolean);
    /** 是否被锁定 */
    get locked(): boolean;
    /** 设置是否被锁定 */
    set locked(v: boolean);
    /** 是否不允许selector操作 */
    get ghost(): boolean;
    /** 设置是否不允许selector操作 */
    set ghost(v: boolean);
    merge(o: Partial<IShapeStatus>): this;
    read(o: Partial<IShapeStatus>): this;
    copy(): typeof this;
}

declare class ShapeData implements IShapeData {
    t: ShapeType;
    i: string;
    x: number;
    y: number;
    w: number;
    h: number;
    z: number;
    c?: number;
    d?: number;
    /** layerId */
    l?: string;
    /** rotation */
    r?: number;
    /** group id */
    g?: string;
    /** style */
    a?: IShapeStyle;
    /** status */
    b?: IShapeStatus;
    /**
     * Creates an instance of ShapeData.
     *
     * @description
     *    here, subclasses' "read" can't be called correctly because of "this" problem.
     *    subclass needs to call its own 'read' in its own 'constructor'
     *
     *    like:
     *    ``` typescript
     *    class SubData extends ShapeData {
     *      constructor(other?: Partial<SubData>) {
     *        // super(other); // don't do it
     *        super();
     *        this.read(other) // subclasses need to call its own 'read' in its own 'constructor'
     *      }
     *    }
     *    ```
     * @constructor
     * @param {?Partial<ShapeData>} [other]
     */
    constructor(other?: Partial<ShapeData>);
    get style(): ShapeStyle;
    get status(): ShapeStatus;
    /**
     * getter: type
     *
     * @type {ShapeType}
     * @memberof ShapeData
     */
    get type(): ShapeType;
    /**
     * setter: type
     *
     * @type {ShapeType}
     * @memberof ShapeData
     */
    set type(v: ShapeType);
    get id(): string;
    set id(v: string);
    get scaleX(): number;
    set scaleX(v: number);
    get scaleY(): number;
    set scaleY(v: number);
    get fillStyle(): string | CanvasGradient | CanvasPattern;
    set fillStyle(v: string | CanvasGradient | CanvasPattern);
    get strokeStyle(): string | CanvasGradient | CanvasPattern;
    set strokeStyle(v: string | CanvasGradient | CanvasPattern);
    get lineCap(): CanvasLineCap;
    set lineCap(v: CanvasLineCap);
    get lineDash(): number[];
    set lineDash(v: number[]);
    get lineDashOffset(): number;
    set lineDashOffset(v: number);
    get lineJoin(): CanvasLineJoin;
    set lineJoin(v: CanvasLineJoin);
    get lineWidth(): number;
    set lineWidth(v: number);
    get miterLimit(): number;
    set miterLimit(v: number);
    get visible(): boolean;
    set visible(v: boolean);
    get selected(): boolean;
    set selected(v: boolean);
    get editing(): boolean;
    set editing(v: boolean);
    get locked(): boolean;
    set locked(v: boolean);
    get ghost(): boolean;
    set ghost(v: boolean);
    get layer(): string | undefined;
    set layer(v: string | undefined);
    get needFill(): boolean;
    get needStroke(): boolean;
    get rotation(): number;
    set rotation(v: number);
    get halfW(): number;
    set halfW(v: number);
    get halfH(): number;
    set halfH(v: number);
    get midX(): number;
    set midX(v: number);
    get midY(): number;
    set midY(v: number);
    merge(o: Partial<IShapeData>): this;
    read(o: Partial<IShapeData>): this;
    copy(): typeof this;
    /** 清洗掉可空的字段 */
    wash(): typeof this;
}

declare enum ShapeEventEnum {
    StartDirty = "start_dirty",
    EndDirty = "end_dirty",
    BoardChanged = "board_changed"
}
interface ShapeEventMap {
    [ShapeEventEnum.StartDirty]: CustomEvent<{
        shape: Shape;
        prev?: Partial<IShapeData>;
    }>;
    [ShapeEventEnum.EndDirty]: CustomEvent<{
        shape: Shape;
        prev?: Partial<IShapeData>;
    }>;
    [ShapeEventEnum.BoardChanged]: CustomEvent<{
        shape: Shape;
        prev?: Board;
    }>;
}
type ShapeEventListener<K extends keyof ShapeEventMap> = (this: HTMLObjectElement, ev: ShapeEventMap[K]) => any;

/**
 * 一切图形的基类
 *
 * @export
 * @class Shape 图形基类
 * @template D 图形数据类
 */
declare class Shape<D extends ShapeData = ShapeData> {
    protected _d: D;
    protected _b?: Board;
    protected _r: Resizable;
    constructor(data: Partial<D>, cls: new (other?: Partial<D>) => D);
    /**
     * 图形的数据
     *
     * @readonly
     * @type {D}
     * @memberof Shape
     */
    get data(): D;
    /**
     * 图形类型
     *
     * 当图形为内置图形时，值为ShapeEnum，否则为字符串
     *
     * @readonly
     * @see {ShapeEnum}
     * @type {ShapeType}
     * @memberof Shape
     */
    get type(): ShapeType;
    /**
     * 图形属于哪个黑板
     *
     * @type {(Board | undefined)}
     * @memberof Shape
     */
    get board(): Board | undefined;
    set board(v: Board | undefined);
    /**
     * 图形是否可见，
     *
     * 当不可见时，图形将在渲染时被忽略
     *
     * @type {boolean}
     * @memberof Shape
     */
    get visible(): boolean;
    set visible(v: boolean);
    /**
     * 是否正在编辑中
     *
     * TODO
     *
     * @type {boolean}
     * @memberof Shape
     */
    get editing(): boolean;
    set editing(v: boolean);
    /**
     * 图形是否被选中
     *
     * 选中图形后，图形将呈现为被选中状态，其他一些对图形的操作均需要选中图形
     *
     * @type {boolean}
     * @memberof Shape
     */
    get selected(): boolean;
    set selected(v: boolean);
    /**
     * 图形是否可以被用户修改尺寸
     *
     * 当不为Resizable.None时，选中的图形将出现控制点，
     * 此时可以点击拖拽控制点来修改图形的尺寸
     *
     * @type {Resizable}
     * @memberof Shape
     */
    get resizable(): Resizable;
    set resizable(v: Resizable);
    /**
     * 图形是否被锁定
     *
     * 被锁定的图形将不能被编辑，选中图形时，选中图形将显示为被锁定
     *
     * @type {boolean}
     * @memberof Shape
     */
    get locked(): boolean;
    set locked(v: boolean);
    /**
     * 图形能否交互
     *
     * 当ghost为true时，只能看见这个图形，而不能选中并与其产生交互。
     * 利用这个属性，可以实现比较特殊的功能，比如：背景图
     *
     * @type {boolean}
     * @memberof Shape
     */
    get ghost(): boolean;
    set ghost(v: boolean);
    /**
     * 图形描边宽度
     * 若图形不存在描边，则为0
     *
     * @type {number}
     * @memberof Shape
     */
    get lineWidth(): number;
    set lineWidth(v: number);
    merge(data: Partial<IShapeData>): void;
    beginDirty(prev?: Partial<IShapeData>): void;
    endDirty(prev?: Partial<IShapeData>): void;
    markDirty(rect?: IRect): void;
    /**
     * 移动图形
     *
     * @param x x坐标
     * @param y y坐标
     * @returns void
     */
    move(x: number, y: number): void;
    resize(w: number, h: number): void;
    get x(): number;
    get y(): number;
    get halfW(): number;
    get halfH(): number;
    get midX(): number;
    get midY(): number;
    get w(): number;
    get h(): number;
    get left(): number;
    get top(): number;
    get right(): number;
    get bottom(): number;
    get topLeft(): IVector;
    get bottomLeft(): IVector;
    get topRight(): IVector;
    get bottomRight(): IVector;
    get leftTop(): IVector;
    get leftBottom(): IVector;
    get rightTop(): IVector;
    get rightBottom(): IVector;
    get rotatedTopLeft(): IVector;
    get rotatedBottomLeft(): IVector;
    get rotatedTopRight(): IVector;
    get rotatedBottomRight(): IVector;
    get rotatedLeftTop(): IVector;
    get rotatedLeftBottom(): IVector;
    get rotatedRightTop(): IVector;
    get rotatedRightBottom(): IVector;
    get midTop(): IVector;
    get midBottom(): IVector;
    get midLeft(): IVector;
    get midRight(): IVector;
    get rotatedMidTop(): IVector;
    get rotatedMidBottom(): IVector;
    get rotatedMidLeft(): IVector;
    get rotatedMidRight(): IVector;
    get rotatedMid(): IVector;
    get rotation(): number;
    rotateBy(d: number): void;
    rotateTo(r: number): void;
    getGeo(): Rect;
    setGeo(rect: Rect): void;
    geo(x: number, y: number, w: number, h: number): void;
    moveBy(x: number, y: number): void;
    resizeBy(w: number, h: number): void;
    geoBy(x: number, y: number, w: number, h: number): void;
    render(ctx: CanvasRenderingContext2D): void;
    /**
     * 绘制矩形
     *
     * @returns
     */
    drawingRect(): IRect;
    selectorRect(): IRect;
    /** @deprecated */ boundingRect: () => IRect;
    /**
     * 获取AABB包围盒
     *
     * 包围盒矩形的数据均为整数。
     *
     * 脏区域会根据包围盒矩形的来运算
     *
     * @return {IRect} 包围盒矩形
     * @memberof Shape
     */
    aabb(): IRect;
    obb(): IRotatedRect;
    getResizerNumbers(x: number, y: number, w: number, h: number): {
        s: number;
        lx: number;
        rx: number;
        ty: number;
        by: number;
        mx: number;
        my: number;
    };
    /**
     * 世界坐标系坐标　转换　本图坐标系坐标
     * @param x 世界坐标系X坐标
     * @param y 世界坐标系Y坐标
     * @returns 本图坐标系 坐标
     */
    map2me(x: number, y: number): Vector;
    /**
     * 世界坐标系坐标　转换　本图坐标系坐标
     * @param v 世界坐标系坐标
     * @returns 本图坐标系 坐标
     */
    map2me(v: IVector): Vector;
    /**
     * 本图坐标系坐标 转换 世界坐标系坐标
     * @param x 本图坐标系X坐标
     * @param y 本图坐标系Y坐标
     * @returns 世界坐标系坐标
     */
    map2world(x: number, y: number): Vector;
    /**
     * 本图坐标系坐标 转换 世界坐标系坐标
     * @param v 本图坐标系坐标
     * @returns 世界坐标系坐标
     */
    map2world(v: IVector): Vector;
    resizeDirection(pointerX: number, pointerY: number): [ResizeDirection, Rect | undefined];
    protected beginDraw(ctx: CanvasRenderingContext2D): void;
    protected endDraw(ctx: CanvasRenderingContext2D): void;
    private _ele;
    private _relCount;
    addEventListener<K extends keyof ShapeEventMap>(type: K, listener: ShapeEventListener<K>, options?: boolean | AddEventListenerOptions): this;
    removeEventListener<K extends keyof ShapeEventMap>(type: K, listener: ShapeEventListener<K>, options?: boolean | AddEventListenerOptions): this;
    dispatchEvent<K extends keyof ShapeEventMap>(type: K, detail: ShapeEventMap[K]['detail']): this;
}

declare class ShapeNeedPath<D extends ShapeData = ShapeData> extends Shape<D> {
    constructor(data: Partial<D>, cls: new (other?: Partial<D>) => D);
    path(ctx: CanvasRenderingContext2D): void;
    render(ctx: CanvasRenderingContext2D): void;
}

declare class CrossData extends ShapeData {
    get needFill(): boolean;
    constructor(other?: Partial<CrossData>);
}

declare class ShapeCross extends ShapeNeedPath<CrossData> {
    constructor(data: Partial<CrossData>);
    path(ctx: CanvasRenderingContext2D): void;
}

declare class RectHelper {
    private _from;
    private _to;
    get ok(): boolean;
    get from(): IVector;
    get to(): IVector;
    start(x: number, y: number): void;
    end(x: number, y: number): void;
    clear(): void;
    gen(): IRect;
}

interface ITool {
    get type(): ToolType;
    get board(): Board | undefined;
    set board(v: Board | undefined);
    /**
     * 工具切换时被调用
     *
     * 例：A切换至B时
     * 有：
     *    A.end();
     *    B.start();
     */
    start?(): void;
    /**
     * 工具被切换时被调用
     *
     * 例：A切换至B时
     * 有：
     *    A.end();
     *    B.start();
     */
    end?(): void;
    pointerMove?(dot: IDot): void;
    pointerDown?(dot: IDot): void;
    pointerDraw?(dot: IDot): void;
    pointerUp?(dot: IDot): void;
    render?(ctx: CanvasRenderingContext2D): void;
}

type FnKeys = 'Control' | 'Alt' | 'Shift';
declare class SimpleTool implements ITool {
    get type(): string;
    private _type;
    private _shapeType;
    constructor(type: ToolType, shapeType: ShapeType);
    protected _keys: Map<FnKeys, boolean>;
    protected keydown: (e: KeyboardEvent) => void;
    protected keyup: (e: KeyboardEvent) => void;
    holdingKey(...keys: FnKeys[]): boolean;
    start(): void;
    end(): void;
    render(): void;
    get board(): Board | undefined;
    set board(v: Board | undefined);
    pointerMove(dot: IDot): void;
    pointerDown(dot: IDot): void;
    pointerDraw(dot: IDot): void;
    pointerUp(dot: IDot): void;
    protected applyRect(): void;
    private updateGeo;
    protected _startData: Events.IShapeGeoData | undefined;
    protected _prevData: Events.IShapeGeoData | undefined;
    protected _curShape: Shape | undefined;
    protected _board: Board | undefined;
    protected _rect: RectHelper;
}

declare class HalfTickData extends ShapeData {
    get needFill(): boolean;
    constructor(other?: Partial<HalfTickData>);
}

declare class ShapeHalfTick extends ShapeNeedPath<HalfTickData> {
    constructor(data: Partial<HalfTickData>);
    path(ctx: CanvasRenderingContext2D): void;
}

declare enum ObjectFit {
    Fill = 0,
    Contain = 1,
    Cover = 2
}
interface IImgData extends IShapeData {
    /** src */
    s?: string;
    /** objectFit */
    f?: ObjectFit;
}
declare class ImgData extends ShapeData {
    s?: string;
    f?: ObjectFit;
    get src(): string;
    set src(v: string);
    get objectFit(): ObjectFit;
    set objectFit(v: ObjectFit);
    get needFill(): boolean;
    get needStroke(): boolean;
    constructor(other?: Partial<ImgData>);
    read(other: Partial<ImgData>): this;
}

declare class ShapeImg extends Shape<ImgData> {
    private _src?;
    private _img?;
    private _loaded;
    private _error;
    constructor(data: Partial<ImgData>);
    get img(): HTMLImageElement;
    onLoad: () => void;
    onError: (e: ErrorEvent) => void;
    render(ctx: CanvasRenderingContext2D): void;
    drawText(ctx: CanvasRenderingContext2D, text: string): void;
}

interface ILinesData extends IShapeData {
    /** coords */
    u: number[];
}
declare class LinesData extends ShapeData implements ILinesData {
    u: number[];
    get coords(): number[];
    set coords(v: number[]);
    get needFill(): boolean;
    constructor(other?: Partial<LinesData>);
    read(other: Partial<LinesData>): this;
    merge(other: Partial<LinesData>): this;
}

declare class ShapeLines extends Shape<LinesData> {
    private _srcGeo;
    private _path2D;
    constructor(data: Partial<LinesData>);
    merge(data: Partial<LinesData>): void;
    /**
     * 计算原始矩形
     * @param dot
     */
    private updateSrcGeo;
    private updatePath;
    pushDot(dot: IDot, type?: 'first'): void;
    editDot(dot: IDot): void;
    render(ctx: CanvasRenderingContext2D): void;
}

declare class LinesTool implements ITool {
    private _pressingShift;
    private _pressingControl;
    private _keydown;
    private _keyup;
    private _blur;
    start(): void;
    end(): void;
    get type(): string;
    render(): void;
    get board(): Board | undefined;
    set board(v: Board | undefined);
    addDot(dot: IDot, type?: 'first'): void;
    moveDot(dot: IDot): void;
    pointerMove(dot: IDot): void;
    pointerDown(dot: IDot): void;
    pointerDraw(dot: IDot): void;
    pointerUp(dot: IDot): void;
    private _prevData;
    private _curShape;
    private _board;
}

declare class OvalData extends ShapeData {
    constructor(other?: Partial<OvalData>);
}

declare class ShapeOval extends ShapeNeedPath<OvalData> {
    constructor(data: Partial<OvalData>);
    path(ctx: CanvasRenderingContext2D): void;
}

declare class OvalTool extends SimpleTool {
    constructor();
    protected applyRect(): void;
}

declare enum ChangeType {
    Invalid = 0,
    All = 1,
    Append = 2,
    Subtract = 3
}
interface IPenData extends IShapeData {
    /** ChangeType */
    v: ChangeType;
    /** coords */
    u: number[];
}
declare class PenData extends ShapeData implements IPenData {
    v: ChangeType;
    u: number[];
    private _src_rect;
    get src_rect(): Readonly<Rect>;
    get dotsType(): ChangeType;
    set dotsType(v: ChangeType);
    get coords(): Readonly<number[]>;
    set coords(v: number[]);
    add_coords(v: number[]): this;
    del_coords(start: number, deleteCount: number): number[];
    reset_src_rect(u?: Readonly<number[]>): Readonly<Rect>;
    expand_src_rect(u: Readonly<number[]>): Readonly<Rect>;
    get coords2world(): number[];
    get needFill(): boolean;
    constructor(other?: Partial<PenData>);
    read(other: Partial<PenData>): this;
    merge(other: Partial<PenData>): this;
}

declare class ShapePen extends Shape<PenData> {
    static is(shape: Shape<ShapeData>): shape is ShapePen;
    private _lineFactor;
    private _smoothFactor;
    private _path2D;
    private prev_t;
    private prev_dot;
    constructor(data: Partial<PenData>);
    merge(data: Partial<PenData>): void;
    private updatePath;
    appendDot(dot: IVector, type: 'first' | 'mid' | 'last'): void;
    applyCoords(coords: number[]): void;
    applyDots(dots: IVector[]): void;
    render(ctx: CanvasRenderingContext2D): void;
}

declare class PenTool implements ITool {
    readonly type: string;
    board: Board | undefined;
    end(): void;
    pointerDown(dot: IDot): void;
    pointerDraw(dot: IDot): void;
    pointerUp(dot: IDot): void;
    protected _prevData: PenData | undefined;
    protected _curShape: ShapePen | undefined;
    protected addDot(dot: IDot, type: 'first' | 'last' | 'mid'): void;
}

interface IPolygonData extends IShapeData {
    /** dots */
    u: IDot[];
}
declare class PolygonData extends ShapeData implements IPolygonData {
    constructor(other?: Partial<PolygonData>);
    u: IDot[];
    get dots(): IDot[];
    set dots(v: IDot[]);
    read(other: Partial<PolygonData>): this;
}

declare class ShapePolygon extends ShapeNeedPath<PolygonData> {
    constructor(data: Partial<PolygonData>);
    path(ctx: CanvasRenderingContext2D): void;
}

declare class RectData extends ShapeData {
    constructor(other?: Partial<RectData>);
}

declare class ShapeRect extends ShapeNeedPath<RectData> {
    constructor(data: Partial<RectData>);
    path(ctx: CanvasRenderingContext2D): void;
}

type TFontStyle = [
    'normal' | 'italic' | 'oblique',
    'normal' | 'small-caps',
    'normal' | 'bold' | 'bolder' | 'lighter' | number,
    number,
    string
];
interface ITextData extends IShapeData {
    /** text */
    s: string;
    /** TFontStyle */
    u: TFontStyle;
    /** padding left */
    m: number;
    /** padding right */
    n: number;
    /** padding top */
    p: number;
    /** padding bottom */
    q: number;
}
declare class TextData extends ShapeData implements ITextData {
    constructor(other?: Partial<TextData>);
    /** text */
    s: string;
    get text(): string;
    set text(v: string);
    /** TFontStyle */
    u: TFontStyle;
    get f_d(): TFontStyle;
    set f_d(v: TFontStyle);
    /** padding left */
    m: number;
    get t_l(): number;
    set t_l(v: number);
    /** padding right */
    n: number;
    get t_r(): number;
    set t_r(v: number);
    /** padding top */
    p: number;
    get t_t(): number;
    set t_t(v: number);
    /** padding bottom */
    q: number;
    get t_b(): number;
    set t_b(v: number);
    get font(): string;
    get font_style(): "normal" | "italic" | "oblique";
    get font_variant(): "normal" | "small-caps";
    get font_weight(): number | "normal" | "bold" | "bolder" | "lighter";
    get font_size(): number;
    get font_family(): string;
    set font_style(v: "normal" | "italic" | "oblique");
    set font_variant(v: "normal" | "small-caps");
    set font_weight(v: number | "normal" | "bold" | "bolder" | "lighter");
    set font_size(v: number);
    set font_family(v: string);
    read(o: Partial<TextData>): this;
}

interface ITextSelection {
    start: number;
    end: number;
}
declare class TextSelection implements ITextSelection {
    start: number;
    end: number;
    constructor(start?: number, end?: number);
    equal(other: ITextSelection): boolean;
}

interface ILineInfo extends TextMetrics {
    x: number;
    y: number;
    bl: number;
    str: string;
}
declare class ShapeText extends Shape<TextData> {
    private _selection;
    private _lines;
    private _selectionRects;
    private _offscreen?;
    get text(): string;
    set text(v: string);
    get selection(): TextSelection;
    set selection(v: TextSelection);
    get selectionRects(): IRect[];
    private get offscreen();
    constructor(data: Partial<TextData>);
    get fontSize(): number;
    set fontSize(v: number);
    merge(data: Partial<TextData>): void;
    private _cursorFlashingTimer;
    private _cursorVisible;
    private _setCursorVisible;
    private _setCursorFlashing;
    private _applyStyle;
    setText(v: string, dirty?: boolean): void;
    setSelection(v?: ITextSelection, dirty?: boolean): void;
    private _calculateLines;
    private _calculateSectionRects;
    render(ctx: CanvasRenderingContext2D): void;
}

declare class TextTool implements ITool {
    readonly type: string;
    readonly editor: HTMLTextAreaElement;
    private _board;
    private _curShape;
    private _prevData;
    selectorCallback?: (this: HTMLTextAreaElement, ev: FocusEvent) => void;
    private _newTxt;
    private set curShape(value);
    private _updateEditorStyle;
    private _updateShapeText;
    constructor();
    start(): void;
    end(): void;
    private _docPointerdown;
    private _keydown;
    get board(): Board | undefined;
    set board(v: Board | undefined);
    pointerDown(dot: IDot): void;
    connect(shapeText: ShapeText): void;
}

declare class TickData extends ShapeData {
    get needFill(): boolean;
    constructor(other?: Partial<TickData>);
}

declare class ShapeTick extends ShapeNeedPath<TickData> {
    constructor(data: Partial<TickData>);
    path(ctx: CanvasRenderingContext2D): void;
}

interface IShapeDecoration {
    ghost?: (shape: Shape, ctx: CanvasRenderingContext2D) => void;
    locked?: (shape: Shape, ctx: CanvasRenderingContext2D) => void;
    selected?: (shape: Shape, ctx: CanvasRenderingContext2D) => void;
    resizable?: (shape: Shape, ctx: CanvasRenderingContext2D) => void;
    debug?: (shape: Shape, ctx: CanvasRenderingContext2D) => void;
}

declare enum FactoryEnum {
    Invalid = 0,
    Default = 1
}
type FactoryType = FactoryEnum | string;
declare const getFactoryName: (value: FactoryEnum) => string;

declare class InvalidTool implements ITool {
    start(): void;
    end(): void;
    get type(): ToolType;
    get board(): Board | undefined;
    set board(_: Board | undefined);
    pointerMove(): void;
    pointerDown(): void;
    pointerDraw(): void;
    pointerUp(): void;
    render(): void;
}

interface ThrottleCallback<F extends (...args: any[]) => any> {
    (...args: Parameters<F>): ReturnType<F>;
    enforce: F;
}

declare enum SelectorStatus {
    Idle = 0,
    ReadyForDragging = 1,
    Dragging = 2,
    ReadyForSelecting = 3,
    Selecting = 4,
    ReadyForResizing = 5,
    Resizing = 6,
    ReadyForRotating = 7,
    Rotating = 8
}
declare class SelectorTool implements ITool {
    get type(): ToolType;
    private _doubleClickTimer;
    private _picking;
    private _selector;
    private _rectHelper;
    private _status;
    private _prevPos;
    private _resizer;
    private _rotator;
    private _windowPointerDown;
    private _shapes;
    get board(): Board;
    set board(v: Board);
    private onSelectChanged;
    get rect(): RectHelper;
    set cursor(v: string);
    render(ctx: CanvasRenderingContext2D): void;
    start(): void;
    end(): void;
    deselect(): void;
    connect(shapes: Shape[]): this;
    connect(shapes: Shape[], startX: number, startY: number): this;
    move(curX: number, curY: number): this;
    moveBy(diffX: number, diffY: number): this;
    pointerDown(dot: IDot): void;
    pointerMove(dot: IDot): void;
    private getReiszerCursor;
    _pen_in_click: (shape: Shape, rect: IRotatedRect) => boolean;
    _pen_in_rect: (shape: Shape, rect: IRotatedRect) => boolean;
    pointerDraw(dot: IDot): void;
    pointerUp(): void;
    doubleClick(): void;
    emitGeoEvent: ThrottleCallback<(isLast: boolean) => void>;
    private updateGeo;
}

declare class Indicator extends ShapeRect {
    constructor();
    press(): void;
    release(): void;
}

declare class EraserTool implements ITool {
    readonly type = ToolEnum.Eraser;
    readonly indicator: Indicator;
    get board(): Board;
    set board(v: Board);
    start(): void;
    end(): void;
    update_geo(dot: IDot): void;
    pointerDown(dot: IDot): void;
    pointerUp(dot: IDot): void;
    protected _breakings: [ShapePen, IVector[][]][];
    protected _predicate_and_calc: (shape: Shape) => boolean;
    pointerDraw(dot: IDot): void;
    pointerMove(dot: IDot): void;
    render(ctx: CanvasRenderingContext2D): void;
}

interface IResizerInfo {
    size: number;
}

interface IRotatorInfo {
    size: number;
    distance: number;
}

interface IHitPredicate {
    (shape: Shape, rect: IRotatedRect): any;
}
interface IShapesMgr {
    /**
     * 查找指定ID的图形
     *
     * @param {string} id 指定ID
     * @return {(Shape | null)} 存在时，返回图形，否则返回undefined
     * @memberof IShapesMgr
     */
    find(id: string): Shape | null;
    /**
     * 获取全部图形
     *
     * @return {Shape[]} 全部图形
     * @memberof IShapesMgr
     */
    shapes(): Shape[];
    add(...items: Shape[]): number;
    remove(...items: Shape[]): number;
    exists(...items: Shape[]): number;
    hit(rect: IRotatedRect, predicate?: IHitPredicate): Shape | null;
    hits(rect: IRotatedRect, predicate?: IHitPredicate): Shape[];
}

/**
 * 接口：工厂
 *
 * @export
 * @interface IFactory
 */
interface IFactory {
    get type(): FactoryType;
    get resizer(): IResizerInfo;
    get rotator(): IRotatorInfo;
    shapeTemplate(shapeType: ShapeType): ShapeData;
    setShapeTemplate(shapeType: ShapeType, template: ShapeData): void;
    newBoard(options: BoardOptions): Board;
    newShapesMgr(): IShapesMgr;
    newTool(toolType: ToolType): ITool;
    newShapeData(shapeType: ShapeType): ShapeData;
    newId(data: IShapeData): string;
    newZ(data: IShapeData): number;
    newShape(shapeType: ShapeType): Shape;
    newShape(shapeData: IShapeData): Shape;
    newLayerId(): string;
    newLayerName(): string;
    newLayer(inits?: Partial<ILayerInits>): Layer;
    shapeDecoration(shape: Shape): IShapeDecoration;
    overbound(shape: Shape): number;
    /** @deprecated */ fontFamilies(): string[];
    /** @deprecated */ fontName(fontFamily: string): string;
}

declare class DefaultFactory implements IFactory {
    private _z;
    private _time;
    private _shapeTemplates;
    get type(): FactoryType;
    resizer: IResizerInfo;
    rotator: IRotatorInfo;
    shapeTemplate(type: ShapeType): ShapeData;
    setShapeTemplate(type: ShapeType, template: ShapeData): void;
    newBoard(options: BoardOptions): Board;
    newShapesMgr(): IShapesMgr;
    newTool(toolType: ToolType): ITool;
    newShapeData(shapeType: ShapeType): ShapeData;
    newId(data: IShapeData): string;
    newZ(data: IShapeData): number;
    newShape(shapeType: ShapeType): Shape;
    newShape(shapeData: IShapeData): Shape;
    newLayerId(): string;
    newLayerName(): string;
    newLayer(inits?: Partial<ILayerInits>): Layer;
    private _shapeDecoration;
    shapeDecoration(_: Shape<ShapeData>): IShapeDecoration;
    overbound(_: Shape<ShapeData>): number;
    /** @deprecated */ fontFamilies: () => string[];
    /** @deprecated */ fontName: (f: string) => string;
}

declare namespace FontFamilysChecker {
    function check(fontFamily: string): boolean;
}

interface IFontInfo {
    family: string;
    name: string;
    desc: string;
}

declare const BUILT_IN_FONTS: IFontInfo[];

interface IFactoryInfomation {
    readonly name: string;
    readonly desc: string;
}
interface IFactoryCreater<F extends IFactory = IFactory> {
    (): F;
}
interface IToolInfomation<S extends ShapeType | undefined = ShapeType | undefined> {
    readonly name: string;
    readonly desc: string;
    readonly shape: S;
}
interface IShapeInfomation<S extends ShapeType = ShapeType> {
    readonly name: string;
    readonly desc: string;
    readonly type: S;
}
interface IToolCreater<T extends ITool = ITool> {
    (): T;
}
interface IShapeDataCreater<D extends IShapeData = IShapeData> {
    (): D;
}
interface IShapeCreater<D extends IShapeData, S extends Shape = Shape> {
    (data: D): S;
}
declare class Gaia {
    private static _fonts;
    private static _tools;
    private static _toolInfos;
    private static _shapeDatas;
    private static _shapes;
    private static _shapeInfos;
    private static _factorys;
    private static _factoryInfos;
    private static _fonts_ininted;
    static get fonts(): ReadonlyMap<string, IFontInfo>;
    static checkFont: (fontFamily: string) => boolean;
    static registerFont(infos: IFontInfo[]): void;
    /**
     * 注册工厂
     *
     * @static
     * @param {FactoryType} type 工厂类型
     * @param {IFactoryCreater} creator
     * @param {IFactoryInfomation} info
     * @memberof Gaia
     */
    static registerFactory(type: FactoryType, creator: IFactoryCreater, info: IFactoryInfomation): void;
    /**
     * 列出工厂类型
     *
     * @static
     * @return {FactoryType[]}
     * @memberof Gaia
     */
    static listFactories(): FactoryType[];
    static factory<K extends keyof FactoryEnumFactoryMap>(type: K): FactoryEnumFactoryMap[K];
    static factory(type: FactoryType): IFactoryCreater | undefined;
    static registerTool(type: ToolType, creator: IToolCreater, info?: Partial<IToolInfomation>): void;
    static listTools(): ToolType[];
    static tool<K extends keyof ToolEnumToolMap>(type: K): ToolEnumToolMap[K];
    static tool(type: ToolType): IToolCreater | undefined;
    static toolInfo<K extends keyof ToolEnumToolInfoMap>(type: K): ToolEnumToolInfoMap[K];
    static toolInfo(type: ToolType): IToolInfomation | undefined;
    static editToolInfo<K extends keyof ToolEnumToolInfoMap>(type: K, func: (i: ToolEnumToolInfoMap[K]) => ToolEnumToolInfoMap[K]): void;
    static editToolInfo(type: ToolType, func: (i: IToolInfomation) => IToolInfomation): void;
    static registerShape<D extends ShapeData>(type: ShapeType, dataCreator: IShapeDataCreater<D>, shapeCreator: IShapeCreater<D>, info?: Partial<IShapeInfomation>): void;
    static listShapes(): ShapeType[];
    static shapeInfo<K extends keyof ShapEnumShapeInfoMap>(type: K): ShapEnumShapeInfoMap[K];
    static shapeInfo(type: ShapeType): IShapeInfomation | undefined;
    static shapeData<K extends keyof ShapeEnumShapeDataMap>(type: K): ShapeEnumShapeDataMap[K];
    static shapeData(type: ShapeType): IShapeDataCreater<any> | undefined;
    static shape<K extends keyof ShapeEnumShapeDataMap>(type: K): ShapeEnumShapeMap[K];
    static shape(type: ShapeType): IShapeCreater<any> | undefined;
    static registAction<K extends keyof Events.EventMap>(eventType: K, handler: ActionHandler<Events.EventMap[K]>): void;
    static listActions(): string[];
    static action(eventType: string): ActionHandler | undefined;
    private static _actionHandler;
}
interface ActionHandler<D = any> {
    isAction(board: Board, e: D): boolean;
    undo(board: Board, e: D): void;
    redo(board: Board, e: D): void;
}
interface FactoryEnumFactoryMap {
    [FactoryEnum.Default]: IFactoryCreater;
}
interface ToolEnumToolMap {
    [ToolEnum.Selector]: IToolCreater<SelectorTool>;
    [ToolEnum.Pen]: IToolCreater<PenTool>;
    [ToolEnum.Rect]: IToolCreater<SimpleTool>;
    [ToolEnum.Oval]: IToolCreater<OvalTool>;
    [ToolEnum.Text]: IToolCreater<TextTool>;
    [ToolEnum.Polygon]: IToolCreater<SimpleTool>;
    [ToolEnum.Tick]: IToolCreater<SimpleTool>;
    [ToolEnum.Cross]: IToolCreater<SimpleTool>;
    [ToolEnum.HalfTick]: IToolCreater<SimpleTool>;
    [ToolEnum.Lines]: IToolCreater<LinesTool>;
}
interface ToolEnumToolInfoMap {
    [ToolEnum.Selector]: IToolInfomation<undefined>;
    [ToolEnum.Pen]: IToolInfomation<ShapeEnum.Pen>;
    [ToolEnum.Rect]: IToolInfomation<ShapeEnum.Rect>;
    [ToolEnum.Oval]: IToolInfomation<ShapeEnum.Oval>;
    [ToolEnum.Text]: IToolInfomation<ShapeEnum.Text>;
    [ToolEnum.Polygon]: IToolInfomation<ShapeEnum.Polygon>;
    [ToolEnum.Tick]: IToolInfomation<ShapeEnum.Tick>;
    [ToolEnum.Cross]: IToolInfomation<ShapeEnum.Cross>;
    [ToolEnum.HalfTick]: IToolInfomation<ShapeEnum.HalfTick>;
    [ToolEnum.Lines]: IToolInfomation<ShapeEnum.Lines>;
}
interface ShapEnumShapeInfoMap {
    [ShapeEnum.Pen]: IShapeInfomation<ShapeEnum.Pen>;
    [ShapeEnum.Rect]: IShapeInfomation<ShapeEnum.Rect>;
    [ShapeEnum.Oval]: IShapeInfomation<ShapeEnum.Oval>;
    [ShapeEnum.Text]: IShapeInfomation<ShapeEnum.Text>;
    [ShapeEnum.Polygon]: IShapeInfomation<ShapeEnum.Polygon>;
    [ShapeEnum.Tick]: IShapeInfomation<ShapeEnum.Tick>;
    [ShapeEnum.Cross]: IShapeInfomation<ShapeEnum.Cross>;
    [ShapeEnum.HalfTick]: IShapeInfomation<ShapeEnum.HalfTick>;
    [ShapeEnum.Lines]: IShapeInfomation<ShapeEnum.Lines>;
}
interface ShapeEnumShapeDataMap {
    [ShapeEnum.Pen]: IShapeDataCreater<PenData>;
    [ShapeEnum.Rect]: IShapeDataCreater<RectData>;
    [ShapeEnum.Oval]: IShapeDataCreater<OvalData>;
    [ShapeEnum.Text]: IShapeDataCreater<TextData>;
    [ShapeEnum.Polygon]: IShapeDataCreater<PolygonData>;
    [ShapeEnum.Tick]: IShapeDataCreater<TickData>;
    [ShapeEnum.Cross]: IShapeDataCreater<CrossData>;
    [ShapeEnum.HalfTick]: IShapeDataCreater<HalfTickData>;
    [ShapeEnum.Lines]: IShapeDataCreater<LinesData>;
}
interface ShapeEnumShapeMap {
    [ShapeEnum.Pen]: IShapeCreater<PenData, ShapePen>;
    [ShapeEnum.Rect]: IShapeCreater<RectData, ShapeRect>;
    [ShapeEnum.Oval]: IShapeCreater<OvalData, ShapeOval>;
    [ShapeEnum.Text]: IShapeCreater<TextData, ShapeText>;
    [ShapeEnum.Polygon]: IShapeCreater<PolygonData, ShapePolygon>;
    [ShapeEnum.Tick]: IShapeCreater<TickData, ShapeTick>;
    [ShapeEnum.Cross]: IShapeCreater<CrossData, ShapeCross>;
    [ShapeEnum.HalfTick]: IShapeCreater<HalfTickData, ShapeHalfTick>;
    [ShapeEnum.Lines]: IShapeCreater<LinesData, ShapeLines>;
}

interface ISnapshot {
    v: number;
    x: number;
    y: number;
    w: number;
    h: number;
    l: ILayerInfo[];
    s: IShapeData[];
}

type EmitOpts = boolean | {
    operator: string;
};
interface BoardOptions {
    element?: HTMLElement;
    layers?: ILayerInits[];
    width?: number;
    height?: number;
    scrollWidth?: number;
    scrollHeight?: number;
    toolType?: ToolType;
}
declare class Board {
    protected _factory: IFactory;
    protected _toolType: ToolType | undefined;
    protected _layers: Map<string, Layer>;
    protected _shapesMgr: IShapesMgr;
    protected _mousebuttons: {
        [x in number]?: number;
    };
    protected _tools: Map<string, ITool>;
    protected _tool: ITool | undefined;
    protected _selects: Shape[];
    protected _element: HTMLElement;
    protected _own_element: boolean;
    protected _whoami: string;
    protected _editingLayerId: string;
    protected _viewport: Rect;
    protected _world: Rect;
    protected _world_drag_start_pos: IVector;
    get lb_down(): boolean;
    get mb_down(): boolean;
    get viewport(): Readonly<Rect>;
    get world(): Readonly<Rect>;
    get whoami(): string;
    get width(): number;
    set width(v: number);
    get height(): number;
    set height(v: number);
    scroll_to(x: number, y: number): this;
    set_world_rect(to: IRect): void;
    set_viewport(to: IRect): void;
    scroll_by(x: number, y: number): this;
    addLayer(layer?: ILayerInits | Layer): boolean;
    markViewDirty(): this;
    removeLayer(layerId: string): boolean;
    editLayer(layerId: string): boolean;
    layer(): Layer;
    layer(id: string): Layer | undefined;
    addLayers(layers: ILayerInits[]): void;
    get layers(): Layer[];
    get element(): HTMLElement;
    constructor(factory: IFactory, options: BoardOptions);
    find(id: string): Shape | null;
    toSnapshot(): ISnapshot;
    fromSnapshot(snapshot: ISnapshot): void;
    toJson(replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
    fromJson(json: string): void;
    shapes(): Shape<ShapeData>[];
    exists(...items: Shape<ShapeData>[]): number;
    hit(rect: IRect, predicate?: IHitPredicate): Shape | null;
    hits(rect: IRect, predicate?: IHitPredicate): Shape[];
    addEventListener<K extends keyof Events.EventMap>(type: K, listener: (this: HTMLDivElement, ev: Events.EventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<K extends keyof Events.EventMap>(type: K, listener: (this: HTMLDivElement, ev: Events.EventMap[K]) => any, options?: boolean | EventListenerOptions): void;
    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    dispatchEvent(e: CustomEvent<any>): boolean;
    emitEvent<K extends keyof Events.EventDetailMap>(k: K, detail: Events.EventDetailMap[K]): boolean;
    get factory(): IFactory;
    set factory(v: IFactory);
    ctx(): CanvasRenderingContext2D;
    ctx(layerId: string): CanvasRenderingContext2D | null | undefined;
    octx(): CanvasRenderingContext2D;
    octx(layerId: string): CanvasRenderingContext2D | null | undefined;
    onscreen(): HTMLCanvasElement;
    onscreen(layerId: string): HTMLCanvasElement | undefined;
    offscreen(): HTMLCanvasElement;
    offscreen(layerId: string): HTMLCanvasElement | undefined;
    get toolType(): string | undefined;
    set toolType(v: string | undefined);
    setToolType(to: ToolType | undefined): void;
    get selects(): Shape<ShapeData>[];
    add(shapes: Shape[] | Shape): number;
    add(shapes: Shape[] | Shape, emit: boolean): number;
    add(shapes: Shape[] | Shape, opts: {
        operator: string;
        emit?: boolean;
    }): number;
    remove(shapes: Shape[] | Shape, opts?: EmitOpts): number;
    removeAll(emit?: EmitOpts): number;
    removeSelected(emit?: EmitOpts): void;
    /**
     * 全选图形
     *
     * @param {true} [emit] 是否发射事件
     * @return {Shape[]} 新选中的图形
     * @memberof Board
     */
    selectAll(emit?: EmitOpts): Shape[];
    /**
     * 取消选择
     *
     * @param {true} [emit] 是否发射事件
     * @return {Shape[]} ？？？
     * @memberof Board
     */
    deselect(emit?: EmitOpts): Shape[];
    /**
     * 选中指定区域内的图形，指定区域以外的会被取消选择
     *
     * @param {IRect} rect
     * @param {?EmitOpts} opts 事件发射选项
     * @param {?IHitPredicate} predicate 筛选函数
     * @return {[Shape[], Shape[]]} [新选中的图形的数组, 取消选择的图形的数组]
     * @memberof Board
     */
    selectAt(rect: IRect, opts?: EmitOpts, predicate?: IHitPredicate): [Shape[], Shape[]];
    /**
     * 设置被选中的图形，原来被选中的图形数组将被取消选中
     *
     * @param {Shape[]} shapes 被选中的图形
     * @param {(EmitOpts)} [opts]
     * @return {[Shape[], Shape[]]} [被选中的图形数组， 取消选中的图形数组]
     * @memberof Board
     */
    setSelects(shapes: Shape[], opts?: EmitOpts): [Shape[], Shape[]];
    map2world(x: number, y: number): [number, number];
    getDot(ev: MouseEvent | PointerEvent): IDot;
    get tools(): Map<string, ITool>;
    get tool(): ITool | undefined;
    /**
     * 鼠标滚动事件
     *
     * @protected
     * @param {WheelEvent} e
     * @memberof Board
     */
    protected _wheel: (e: WheelEvent) => void;
    /**
     * 执行指定函数，并检查世界矩形变化，当变化触发emitEvent
     *
     * @protected
     * @param {() => any} func 执行函数
     * @return {this}
     * @memberof Board
     */
    protected world_rect_changing(func: () => any): this;
    protected _pointerdown: (e: PointerEvent) => void;
    protected _pointermove: (e: PointerEvent) => void;
    protected _pointerup: (e: PointerEvent) => void;
    private _dirty;
    /**
     * 标记脏矩形区域，将触发重绘
     * 若在重绘前，连续调用，将会将多个矩形合并一个大的矩形，并仅会触发一次重绘。
     *
     * 脏矩形必须是整数，否则将导致画面有“脏东西”，所以传入浮点的矩形将被取整后再运算
     *
     * @param {Readonly<IRect>} rect 新的脏矩形区域
     * @memberof Board
     */
    markDirty(rect: Readonly<IRect>): void;
    /**
     * 绘制
     *
     * @memberof Board
     */
    render(): void;
    destory(): void;
}

declare class DefaultShapeDecoration implements IShapeDecoration {
    private dashSroke;
    /**
     * 检查一个图形是否是被选择的图形之一
     *
     * @note 有些工具自身需要利用图形来渲染自身，这些图形不会再board?.selects中。
     * @param {Shape} shape 图形
     * @returns {boolean} 若是返回true，否则返回false
     */
    is_mutiply_selected(shape: Shape): boolean;
    locked(shape: Shape, ctx: CanvasRenderingContext2D): void;
    selected(shape: Shape, ctx: CanvasRenderingContext2D): void;
    resizable(shape: Shape, ctx: CanvasRenderingContext2D): void;
}

declare class ActionQueue {
    setActor(actor: Board | undefined): this;
    undo(): this;
    redo(): this;
    get index(): number;
    get length(): number;
    get canRedo(): boolean;
    get canUndo(): boolean;
    private _maxLen;
    private _actionsIdx;
    private _actions;
    private _cancellers;
}

declare class FClipboard {
    private shapesMark;
    private board;
    constructor(board: Board);
    cut(): void;
    copy(): void;
    paste(): void;
    private handleClipboardItem;
    private pastePNG;
    private pasteJPG;
    private pasteTXT;
    private pasteShapes;
}

interface IPureCustomEvent<T = any> {
    readonly timestamp: number;
    readonly type: string;
    readonly detail: T;
}
interface IScreenplay {
    startTime: number;
    endTime: number;
    snapshot?: ISnapshot;
    events: IPureCustomEvent<any>[];
}

declare class Player {
    private screenplay;
    private eventIdx;
    private actor;
    private _backwarding;
    private _req_id;
    private _time;
    private _start_time;
    private _prev_time;
    play(actor: Board, screenplay: Partial<IScreenplay>): void;
    begin(actor: Board, screenplay: Partial<IScreenplay>): void;
    stop(): void;
    update_once(time: number): void;
    tick(time: number): void;
    backward(): this;
    forward(): this;
    private _applyEvent;
    private _undoEvent;
    private _addShape;
    private _removeShape;
    private _changeShapes;
}

/******************************************************************
 * Copyright @ 2023 朱剑豪. All rights reserverd.
 * @file   src\features\Recorder.ts
 * @author 朱剑豪
 * @date   2023/07/02 23:31
 * @desc   事件记录器
 ******************************************************************/

declare class Recorder {
    private _actor?;
    private _cancellers;
    private _screenplay?;
    private _running;
    get running(): boolean;
    get actor(): Board | undefined;
    constructor();
    getScreenplay(): IScreenplay | null;
    getJson(): string | null;
    getActor(): Board | undefined;
    setActor(v: Board | undefined): this;
    destory(): void;
    stop(): this;
    start(): this;
}

export { ActionQueue, Arrays, BUILT_IN_FONTS, BinaryRange, BinaryTree, Board, ChangeType, CrossData, SimpleTool as CrossTool, DefaultFactory, DefaultShapeDecoration, Degrees, EraserTool, EventEnum, Events, FClipboard, FactoryEnum, FontFamilysChecker, Gaia, HalfTickData, SimpleTool as HalfTickTool, ImgData, InvalidTool, Layer, LayerInfo, LinesData, LinesTool, Numbers, ObjectFit, OvalData, OvalTool, PenData, PenTool, Player, Polygon, PolygonData, SimpleTool as PolygonTool, QuadTree, Recorder, Rect, RectData, SimpleTool as RectTool, Resizable, ResizeDirection, RotatedRect, SelectorStatus, SelectorTool, Shape, ShapeCross, ShapeData, ShapeEnum, ShapeEventEnum, ShapeHalfTick, ShapeImg, ShapeLines, ShapeNeedPath, ShapeOval, ShapePen, ShapePolygon, ShapeRect, ShapeStatus, ShapeStyle, ShapeText, ShapeTick, SimpleTool, TextData, TextSelection, TextTool, TickData, SimpleTool as TickTool, ToolEnum, Vector, getFactoryName, getShapeName, getToolName, getValue };
export type { ActionHandler, BinaryTreeOptions, BoardOptions, EmitOpts, EventType, FactoryEnumFactoryMap, FactoryType, IBinaryRange, IDot, IFactory, IFactoryCreater, IFactoryInfomation, IFontInfo, IHitPredicate, IImgData, ILayer, ILayerInfo, ILayerInfoInit, ILayerInits, ILineInfo, ILinesData, IPenData, IPolygon, IPolygonData, IPureCustomEvent, IRect, IRotatedRect, IRotatorInfo, IScreenplay, IShapeCreater, IShapeData, IShapeDataCreater, IShapeDecoration, IShapeInfomation, IShapeStatus, IShapeStyle, IShapesMgr, ISnapshot, ITextData, ITextSelection, ITool, IToolCreater, IToolInfomation, ITree, IVector, QuadTreeOptions, Setter, ShapEnumShapeInfoMap, ShapeEnumShapeDataMap, ShapeEnumShapeMap, ShapeEventListener, ShapeEventMap, ShapeType, TFontStyle, ToolEnumToolInfoMap, ToolEnumToolMap, ToolType, ValueOrSetter };