@joint/core 4.0.4 → 4.1.0

package/dist/joint.d.ts

@@ -1,4 +1,4 @@
-/*! JointJS v4.0.4 (2024-05-31) - JavaScript diagramming library
+/*! JointJS v4.1.0 (2024-11-27) - JavaScript diagramming library
 
 
 This Source Code Form is subject to the terms of the Mozilla Public
@@ -671,10 +671,11 @@ export declare namespace dia {
     export type OrthogonalDirection =
     'left' | 'top' | 'right' | 'bottom';
 
-    export type Direction =
-    OrthogonalDirection |
+    export type DiagonalDirection =
     'top-left' | 'top-right' | 'bottom-right' | 'bottom-left';
 
+    export type Direction = OrthogonalDirection | DiagonalDirection;
+
     export type LinkEnd =
     'source' | 'target';
 
@@ -768,6 +769,20 @@ export declare namespace dia {
             breadthFirst?: boolean;
         }
 
+        export interface FindAtPointOptions extends Options {
+            strict?: boolean;
+        }
+
+        export interface FindInAreaOptions extends Options {
+            strict?: boolean;
+        }
+
+        export type SearchByKey = 'bbox' | PositionName;
+
+        export interface FindUnderElementOptions extends FindInAreaOptions, FindAtPointOptions {
+            searchBy?: SearchByKey;
+        }
+
         export class Cells extends mvc.Collection<Cell> {
             graph: Graph;
             cellNamespace: any;
@@ -844,17 +859,48 @@ export declare 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;
 
@@ -868,6 +914,10 @@ export declare 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;
@@ -912,6 +962,10 @@ export declare namespace dia {
             [key: string]: any;
         }
 
+        export interface EmbedOptions extends Options {
+            reparent?: boolean;
+        }
+
         export interface EmbeddableOptions<T = boolean> extends Options {
             deep?: T;
         }
@@ -939,6 +993,52 @@ export declare namespace dia {
         export interface ConstructorOptions extends Graph.Options {
             mergeArrays?: boolean;
         }
+
+        export interface ExportOptions {
+            ignoreDefault?: boolean | string[];
+            ignoreEmptyAttributes?: boolean;
+        }
+
+        export type UnsetCallback<V> = (
+        this: V,
+        node: Element,
+        nodeAttributes: { [name: string]: any },
+        cellView: V
+        ) => string | Array<string> | null | void;
+
+        export type SetCallback<V> = (
+        this: V,
+        attributeValue: any,
+        refBBox: g.Rect,
+        node: Element,
+        nodeAttributes: { [name: string]: any },
+        cellView: V
+        ) => { [key: string]: any } | string | number | void;
+
+        export type PositionCallback<V> = (
+        this: V,
+        attributeValue: any,
+        refBBox: g.Rect,
+        node: Element,
+        nodeAttributes: { [name: string]: any },
+        cellView: V
+        ) => dia.Point | null | void;
+
+        export type OffsetCallback<V> = (
+        this: V,
+        attributeValue: any,
+        nodeBBox: g.Rect,
+        node: Element,
+        nodeAttributes: { [name: string]: any },
+        cellView: V
+        ) => dia.Point | null | void;
+
+        export interface PresentationAttributeDefinition<V = dia.CellView> {
+            set?: SetCallback<V> | string;
+            unset?: UnsetCallback<V> | string | Array<string>;
+            position?: PositionCallback<V>;
+            offset?: OffsetCallback<V>;
+        }
     }
 
     export class Cell<A extends ObjectHash = Cell.Attributes, S extends mvc.ModelSetOptions = dia.ModelSetOptions> extends mvc.Model<A, S> {
@@ -956,7 +1056,7 @@ export declare 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;
 
@@ -998,7 +1098,7 @@ export declare 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;
 
@@ -1109,6 +1209,10 @@ export declare namespace dia {
             deep?: boolean;
         }
 
+        export interface ResizeOptions extends Cell.Options {
+            direction?: Direction;
+        }
+
         export interface BBoxOptions extends Cell.EmbeddableOptions {
             rotate?: boolean;
         }
@@ -1122,9 +1226,10 @@ export declare 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;
 
@@ -1164,6 +1269,8 @@ export declare 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;
@@ -1171,6 +1278,8 @@ export declare 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
@@ -1319,6 +1428,8 @@ export declare 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
@@ -1436,6 +1547,14 @@ export declare 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;
@@ -1537,6 +1656,8 @@ export declare 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;
 
@@ -1625,6 +1746,11 @@ export declare 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;
@@ -1831,6 +1957,11 @@ export declare namespace dia {
             afterRender?: AfterRenderCallback;
         }
 
+        export interface SnapLinksOptions {
+            radius?: number;
+            findInAreaOptions?: FindInAreaOptions;
+        }
+
         export type PointConstraintCallback = (x: number, y: number, opt: any) => Point;
         export type RestrictTranslateCallback = (elementView: ElementView, x0: number, y0: number) => BBox | boolean | PointConstraintCallback;
         export type FindParentByType = 'bbox' | 'pointer' | PositionName;
@@ -1849,7 +1980,7 @@ export declare 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
@@ -2023,6 +2154,20 @@ export declare namespace dia {
             // custom
             [eventName: string]: mvc.EventHandler;
         }
+
+        export interface BufferOptions {
+            /**
+             * A buffer around the area to extend the search to
+             * to mitigate the differences between the model and view geometry.
+             */
+            buffer?: number;
+        }
+
+        export interface FindAtPointOptions extends Graph.FindAtPointOptions, BufferOptions {
+        }
+
+        export interface FindInAreaOptions extends Graph.FindInAreaOptions, BufferOptions {
+        }
     }
 
     export class Paper extends mvc.View<Graph> {
@@ -2116,19 +2261,52 @@ export declare 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;
 
@@ -2201,7 +2379,6 @@ export declare namespace dia {
             mountBatchSize?: number;
             unmountBatchSize?: number;
             viewport?: Paper.ViewportCallback;
-            progress?: Paper.ProgressCallback;
         }): void;
 
         checkViewport(opt?: {
@@ -2216,10 +2393,10 @@ export declare namespace dia {
         updateViews(opt?: {
             batchSize?: number;
             viewport?: Paper.ViewportCallback;
-            progress?: Paper.ProgressCallback;
         }): {
             updated: number;
             batches: number;
+            priority: number;
         };
 
         hasScheduledUpdates(): boolean;
@@ -2359,6 +2536,21 @@ export declare 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;
     }
 
     export namespace PaperLayer {
@@ -2420,21 +2612,25 @@ export declare namespace dia {
     }
 
     export namespace ToolView {
-        export interface Options extends mvc.ViewOptions<undefined, SVGElement> {
+
+        export type VisibilityCallback<V = dia.CellView> = (this: ToolView, view: V, tool: ToolView) => boolean;
+
+        export interface Options<V = dia.CellView> extends mvc.ViewOptions<undefined, SVGElement> {
             focusOpacity?: number;
+            visibility?: VisibilityCallback<V>;
         }
     }
 
-    export class ToolView extends mvc.View<undefined, SVGElement> {
+    export 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;
 
@@ -2444,6 +2640,12 @@ export declare namespace dia {
 
         isVisible(): boolean;
 
+        isExplicitlyVisible(): boolean;
+
+        updateVisibility(): void;
+
+        protected computeVisibility(): boolean;
+
         focus(): void;
 
         blur(): void;
@@ -2536,6 +2738,11 @@ export declare 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;
@@ -2554,9 +2761,9 @@ export declare namespace elementTools {
 
     export namespace Button {
 
-        export type ActionCallback = (evt: dia.Event, view: dia.ElementView, tool: dia.ToolView) => void;
+        export type ActionCallback = (evt: dia.Event, view: dia.ElementView, tool: Button) => void;
 
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.ElementView> {
             x?: number | string;
             y?: number | string;
             offset?: { x?: number, y?: number };
@@ -2568,7 +2775,7 @@ export declare namespace elementTools {
         }
     }
 
-    export class Button extends dia.ToolView {
+    export class Button extends dia.ToolView<dia.ElementView> {
 
         constructor(opt?: Button.Options);
 
@@ -2610,20 +2817,20 @@ export declare namespace elementTools {
     }
 
     export namespace Boundary {
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.ElementView> {
             padding?: number | dia.Sides;
             useModelGeometry?: boolean;
             rotate?: boolean;
         }
     }
 
-    export class Boundary extends dia.ToolView {
+    export class Boundary extends dia.ToolView<dia.ElementView> {
 
         constructor(opt?: Boundary.Options);
     }
 
     export namespace Control {
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.ElementView> {
             selector?: string | null;
             padding?: number;
             handleAttributes?: Partial<attributes.NativeSVGAttributes>;
@@ -2631,13 +2838,13 @@ export declare namespace elementTools {
         }
     }
 
-    export abstract class Control<T extends mvc.ViewOptions<undefined, SVGElement> = Control.Options> extends dia.ToolView {
+    export 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;
@@ -2662,7 +2869,7 @@ export declare namespace elementTools {
         }
     }
 
-    export class HoverConnect extends linkTools.Connect {
+    export class HoverConnect extends Connect {
 
         constructor(opt?: HoverConnect.Options);
     }
@@ -2714,6 +2921,11 @@ export declare namespace g {
         precision?: number;
     }
 
+    export interface StrictOpt {
+
+        strict?: boolean;
+    }
+
     export interface SubdivisionsOpt extends PrecisionOpt {
 
         subdivisions?: Curve[];
@@ -3321,7 +3533,7 @@ export declare namespace g {
 
         clone(): Rect;
 
-        containsPoint(p: PlainPoint | string): boolean;
+        containsPoint(p: PlainPoint | string, opt?: StrictOpt): boolean;
 
         containsRect(r: PlainRect): boolean;
 
@@ -3761,11 +3973,15 @@ export declare namespace linkTools {
             protected onPointerClick(evt: dia.Event): void;
         }
 
-        export interface Options extends dia.ToolView.Options {
+        export interface VertexAddingOptions {
+            interactiveLineNode: string;
+        }
+
+        export 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;
@@ -3773,7 +3989,7 @@ export declare namespace linkTools {
         }
     }
 
-    export class Vertices extends dia.ToolView {
+    export class Vertices extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Vertices.Options);
     }
@@ -3789,7 +4005,7 @@ export declare namespace linkTools {
             protected onPointerUp(evt: dia.Event): void;
         }
 
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.LinkView> {
             handleClass?: typeof SegmentHandle;
             snapRadius?: number;
             snapHandle?: boolean;
@@ -3801,19 +4017,19 @@ export declare namespace linkTools {
         }
     }
 
-    export class Segments extends dia.ToolView {
+    export class Segments extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Segments.Options);
     }
 
     export namespace Arrowhead {
 
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.LinkView> {
             scale?: number;
         }
     }
 
-    export abstract class Arrowhead extends dia.ToolView {
+    export abstract class Arrowhead extends dia.ToolView<dia.LinkView> {
 
         ratio: number;
         arrowheadType: string;
@@ -3838,7 +4054,7 @@ export declare namespace linkTools {
     }
 
     export namespace Anchor {
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.LinkView> {
             snap?: AnchorCallback<dia.Point>;
             anchor?: AnchorCallback<anchors.AnchorJSON>;
             resetAnchor?: boolean | anchors.AnchorJSON;
@@ -3852,7 +4068,7 @@ export declare namespace linkTools {
         }
     }
 
-    export abstract class Anchor extends dia.ToolView {
+    export abstract class Anchor extends dia.ToolView<dia.LinkView> {
 
         type: string;
 
@@ -3871,10 +4087,14 @@ export declare namespace linkTools {
 
     export namespace Button {
 
-        export type ActionCallback = (evt: dia.Event, view: dia.LinkView, tool: dia.ToolView) => void;
+        export type ActionCallback = (evt: dia.Event, view: dia.LinkView, tool: Button) => void;
 
-        export interface Options extends dia.ToolView.Options {
-            distance?: number | string;
+        export type Distance = number | string;
+
+        export type DistanceCallback = (this: Button, view: dia.LinkView, tool: Button) => Distance;
+
+        export interface Options extends dia.ToolView.Options<dia.LinkView> {
+            distance?: Distance | DistanceCallback;
             offset?: number;
             rotate?: boolean;
             action?: ActionCallback;
@@ -3883,7 +4103,7 @@ export declare namespace linkTools {
         }
     }
 
-    export class Button extends dia.ToolView {
+    export class Button extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Button.Options);
 
@@ -3917,13 +4137,13 @@ export declare namespace linkTools {
     }
 
     export namespace Boundary {
-        export interface Options extends dia.ToolView.Options {
+        export interface Options extends dia.ToolView.Options<dia.LinkView> {
             padding?: number | dia.Sides;
             useModelGeometry?: boolean;
         }
     }
 
-    export class Boundary extends dia.ToolView {
+    export class Boundary extends dia.ToolView<dia.LinkView> {
 
         constructor(opt?: Boundary.Options);
     }
@@ -3959,6 +4179,54 @@ export declare namespace linkTools {
 
         protected onMouseleave(evt: dia.Event): void;
     }
+
+    export namespace Control {
+        export interface Options extends dia.ToolView.Options {
+            selector?: string | null;
+            padding?: number;
+            handleAttributes?: Partial<attributes.NativeSVGAttributes>;
+            scale?: number;
+        }
+    }
+
+    export 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;
+    }
+
+    export namespace RotateLabel {
+
+        export interface Options extends Control.Options {
+            offset?: number | dia.Point;
+            buttonColor?: string;
+            iconColor?: string;
+            outlineColor?: string;
+        }
+    }
+
+    export 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;
+    }
 }
 
 export declare namespace mvc {
@@ -4913,6 +5181,14 @@ export declare namespace shapes {
 
 export declare namespace util {
 
+    export function cloneCells(cells: dia.Cell[]): { [id: string]: dia.Cell };
+
+    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;
@@ -4983,6 +5259,8 @@ export declare namespace util {
 
     export function toggleFullScreen(el?: Element): void;
 
+    export function objectDifference(object: object, base: object, opt?: { maxDepth?: number }): object;
+
     export interface DOMJSONDocument {
         fragment: DocumentFragment;
         selectors: { [key: string]: Element };