@joint/core 4.0.3 → 4.1.0-beta.1

package/types/joint.d.ts

@@ -12,6 +12,16 @@ export namespace config {
 
 type NativeEvent = Event;
 
+type _DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? _DeepRequired<T[P]> : T[P];
+};
+
+type _DeepPartial<T> = {
+	[P in keyof T]?: T[P] extends object ? _DeepPartial<T[P]> : T[P];
+};
+
+type DeepPartial<T> = _DeepPartial<_DeepRequired<T>>;
+
 export namespace dia {
 
     type Event = mvc.TriggeredEvent;
@@ -55,10 +65,11 @@ export namespace dia {
     type OrthogonalDirection =
         'left' | 'top' | 'right' | 'bottom';
 
-    type Direction =
-        OrthogonalDirection |
+    type DiagonalDirection =
         'top-left' | 'top-right' | 'bottom-right' | 'bottom-left';
 
+    type Direction = OrthogonalDirection | DiagonalDirection;
+
     type LinkEnd =
         'source' | 'target';
 
@@ -152,6 +163,20 @@ export namespace dia {
             breadthFirst?: boolean;
         }
 
+        interface FindAtPointOptions extends Options {
+            strict?: boolean;
+        }
+
+        interface FindInAreaOptions extends Options {
+            strict?: boolean;
+        }
+
+        type SearchByKey = 'bbox' | PositionName;
+
+        interface FindUnderElementOptions extends FindInAreaOptions, FindAtPointOptions {
+            searchBy?: SearchByKey;
+        }
+
         class Cells extends mvc.Collection<Cell> {
             graph: Graph;
             cellNamespace: any;
@@ -228,17 +253,48 @@ export namespace dia {
 
         getCommonAncestor(...cells: Cell[]): Element | undefined;
 
-        toJSON(): any;
+        toJSON(opt?: { cellAttributes?: dia.Cell.ExportOptions }): any;
 
         fromJSON(json: any, opt?: S): this;
 
         clear(opt?: { [key: string]: any }): this;
 
+        findElementsAtPoint(p: Point, opt?: Graph.FindAtPointOptions): Element[];
+
+        findElementsInArea(rect: BBox, opt?: Graph.FindInAreaOptions): Element[];
+
+        findElementsUnderElement(element: Element, opt?: Graph.FindUnderElementOptions): Element[];
+
+        findLinksAtPoint(p: Point, opt?: Graph.FindAtPointOptions): Link[];
+
+        findLinksInArea(rect: BBox, opt?: Graph.FindInAreaOptions): Link[];
+
+        findLinksUnderElement(element: Element, opt?: Graph.FindUnderElementOptions): Link[];
+
+        findCellsAtPoint(p: Point, opt?: Graph.FindAtPointOptions): Cell[];
+
+        findCellsInArea(rect: BBox, opt?: Graph.FindInAreaOptions): Cell[];
+
+        findCellsUnderElement(element: Element, opt?: Graph.FindUnderElementOptions): Cell[];
+
+        protected _getFindUnderElementGeometry(element: Element, searchBy: Graph.SearchByKey): g.Point | g.Rect;
+
+        protected _validateCellsUnderElement<T extends Cell[]>(cells: T, element: Element): T;
+
+        protected _isValidElementUnderElement(el1: Element, el2: Element): boolean;
+
+        protected _isValidLinkUnderElement(link: Link, element: Element): boolean;
+
+        protected _filterCellsUnderElement(cells: Cell[], element: Element, opt: Graph.FindUnderElementOptions): Cell[];
+
+        /** @deprecated use `findElementsAtPoint` instead */
         findModelsFromPoint(p: Point): Element[];
 
-        findModelsInArea(rect: BBox, opt?: { strict?: boolean }): Element[];
+        /** @deprecated use `findElementsInArea` instead */
+        findModelsInArea(rect: BBox, opt?: Graph.FindInAreaOptions): Element[];
 
-        findModelsUnderElement(element: Element, opt?: { searchBy?: 'bbox' | PositionName }): Element[];
+        /** @deprecated use `findElementsUnderElement` instead */
+        findModelsUnderElement(element: Element, opt?: Graph.FindUnderElementOptions): Element[];
 
         getBBox(): g.Rect | null;
 
@@ -252,6 +308,10 @@ export namespace dia {
 
         removeCells(cells: Cell[], opt?: Cell.DisconnectableOptions): this;
 
+        transferCellEmbeds(sourceCell: Cell, targetCell: Cell, opt?: S): void;
+
+        transferCellConnectedLinks(sourceCell: Cell, targetCell: Cell, opt?: Graph.ConnectionOptions): void;
+
         resize(width: number, height: number, opt?: S): this;
 
         resizeCells(width: number, height: number, cells: Cell[], opt?: S): this;
@@ -296,6 +356,10 @@ export namespace dia {
             [key: string]: any;
         }
 
+        interface EmbedOptions extends Options {
+            reparent?: boolean;
+        }
+
         interface EmbeddableOptions<T = boolean> extends Options {
             deep?: T;
         }
@@ -323,11 +387,57 @@ export namespace dia {
         interface ConstructorOptions extends Graph.Options {
             mergeArrays?: boolean;
         }
+
+        interface ExportOptions {
+            ignoreDefault?: boolean | string[];
+            ignoreEmptyAttributes?: boolean;
+        }
+
+        type UnsetCallback<V> = (
+            this: V,
+            node: Element,
+            nodeAttributes: { [name: string]: any },
+            cellView: V
+        ) => string | Array<string> | null | void;
+
+        type SetCallback<V> = (
+            this: V,
+            attributeValue: any,
+            refBBox: g.Rect,
+            node: Element,
+            nodeAttributes: { [name: string]: any },
+            cellView: V
+        ) => { [key: string]: any } | string | number | void;
+
+        type PositionCallback<V> = (
+            this: V,
+            attributeValue: any,
+            refBBox: g.Rect,
+            node: Element,
+            nodeAttributes: { [name: string]: any },
+            cellView: V
+        ) => dia.Point | null | void;
+
+        type OffsetCallback<V> = (
+            this: V,
+            attributeValue: any,
+            nodeBBox: g.Rect,
+            node: Element,
+            nodeAttributes: { [name: string]: any },
+            cellView: V
+        ) => dia.Point | null | void;
+
+        interface PresentationAttributeDefinition<V = dia.CellView> {
+            set?: SetCallback<V> | string;
+            unset?: UnsetCallback<V> | string | Array<string>;
+            position?: PositionCallback<V>;
+            offset?: OffsetCallback<V>;
+        }
     }
 
     class Cell<A extends ObjectHash = Cell.Attributes, S extends mvc.ModelSetOptions = dia.ModelSetOptions> extends mvc.Model<A, S> {
 
-        constructor(attributes?: A, opt?: Cell.ConstructorOptions);
+        constructor(attributes?: DeepPartial<A>, opt?: Cell.ConstructorOptions);
 
         id: Cell.ID;
         graph: Graph;
@@ -340,7 +450,7 @@ export namespace dia {
 
         protected stopScheduledTransitions(path?: string, delim?: string): void;
 
-        toJSON(): Cell.JSON<any, A>;
+        toJSON(opt?: dia.Cell.ExportOptions): Cell.JSON<any, A>;
 
         remove(opt?: Cell.DisconnectableOptions): this;
 
@@ -361,7 +471,7 @@ export namespace dia {
         isEmbedded(): boolean;
 
         prop(key: Path): any;
-        prop(object: Partial<A>, opt?: Cell.Options): this;
+        prop(object: DeepPartial<A>, opt?: Cell.Options): this;
         prop(key: Path, value: any, opt?: Cell.Options): this;
 
         removeProp(path: Path, opt?: Cell.Options): this;
@@ -382,7 +492,7 @@ export namespace dia {
 
         stopTransitions(path?: string, delim?: string): this;
 
-        embed(cell: Cell | Cell[], opt?: Graph.Options): this;
+        embed(cell: Cell | Cell[], opt?: Cell.EmbedOptions): this;
 
         unembed(cell: Cell | Cell[], opt?: Graph.Options): this;
 
@@ -493,6 +603,10 @@ export namespace dia {
             deep?: boolean;
         }
 
+        interface ResizeOptions extends Cell.Options {
+            direction?: Direction;
+        }
+
         interface BBoxOptions extends Cell.EmbeddableOptions {
             rotate?: boolean;
         }
@@ -506,9 +620,10 @@ export namespace dia {
         position(x: number, y: number, opt?: Element.PositionOptions): this;
 
         size(): Size;
-        size(width: number, height?: number, opt?: { direction?: Direction, [key: string]: any }): this;
+        size(size: Partial<Size>, opt?: Element.ResizeOptions): this;
+        size(width: number, height: number, opt?: Element.ResizeOptions): this;
 
-        resize(width: number, height: number, opt?: { direction?: Direction, [key: string]: any }): this;
+        resize(width: number, height: number, opt?: Element.ResizeOptions): this;
 
         rotate(deg: number, absolute?: boolean, origin?: Point, opt?: { [key: string]: any }): this;
 
@@ -548,6 +663,8 @@ export namespace dia {
 
         getPortIndex(port: string | Element.Port): number;
 
+        getPortGroupNames(): string[];
+
         portProp(portId: string, path: dia.Path): any;
 
         portProp(portId: string, path: dia.Path, value?: any, opt?: S): Element;
@@ -555,6 +672,8 @@ export namespace dia {
         protected generatePortId(): string | number;
 
         static define(type: string, defaults?: any, protoProps?: any, staticProps?: any): Cell.Constructor<Element>;
+
+        static attributes: { [attributeName: string]: Cell.PresentationAttributeDefinition<ElementView> };
     }
 
     // dia.Link
@@ -703,6 +822,8 @@ export namespace dia {
         translate(tx: number, ty: number, opt?: S): this;
 
         static define(type: string, defaults?: any, protoProps?: any, staticProps?: any): Cell.Constructor<Link>;
+
+        static attributes: { [attributeName: string]: Cell.PresentationAttributeDefinition<LinkView> };
     }
 
     // dia.CellView
@@ -820,6 +941,14 @@ export namespace dia {
 
         isDefaultInteractionPrevented(evt: dia.Event): boolean;
 
+        isIntersecting(geometryShape: g.Shape, geometryData?: g.SegmentSubdivisionsOpt | null): boolean;
+
+        protected isEnclosedIn(area: g.Rect): boolean;
+
+        protected isInArea(area: g.Rect, options: g.StrictOpt): boolean;
+
+        protected isAtPoint(point: g.Point, options: g.StrictOpt): boolean;
+
         protected findBySelector(selector: string, root?: SVGElement): SVGElement[];
 
         protected removeHighlighters(): void;
@@ -921,6 +1050,8 @@ export namespace dia {
 
         getDelegatedView(): ElementView | null;
 
+        getTargetParentView(evt: dia.Event): CellView | null;
+
         findPortNode(portId: string | number): SVGElement | null;
         findPortNode(portId: string | number, selector: string): E | null;
 
@@ -1009,6 +1140,11 @@ export namespace dia {
         options: LinkView.Options<L>;
         sourceAnchor: g.Point;
         targetAnchor: g.Point;
+        sourcePoint: g.Point;
+        targetPoint: g.Point;
+        sourceBBox: g.Rect;
+        targetBBox: g.Rect;
+        route: g.Point[];
 
         sendToken(token: SVGElement, duration?: number, callback?: () => void): void;
         sendToken(token: SVGElement, opt?: { duration?: number, direction?: string, connection?: string }, callback?: () => void): void;
@@ -1215,6 +1351,11 @@ export namespace dia {
             afterRender?: AfterRenderCallback;
         }
 
+        interface SnapLinksOptions {
+            radius?: number;
+            findInAreaOptions?: FindInAreaOptions;
+        }
+
         type PointConstraintCallback = (x: number, y: number, opt: any) => Point;
         type RestrictTranslateCallback = (elementView: ElementView, x0: number, y0: number) => BBox | boolean | PointConstraintCallback;
         type FindParentByType = 'bbox' | 'pointer' | PositionName;
@@ -1233,7 +1374,7 @@ export namespace dia {
             highlighting?: boolean | Record<string | dia.CellView.Highlighting, highlighters.HighlighterJSON | boolean>;
             interactive?: ((cellView: CellView, event: string) => boolean | CellView.InteractivityOptions) | boolean | CellView.InteractivityOptions;
             snapLabels?: boolean;
-            snapLinks?: boolean | { radius: number };
+            snapLinks?: boolean | SnapLinksOptions;
             snapLinksSelf?: boolean | { distance: number };
             markAvailable?: boolean;
             // validations
@@ -1407,6 +1548,20 @@ export namespace dia {
             // custom
             [eventName: string]: mvc.EventHandler;
         }
+
+        interface BufferOptions {
+            /**
+             * A buffer around the area to extend the search to
+             * to mitigate the differences between the model and view geometry.
+             */
+            buffer?: number;
+        }
+
+        interface FindAtPointOptions extends Graph.FindAtPointOptions, BufferOptions {
+        }
+
+        interface FindInAreaOptions extends Graph.FindInAreaOptions, BufferOptions {
+        }
     }
 
     class Paper extends mvc.View<Graph> {
@@ -1500,19 +1655,52 @@ export namespace dia {
 
         findViewByModel<T extends ElementView | LinkView>(model: Cell | Cell.ID): T;
 
-        findViewsFromPoint(point: string | Point): ElementView[];
+        /**
+         * Finds all the element views at the specified point
+         * @param point a point in local paper coordinates
+         * @param opt options for the search
+         */
+        findElementViewsAtPoint(point: Point, opt?: Paper.FindAtPointOptions): ElementView[];
 
-        findViewsInArea(rect: BBox, opt?: { strict?: boolean }): ElementView[];
+        /**
+         * Finds all the link views at the specified point
+         * @param point a point in local paper coordinates
+         * @param opt options for the search
+         */
+        findLinkViewsAtPoint(point: Point, opt?: Paper.FindAtPointOptions): LinkView[];
 
-        fitToContent(opt?: Paper.FitToContentOptions): g.Rect;
-        fitToContent(gridWidth?: number, gridHeight?: number, padding?: number, opt?: any): g.Rect;
+        /**
+         * Finds all the cell views at the specified point
+         * @param point a point in local paper coordinates
+         * @param opt options for the search
+         */
+        findCellViewsAtPoint(point: Point, opt?: Paper.FindAtPointOptions): CellView[];
 
-        getFitToContentArea(opt?: Paper.FitToContentOptions): g.Rect;
+        /**
+         * Finds all the element views in the specified area
+         * @param area a rectangle in local paper coordinates
+         * @param opt options for the search
+         */
+        findElementViewsInArea(area: BBox, opt?: Paper.FindInAreaOptions): ElementView[];
 
         /**
-         * @deprecated use transformToFitContent
+         * Finds all the link views in the specified area
+         * @param area a rectangle in local paper coordinates
+         * @param opt options for the search
          */
-        scaleContentToFit(opt?: Paper.ScaleContentOptions): void;
+        findLinkViewsInArea(area: BBox, opt?: Paper.FindInAreaOptions): LinkView[];
+
+        /**
+         * Finds all the cell views in the specified area
+         * @param area a rectangle in local paper coordinates
+         * @param opt options for the search
+         */
+        findCellViewsInArea(area: BBox, opt?: Paper.FindInAreaOptions): CellView[];
+
+        fitToContent(opt?: Paper.FitToContentOptions): g.Rect;
+        fitToContent(gridWidth?: number, gridHeight?: number, padding?: number, opt?: any): g.Rect;
+
+        getFitToContentArea(opt?: Paper.FitToContentOptions): g.Rect;
 
         transformToFitContent(opt?: Paper.TransformToFitContentOptions): void;
 
@@ -1585,7 +1773,6 @@ export namespace dia {
             mountBatchSize?: number;
             unmountBatchSize?: number;
             viewport?: Paper.ViewportCallback;
-            progress?: Paper.ProgressCallback;
         }): void;
 
         checkViewport(opt?: {
@@ -1600,10 +1787,10 @@ export namespace dia {
         updateViews(opt?: {
             batchSize?: number;
             viewport?: Paper.ViewportCallback;
-            progress?: Paper.ProgressCallback;
         }): {
             updated: number;
             batches: number;
+            priority: number;
         };
 
         hasScheduledUpdates(): boolean;
@@ -1743,6 +1930,21 @@ export namespace dia {
         protected customEventTrigger(event: dia.Event, view: CellView, rootNode?: SVGElement): dia.Event | null;
 
         protected addStylesheet(stylesheet: string): void;
+
+        /**
+         * @deprecated use `findElementViewsAtPoint()
+         */
+        findViewsFromPoint(point: string | Point): ElementView[];
+
+        /**
+         *  @deprecated use `findElementViewsInArea()
+         */
+        findViewsInArea(rect: BBox, opt?: { strict?: boolean }): ElementView[];
+
+        /**
+         * @deprecated use transformToFitContent
+         */
+        scaleContentToFit(opt?: Paper.ScaleContentOptions): void;
     }
 
     namespace PaperLayer {
@@ -1804,21 +2006,25 @@ export namespace dia {
     }
 
     namespace ToolView {
-        interface Options extends mvc.ViewOptions<undefined, SVGElement> {
+
+        type VisibilityCallback<V = dia.CellView> = (this: ToolView, view: V, tool: ToolView) => boolean;
+
+        interface Options<V = dia.CellView> extends mvc.ViewOptions<undefined, SVGElement> {
             focusOpacity?: number;
+            visibility?: VisibilityCallback<V>;
         }
     }
 
-    class ToolView extends mvc.View<undefined, SVGElement> {
+    class ToolView<V = dia.CellView> extends mvc.View<undefined, SVGElement> {
 
         name: string | null;
         parentView: ToolsView;
         relatedView: dia.CellView;
         paper: Paper;
 
-        constructor(opt?: ToolView.Options);
+        constructor(opt?: ToolView.Options<V>);
 
-        configure(opt?: ToolView.Options): this;
+        configure(opt?: ToolView.Options<V>): this;
 
         protected simulateRelatedView(el: SVGElement): void;
 
@@ -1828,6 +2034,12 @@ export namespace dia {
 
         isVisible(): boolean;
 
+        isExplicitlyVisible(): boolean;
+
+        updateVisibility(): void;
+
+        protected computeVisibility(): boolean;
+
         focus(): void;
 
         blur(): void;
@@ -1920,6 +2132,11 @@ export namespace dia {
             cellView: dia.CellView
         ): T[];
 
+        static getAll<T extends HighlighterView = HighlighterView>(
+            paper: dia.Paper,
+            id?: string
+        ): T[];
+
         static update(cellView: dia.CellView, id?: string): void;
 
         static transform(cellView: dia.CellView, id?: string): void;
@@ -2367,6 +2584,12 @@ export namespace shapes {
 
 export namespace util {
 
+    export function isCalcExpression(value: any): boolean;
+
+    export function evalCalcFormula(formula: string, rect: g.PlainRect): number;
+
+    export function evalCalcExpression(expression: string, rect: g.PlainRect): string;
+
     export function hashCode(str: string): string;
 
     export function getByPath(object: { [key: string]: any }, path: string | string[], delim?: string): any;
@@ -2437,6 +2660,8 @@ export namespace util {
 
     export function toggleFullScreen(el?: Element): void;
 
+    export function objectDifference(object: object, base: object, opt?: { maxDepth?: number }): object;
+
     interface DOMJSONDocument {
         fragment: DocumentFragment;
         selectors: { [key: string]: Element };
@@ -4067,9 +4292,9 @@ export namespace elementTools {
 
     namespace Button {
 
-        type ActionCallback = (evt: dia.Event, view: dia.ElementView, tool: dia.ToolView) => void;
+        type ActionCallback = (evt: dia.Event, view: dia.ElementView, tool: Button) => void;
 
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.ElementView> {
             x?: number | string;
             y?: number | string;
             offset?: { x?: number, y?: number };
@@ -4081,7 +4306,7 @@ export namespace elementTools {
         }
     }
 
-    class Button extends dia.ToolView {
+    class Button extends dia.ToolView<dia.ElementView> {
 
         constructor(opt?: Button.Options);
 
@@ -4123,20 +4348,20 @@ export namespace elementTools {
     }
 
     namespace Boundary {
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.ElementView> {
             padding?: number | dia.Sides;
             useModelGeometry?: boolean;
             rotate?: boolean;
         }
     }
 
-    class Boundary extends dia.ToolView {
+    class Boundary extends dia.ToolView<dia.ElementView> {
 
         constructor(opt?: Boundary.Options);
     }
 
     namespace Control {
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.ElementView> {
             selector?: string | null;
             padding?: number;
             handleAttributes?: Partial<attributes.NativeSVGAttributes>;
@@ -4144,13 +4369,13 @@ export namespace elementTools {
         }
     }
 
-    abstract class Control<T extends mvc.ViewOptions<undefined, SVGElement> = Control.Options> extends dia.ToolView {
+    abstract class Control<T extends mvc.ViewOptions<undefined, SVGElement> = Control.Options> extends dia.ToolView<dia.ElementView> {
         options: T;
         constructor(opt?: T);
 
         protected getPosition(view: dia.ElementView): dia.Point;
-        protected setPosition(view: dia.ElementView, coordinates: g.Point): void;
-        protected resetPosition(view: dia.ElementView): void;
+        protected setPosition(view: dia.ElementView, coordinates: g.Point, evt: dia.Event): void;
+        protected resetPosition(view: dia.ElementView, evt: dia.Event): void;
 
         protected updateHandle(handleNode: SVGElement): void;
         protected updateExtras(extrasNode: SVGElement): void;
@@ -4175,7 +4400,7 @@ export namespace elementTools {
         }
     }
 
-    class HoverConnect extends linkTools.Connect {
+    class HoverConnect extends Connect {
 
         constructor(opt?: HoverConnect.Options);
     }
@@ -4202,11 +4427,15 @@ export namespace linkTools {
             protected onPointerClick(evt: dia.Event): void;
         }
 
-        interface Options extends dia.ToolView.Options {
+        interface VertexAddingOptions {
+            interactiveLineNode: string;
+        }
+
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
             handleClass?: typeof VertexHandle;
             snapRadius?: number;
             redundancyRemoval?: boolean;
-            vertexAdding?: boolean;
+            vertexAdding?: boolean | Partial<VertexAddingOptions>;
             vertexRemoving?: boolean;
             vertexMoving?: boolean;
             stopPropagation?: boolean;
@@ -4214,7 +4443,7 @@ export namespace linkTools {
         }
     }
 
-    class Vertices extends dia.ToolView {
+    class Vertices extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Vertices.Options);
     }
@@ -4230,7 +4459,7 @@ export namespace linkTools {
             protected onPointerUp(evt: dia.Event): void;
         }
 
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
             handleClass?: typeof SegmentHandle;
             snapRadius?: number;
             snapHandle?: boolean;
@@ -4242,19 +4471,19 @@ export namespace linkTools {
         }
     }
 
-    class Segments extends dia.ToolView {
+    class Segments extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Segments.Options);
     }
 
     namespace Arrowhead {
 
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
             scale?: number;
         }
     }
 
-    abstract class Arrowhead extends dia.ToolView {
+    abstract class Arrowhead extends dia.ToolView<dia.LinkView> {
 
         ratio: number;
         arrowheadType: string;
@@ -4279,7 +4508,7 @@ export namespace linkTools {
     }
 
     namespace Anchor {
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
             snap?: AnchorCallback<dia.Point>;
             anchor?: AnchorCallback<anchors.AnchorJSON>;
             resetAnchor?: boolean | anchors.AnchorJSON;
@@ -4293,7 +4522,7 @@ export namespace linkTools {
         }
     }
 
-    abstract class Anchor extends dia.ToolView {
+    abstract class Anchor extends dia.ToolView<dia.LinkView> {
 
         type: string;
 
@@ -4312,10 +4541,14 @@ export namespace linkTools {
 
     namespace Button {
 
-        type ActionCallback = (evt: dia.Event, view: dia.LinkView, tool: dia.ToolView) => void;
+        type ActionCallback = (evt: dia.Event, view: dia.LinkView, tool: Button) => void;
 
-        interface Options extends dia.ToolView.Options {
-            distance?: number | string;
+        type Distance = number | string;
+
+        type DistanceCallback = (this: Button, view: dia.LinkView, tool: Button) => Distance;
+
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
+            distance?: Distance | DistanceCallback;
             offset?: number;
             rotate?: boolean;
             action?: ActionCallback;
@@ -4324,7 +4557,7 @@ export namespace linkTools {
         }
     }
 
-    class Button extends dia.ToolView {
+    class Button extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Button.Options);
 
@@ -4358,13 +4591,13 @@ export namespace linkTools {
     }
 
     namespace Boundary {
-        interface Options extends dia.ToolView.Options {
+        interface Options extends dia.ToolView.Options<dia.LinkView> {
             padding?: number | dia.Sides;
             useModelGeometry?: boolean;
         }
     }
 
-    class Boundary extends dia.ToolView {
+    class Boundary extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Boundary.Options);
     }
@@ -4400,4 +4633,52 @@ export namespace linkTools {
 
         protected onMouseleave(evt: dia.Event): void;
     }
+
+    namespace Control {
+        interface Options extends dia.ToolView.Options {
+            selector?: string | null;
+            padding?: number;
+            handleAttributes?: Partial<attributes.NativeSVGAttributes>;
+            scale?: number;
+        }
+    }
+
+    abstract class Control<T extends mvc.ViewOptions<undefined, SVGElement> = Control.Options> extends dia.ToolView {
+        options: T;
+        constructor(opt?: T);
+
+        protected getPosition(view: dia.LinkView): dia.Point;
+        protected setPosition(view: dia.LinkView, coordinates: g.Point): void;
+        protected resetPosition(view: dia.LinkView): void;
+
+        protected updateHandle(handleNode: SVGElement): void;
+        protected updateExtras(extrasNode: SVGElement): void;
+        protected toggleExtras(visible: boolean): void;
+
+        protected onPointerDown(evt: dia.Event): void;
+        protected onPointerMove(evt: dia.Event): void;
+        protected onPointerUp(evt: dia.Event): void;
+        protected onPointerDblClick(evt: dia.Event): void;
+    }
+
+    namespace RotateLabel {
+
+        interface Options extends Control.Options {
+            offset?: number | dia.Point;
+            buttonColor?: string;
+            iconColor?: string;
+            outlineColor?: string;
+        }
+    }
+
+    class RotateLabel extends Control<RotateLabel.Options> {
+
+        constructor(opt?: RotateLabel.Options);
+
+        protected getLabelPosition(label: dia.Link.Label): dia.Link.LabelPosition;
+
+        protected getLabelIndex(): number;
+
+        protected getLabel(): dia.Link.Label | null;
+    }
 }