@joint/core 4.1.3 → 4.2.0-alpha.1

package/types/joint.d.ts

@@ -8,6 +8,8 @@ export namespace config {
     var classNamePrefix: string;
     var defaultTheme: string;
     var doubleTapInterval: number;
+    var cellMergeStrategy: util.MergeCustomizer | null;
+    var cellDefaultsMergeStrategy: util.MergeCustomizer | null;
 }
 
 type NativeEvent = Event;
@@ -333,6 +335,7 @@ export namespace dia {
         interface GenericAttributes<T> {
             attrs?: T;
             z?: number;
+            layer?: string;
             [key: string]: any;
         }
 
@@ -521,6 +524,8 @@ export namespace dia {
 
         getBBox(): g.Rect;
 
+        getCenter(): g.Point;
+
         getPointFromConnectedLink(link: dia.Link, endType: dia.LinkEnd): g.Point;
 
         getPointRotatedAroundCenter(angle: number, x: number, y: number): g.Point;
@@ -536,6 +541,8 @@ export namespace dia {
 
         static define(type: string, defaults?: any, protoProps?: any, staticProps?: any): Cell.Constructor<Cell>;
 
+        static getAttributeDefinition(attrName: string): Cell.PresentationAttributeDefinition<CellView> | null;
+
         /**
          * @deprecated
          */
@@ -560,23 +567,40 @@ export namespace dia {
         interface Attributes extends GenericAttributes<Cell.Selectors> {
         }
 
-        type PortPositionCallback = (ports: Port[], bbox: g.Rect) => dia.Point[];
+        interface ConstructorOptions extends Cell.ConstructorOptions {
+            portLayoutNamespace?: { [key: string]: layout.Port.LayoutFunction };
+            portLabelLayoutNamespace?: { [key: string]: layout.PortLabel.LayoutFunction };
+        }
+
+        type PortPositionCallback = layout.Port.LayoutFunction;
+
+        type PortLabelPositionCallback = layout.PortLabel.LayoutFunction;
 
         interface PortPositionJSON {
             name?: string;
-            args?: { [key: string]: any };
+            args?: layout.Port.Options;
+        }
+
+        interface PortLabelPositionJSON {
+            name?: string;
+            args?: layout.PortLabel.Options;
         }
 
         type PositionType = string | PortPositionCallback | PortPositionJSON;
 
+        type PortLabelPositionType = PortLabelPositionCallback | PortPositionJSON;
+
         interface PortGroup {
             position?: PositionType;
             markup?: string | MarkupJSON;
             attrs?: Cell.Selectors;
-            label?: {
-                markup?: string | MarkupJSON;
-                position?: PositionType;
-            };
+            size?: Size;
+            label?: PortLabel;
+        }
+
+        interface PortLabel {
+            markup?: string | MarkupJSON;
+            position?: PortLabelPositionType;
         }
 
         interface Port {
@@ -584,11 +608,13 @@ export namespace dia {
             markup?: string | MarkupJSON;
             group?: string;
             attrs?: Cell.Selectors;
-            args?: { [key: string]: any };
-            label?: {
-                markup?: string | MarkupJSON;
-                position?: PositionType;
+            position?: {
+                args?: layout.Port.Options;
             };
+            /** @deprecated use `position.args` instead */
+            args?: layout.Port.Options;
+            size?: Size;
+            label?: PortLabel;
             z?: number | 'auto';
         }
 
@@ -596,6 +622,10 @@ export namespace dia {
             angle: number;
         }
 
+        interface PortRect extends BBox {
+            angle: number;
+        }
+
         interface TranslateOptions extends Cell.Options {
             restrictedArea?: BBox | Paper.PointConstraintCallback;
             transition?: Cell.TransitionOptions;
@@ -610,13 +640,32 @@ export namespace dia {
             direction?: Direction;
         }
 
-        interface BBoxOptions extends Cell.EmbeddableOptions {
+        interface FitToChildrenOptions {
+            filter?: (cell: Cell) => boolean;
+            deep?: boolean;
+            padding?: Padding;
+            minRect?: Partial<BBox>;
+            expandOnly?: boolean;
+            shrinkOnly?: boolean;
+        }
+
+        interface FitParentOptions extends FitToChildrenOptions {
+            terminator?: Cell | Cell.ID;
+        }
+
+        interface RotateOptions {
             rotate?: boolean;
         }
+
+        interface BBoxOptions extends Cell.EmbeddableOptions, RotateOptions {
+
+        }
     }
 
     class Element<A extends ObjectHash = Element.Attributes, S extends mvc.ModelSetOptions = dia.ModelSetOptions> extends Cell<A, S> {
 
+        constructor(attributes?: DeepPartial<A>, opt?: Element.ConstructorOptions);
+
         translate(tx: number, ty?: number, opt?: Element.TranslateOptions): this;
 
         position(opt?: Element.PositionOptions): g.Point;
@@ -634,10 +683,10 @@ export namespace dia {
 
         scale(scaleX: number, scaleY: number, origin?: Point, opt?: { [key: string]: any }): this;
 
-        fitEmbeds(opt?: { deep?: boolean, padding?: Padding, expandOnly?: boolean, shrinkOnly?: boolean }): this;
-        fitToChildren(opt?: { deep?: boolean, padding?: Padding, expandOnly?: boolean, shrinkOnly?: boolean }): this;
+        fitEmbeds(opt?: Element.FitToChildrenOptions): this;
+        fitToChildren(opt?: Element.FitToChildrenOptions): this;
 
-        fitParent(opt?: { deep?: boolean, padding?: Padding, expandOnly?: boolean, shrinkOnly?: boolean, terminator?: Cell | Cell.ID }): this;
+        fitParent(opt?: Element.FitParentOptions): this;
 
         getBBox(opt?: Element.BBoxOptions): g.Rect;
 
@@ -664,6 +713,14 @@ export namespace dia {
 
         getPortsPositions(groupName: string): { [id: string]: Element.PortPosition };
 
+        getPortRelativePosition(portId: string): Element.PortPosition;
+
+        getPortRelativeRect(portId: string): Element.PortRect;
+
+        getPortCenter(portId: string): g.Point;
+
+        getPortBBox(portId: string, opt?: Element.RotateOptions): g.Rect;
+
         getPortIndex(port: string | Element.Port): number;
 
         getPortGroupNames(): string[];
@@ -946,6 +1003,10 @@ export namespace dia {
 
         isIntersecting(geometryShape: g.Shape, geometryData?: g.SegmentSubdivisionsOpt | null): boolean;
 
+        cleanNodesCache(): void;
+
+        cleanNodeCache(node: SVGElement): void
+
         protected isEnclosedIn(area: g.Rect): boolean;
 
         protected isInArea(area: g.Rect, options: g.StrictOpt): boolean;
@@ -1002,8 +1063,6 @@ export namespace dia {
 
         protected addLinkFromMagnet(magnet: SVGElement, x: number, y: number): LinkView;
 
-        protected cleanNodesCache(): void;
-
         protected nodeCache(magnet: SVGElement): CellView.NodeMetrics;
 
         protected getNodeData(magnet: SVGElement): CellView.NodeData;
@@ -1326,36 +1385,94 @@ export namespace dia {
             GRID = 'grid',
         }
 
-        type UpdateStats = {
+        interface RenderStats {
             priority: number;
             updated: number;
-            empty?: boolean;
-            postponed?: number;
-            unmounted?: number;
-            mounted?: number;
+        }
+
+        interface UpdateVisibilityStats {
+            mounted: number;
+            unmounted: number;
+        }
+
+        interface RenderBatchStats extends RenderStats, UpdateVisibilityStats {
+            postponed: number;
+            empty: boolean;
+        }
+
+        type UpdateStats = RenderStats & Partial<RenderBatchStats> & {
             batches?: number;
         };
 
         type ViewportCallback = (view: mvc.View<any, any>, isMounted: boolean, paper: Paper) => boolean;
+        type CellVisibilityCallback = (cell: Cell, isMounted: boolean, paper: Paper) => boolean;
         type ProgressCallback = (done: boolean, processed: number, total: number, stats: UpdateStats, paper: Paper) => void;
         type BeforeRenderCallback = (opt: { [key: string]: any }, paper: Paper) => void;
         type AfterRenderCallback = (stats: UpdateStats, opt: { [key: string]: any }, paper: Paper) => void;
 
-        interface FreezeOptions {
-            key?: string;
+        interface CellVisibilityOptions {
+            cellVisibility?: CellVisibilityCallback | null;
+
+            /** @deprecated disable `legacyMode` and use `cellVisibility` instead */
+            viewport?: ViewportCallback | null;
         }
 
-        interface UnfreezeOptions {
-            key?: string;
+        interface MountOptions {
             mountBatchSize?: number;
+        }
+
+        interface UnmountOptions {
             unmountBatchSize?: number;
+        }
+
+        interface BatchSizeOptions {
             batchSize?: number;
-            viewport?: ViewportCallback;
-            progress?: ProgressCallback;
+        }
+
+        interface BeforeRenderOptions {
             beforeRender?: BeforeRenderCallback;
+        }
+
+        interface AfterRenderOptions {
             afterRender?: AfterRenderCallback;
         }
 
+        interface RenderCallbackOptions extends BeforeRenderOptions, AfterRenderOptions, mvc.Silenceable {
+
+        }
+
+        interface KeyOptions {
+            key?: string;
+        }
+
+        interface UpdateViewOptions {
+            [key: string]: any;
+        }
+
+        interface UpdateViewsBatchOptions extends UpdateViewOptions, BatchSizeOptions, CellVisibilityOptions {
+
+        }
+
+        interface UpdateViewsOptions extends UpdateViewsBatchOptions, RenderCallbackOptions {
+
+        }
+
+        interface UpdateViewsAsyncOptions extends UpdateViewsBatchOptions, ScheduleCellsVisibilityUpdateOptions, RenderCallbackOptions {
+            progress?: ProgressCallback;
+        }
+
+        interface ScheduleCellsVisibilityUpdateOptions extends CellVisibilityOptions, MountOptions, UnmountOptions {
+
+        }
+
+        interface FreezeOptions extends KeyOptions {
+
+        }
+
+        interface UnfreezeOptions extends KeyOptions, UpdateViewsAsyncOptions, UpdateViewsOptions {
+
+        }
+
         interface SnapLinksOptions {
             radius?: number;
             findInAreaOptions?: FindInAreaOptions;
@@ -1365,8 +1482,9 @@ export namespace dia {
         type RestrictTranslateCallback = (elementView: ElementView, x0: number, y0: number) => BBox | boolean | PointConstraintCallback;
         type FindParentByType = 'bbox' | 'pointer' | PositionName;
         type FindParentByCallback = ((this: dia.Graph, elementView: ElementView, evt: dia.Event, x: number, y: number) => Cell[]);
+        type MeasureNodeCallback = (node: SVGGraphicsElement, cellView: dia.CellView) => g.Rect;
 
-        interface Options extends mvc.ViewOptions<Graph> {
+        interface Options extends mvc.ViewOptions<Graph>, CellVisibilityOptions, BeforeRenderOptions, AfterRenderOptions {
             // appearance
             width?: Dimension;
             height?: Dimension;
@@ -1400,6 +1518,7 @@ export namespace dia {
             // views
             elementView?: typeof ElementView | ((element: Element) => typeof ElementView);
             linkView?: typeof LinkView | ((link: Link) => typeof LinkView);
+            measureNode?: MeasureNodeCallback;
             // embedding
             embeddingMode?: boolean;
             frontParentOnly?: boolean;
@@ -1427,14 +1546,17 @@ export namespace dia {
             sorting?: sorting;
             frozen?: boolean;
             autoFreeze?: boolean;
-            viewport?: ViewportCallback | null;
+            viewManagement?: ViewManagementOptions | boolean;
             onViewUpdate?: (view: mvc.View<any, any>, flag: number, priority: number, opt: { [key: string]: any }, paper: Paper) => void;
             onViewPostponed?: (view: mvc.View<any, any>, flag: number, paper: Paper) => boolean;
-            beforeRender?: Paper.BeforeRenderCallback;
-            afterRender?: Paper.AfterRenderCallback;
             overflow?: boolean;
         }
 
+        interface ViewManagementOptions {
+            lazyInitialize?: boolean;
+            disposeHidden?: boolean;
+        }
+
         interface TransformToFitContentOptions {
             padding?: Padding;
             preserveAspectRatio?: boolean;
@@ -1567,6 +1689,17 @@ export namespace dia {
 
         interface FindInAreaOptions extends Graph.FindInAreaOptions, BufferOptions {
         }
+
+        interface FindClosestMagnetToPointOptions {
+            radius?: number;
+            findInAreaOptions?: FindInAreaOptions;
+            filter?: (view: CellView, magnet: SVGElement) => boolean;
+        }
+
+        interface ClosestMagnet {
+            view: CellView;
+            magnet: SVGElement;
+        }
     }
 
     class Paper extends mvc.View<Graph> {
@@ -1702,6 +1835,13 @@ export namespace dia {
          */
         findCellViewsInArea(area: BBox, opt?: Paper.FindInAreaOptions): CellView[];
 
+        /**
+         * Finds the closest magnet to the specified point
+         * @param point a point in local paper coordinates
+         * @param opt options for the search
+         */
+        findClosestMagnetToPoint(point: Point, opt?: Paper.FindClosestMagnetToPointOptions): Paper.ClosestMagnet | null;
+
         fitToContent(opt?: Paper.FitToContentOptions): g.Rect;
         fitToContent(gridWidth?: number, gridHeight?: number, padding?: number, opt?: any): g.Rect;
 
@@ -1751,7 +1891,7 @@ export namespace dia {
 
         getLayerNode(layerName: Paper.Layers | string): SVGGElement;
 
-        getLayerView(layerName: Paper.Layers | string): any;
+        getLayerView(layerName: Paper.Layers | string): PaperLayer;
 
         hasLayerView(layerName: Paper.Layers | string): boolean;
 
@@ -1761,44 +1901,48 @@ export namespace dia {
 
         protected resetLayers(): void;
 
+        addLayer(layerName: string, layerView: PaperLayer, options?: { insertBefore?: string }): void;
+
+        removeLayer(layer: string | PaperLayer): void;
+
+        moveLayer(layer: string | PaperLayer, insertBefore: string | PaperLayer | null): void;
+
+        hasLayer(layer: string | PaperLayer): boolean;
+
+        getLayerNames(): string[];
+
+        getLayers(): Array<PaperLayer>;
+
         // rendering
 
         freeze(opt?: Paper.FreezeOptions): void;
 
         unfreeze(opt?: Paper.UnfreezeOptions): void;
 
+        wakeUp(): void;
+
         isFrozen(): boolean;
 
         requestViewUpdate(view: mvc.View<any, any>, flag: number, priority: number, opt?: { [key: string]: any }): void;
 
-        requireView<T extends ElementView | LinkView>(model: Cell | Cell.ID, opt?: dia.Cell.Options): T;
+        requireView<T extends ElementView | LinkView>(cellOrId: Cell | Cell.ID, opt?: Paper.UpdateViewOptions & Paper.RenderCallbackOptions): T;
 
-        dumpViews(opt?: {
-            batchSize?: number;
-            mountBatchSize?: number;
-            unmountBatchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): void;
+        updateViews(opt?: Paper.UpdateViewsOptions): Paper.RenderStats & { batches: number };
 
-        checkViewport(opt?: {
-            mountBatchSize?: number;
-            unmountBatchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): {
-            mounted: number;
-            unmounted: number;
-        };
+        hasScheduledUpdates(): boolean;
 
-        updateViews(opt?: {
-            batchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): {
-            updated: number;
-            batches: number;
-            priority: number;
-        };
+        disposeHiddenCellViews(): void;
 
-        hasScheduledUpdates(): boolean;
+        isCellVisible(cellOrId: dia.Cell | dia.Cell.ID): boolean;
+
+        updateCellVisibility(
+            cell: Cell | Cell.ID,
+            opt?: Paper.CellVisibilityOptions & Paper.UpdateViewOptions & Paper.RenderCallbackOptions
+        ): void;
+
+        updateCellsVisibility(
+            opt?: Paper.ScheduleCellsVisibilityUpdateOptions & Paper.UpdateViewsOptions
+        ): void;
 
         // events
 
@@ -1809,52 +1953,51 @@ export namespace dia {
         // protected
 
         /**
-        * For the specified view, calls the visibility viewport function specified by the paper.options.viewport function.
+        * For the specified view, calls the cell visibility function specified by the `paper.options.cellVisibility` function.
         * If the function returns true, the view is attached to the DOM; in other case it is detached.
-        * While async papers do this automatically, synchronous papers require an explicit call to this method for this functionality to be applied. To show the view again, use paper.requestView().
-        * If you are using autoFreeze option you should call this function if you are calling paper.requestView() if you want paper.options.viewport function to be applied.
+        * While async papers do this automatically, synchronous papers require an explicit call to this method for this functionality to be applied. To show the view again, use `paper.requestView()`.
+        * If you are using `autoFreeze` option you should call this function if you are calling `paper.requestView()` if you want `paper.options.cellVisibility` function to be applied.
         * @param cellView cellView for which the visibility check is performed
-        * @param opt if opt.viewport is provided, it is used as the callback function instead of paper.options.viewport.
+        * @param opt if opt.cellVisibility is provided, it is used as the callback function instead of paper.options.cellVisibility.
         */
-        protected checkViewVisibility(cellView: dia.CellView, opt?: {
-            viewport?: Paper.ViewportCallback;
-        }): {
-            mounted: number;
-            unmounted: number;
-        };
+        protected checkViewVisibility(
+            cellView: dia.CellView,
+            opt?: Paper.CellVisibilityOptions
+        ): Paper.UpdateVisibilityStats;
+
+
+        protected scheduleCellsVisibilityUpdate(opt?: Paper.ScheduleCellsVisibilityUpdateOptions): Paper.UpdateVisibilityStats;
 
         protected scheduleViewUpdate(view: mvc.View<any, any>, flag: number, priority: number, opt?: { [key: string]: any }): void;
 
         protected dumpViewUpdate(view: mvc.View<any, any>): number;
 
-        protected dumpView(view: mvc.View<any, any>, opt?: { [key: string]: any }): number;
+        protected dumpView(view: mvc.View<any, any>, opt?: Paper.UpdateViewOptions & Paper.RenderCallbackOptions): number;
 
-        protected updateView(view: mvc.View<any, any>, flag: number, opt?: { [key: string]: any }): number;
+        protected updateView(view: mvc.View<any, any>, flag: number, opt?: Paper.UpdateViewOptions): number;
 
         protected registerUnmountedView(view: mvc.View<any, any>): number;
 
         protected registerMountedView(view: mvc.View<any, any>): number;
 
-        protected updateViewsAsync(opt?: {
-            batchSize?: number;
-            mountBatchSize?: number;
-            unmountBatchSize?: number;
-            viewport?: Paper.ViewportCallback;
-            progress?: Paper.ProgressCallback;
-            before?: Paper.BeforeRenderCallback;
-        }): void;
+        protected updateViewsAsync(opt?: Paper.UpdateViewsAsyncOptions): void;
 
-        protected updateViewsBatch(opt?: {
-            batchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): Paper.UpdateStats;
+        protected updateViewsBatch(opt?: Paper.UpdateViewsBatchOptions): Paper.RenderBatchStats;
+
+        protected checkMountedViews(viewport: Paper.ViewportCallback, opt?: Paper.UnmountOptions): number;
+
+        protected checkUnmountedViews(viewport: Paper.ViewportCallback, opt?: Paper.MountOptions): number;
 
-        protected checkMountedViews(viewport: Paper.ViewportCallback, opt?: { unmountBatchSize?: number }): number;
+        protected prioritizeCellViewMount(cellOrId: dia.Cell | dia.Cell.ID): boolean;
 
-        protected checkUnmountedViews(viewport: Paper.ViewportCallback, opt?: { mountBatchSize?: number }): number;
+        protected prioritizeCellViewUnmount(cellOrId: dia.Cell | dia.Cell.ID): boolean;
+
+        protected isViewMounted(viewOrCid: dia.CellView | string): boolean;
 
         protected isAsync(): boolean;
 
+        protected isIdle(): boolean;
+
         protected isExactSorting(): boolean;
 
         protected sortViews(): void;
@@ -1930,7 +2073,9 @@ export namespace dia {
 
         protected insertView(cellView: CellView, isInitialInsert: boolean): void;
 
-        protected detachView(cellView: CellView): void;
+        protected _hideCellView(cellView: CellView): void;
+
+        protected _detachCellView(cellView: CellView): void;
 
         protected customEventTrigger(event: dia.Event, view: CellView, rootNode?: SVGElement): dia.Event | null;
 
@@ -1950,6 +2095,16 @@ export namespace dia {
          * @deprecated use transformToFitContent
          */
         scaleContentToFit(opt?: Paper.ScaleContentOptions): void;
+
+        /**
+         * @deprecated Use `updateCellsVisibility()`
+         */
+        checkViewport(opt?: Paper.ScheduleCellsVisibilityUpdateOptions): Paper.UpdateVisibilityStats;
+
+        /**
+         * @deprecated Use `updateCellsVisibility()`
+         */
+        dumpViews(opt?: Paper.ScheduleCellsVisibilityUpdateOptions & Paper.UpdateViewsOptions): void;
     }
 
     namespace PaperLayer {
@@ -2008,6 +2163,10 @@ export namespace dia {
         hide(): this;
 
         mount(): this;
+
+        getLayer(): string | null;
+
+        hasLayer(): boolean;
     }
 
     namespace ToolView {
@@ -2051,6 +2210,8 @@ export namespace dia {
 
         update(): void;
 
+        isOverlay(): boolean;
+
         protected guard(evt: dia.Event): boolean;
     }
 
@@ -2142,6 +2303,8 @@ export namespace dia {
             id?: string
         ): T[];
 
+        static has(cellView: dia.CellView, id?: string): boolean;
+
         static update(cellView: dia.CellView, id?: string): void;
 
         static transform(cellView: dia.CellView, id?: string): void;
@@ -2274,7 +2437,7 @@ export namespace highlighters {
             position?: Positions | dia.PositionName;
             size?: number | dia.Size;
             gap?: number;
-            margin?: number | dia.Sides;
+            margin?: dia.Sides;
         }
     }
 
@@ -2625,19 +2788,21 @@ export namespace util {
 
     export function parseCssNumeric(val: any, restrictUnits: string | string[]): { value: number, unit?: string } | null;
 
+    type BreakTextOptions = {
+        svgDocument?: SVGElement;
+        separator?: string | any;
+        eol?: string;
+        ellipsis?: boolean | string;
+        hyphen?: string | RegExp;
+        maxLineCount?: number;
+        preserveSpaces?: boolean;
+    }
+
     type BreakTextFunction = (
         text: string,
         size: { width: number, height?: number },
         attrs?: attributes.NativeSVGAttributes,
-        opt?: {
-            svgDocument?: SVGElement;
-            separator?: string | any;
-            eol?: string;
-            ellipsis?: boolean | string;
-            hyphen?: string | RegExp;
-            maxLineCount?: number;
-            preserveSpaces?: boolean;
-        }
+        opt?: BreakTextOptions
     ) => string;
 
     export var breakText: BreakTextFunction;
@@ -2898,6 +3063,8 @@ export namespace util {
 
     export function merge(destinationObject: object, ...args: any[]): object;
 
+    type MergeCustomizer = (value: any, srcValue: any, key: string, object: any, source: any, stack: any) => any;
+
     // ADDITIONAL SIMPLE UTIL FUNCTIONS:
 
     export function isBoolean(value: any): boolean;
@@ -2937,7 +3104,7 @@ export namespace layout {
             angle: number;
         };
 
-        type LayoutFunction = (ports: Array<Object>, elBBox: g.Rect, opt: Options) => Array<Transformation>;
+        type LayoutFunction = (ports: Array<dia.Element.Port>, elBBox: g.Rect, opt: Options) => Array<Transformation>;
 
         interface Options {
             x?: number | string;
@@ -2950,9 +3117,11 @@ export namespace layout {
             startAngle?: number;
             step?: number;
             compensateRotation?: boolean;
+            [key: string]: any;
         }
 
         export var absolute: LayoutFunction;
+        /** @deprecated */
         export var fn: LayoutFunction;
         export var line: LayoutFunction;
         export var left: LayoutFunction;
@@ -2971,6 +3140,7 @@ export namespace layout {
             angle?: number;
             offset?: number;
             attrs?: dia.Cell.Selectors;
+            [key: string]: any;
         }
 
         interface LabelAttributes {
@@ -3405,6 +3575,7 @@ export namespace mvc {
         collection?: Collection<any> | undefined; // was: Collection<TModel>;
         el?: $Element<TElement> | string | undefined;
         id?: string | undefined;
+        cid?: string | undefined;
         attributes?: Record<string, any> | undefined;
         className?: string | undefined;
         tagName?: string | undefined;
@@ -3431,7 +3602,7 @@ export namespace mvc {
 
         /**
          * Events hash or a method returning the events hash that maps events/selectors to methods on your View.
-         * For assigning events as object hash, do it like this: this.events = <any>{ "event:selector": callback, ... };
+         * For assigning events as object hash, do it like this: `this.events = <any>{ "event:selector": callback, ... };`
          * That works only if you set it in the constructor or the initialize method.
          */
         events(): EventsHash;
@@ -3447,9 +3618,9 @@ export namespace mvc {
 
         el: TElement;
         attributes: Record<string, any>;
-        /* @deprecated use `el` instead */
+        /** @deprecated use `el` instead */
         $el: Dom;
-        /* @deprecated use `el.querySelector()` instead */
+        /** @deprecated use `el.querySelector()` instead */
         $(selector: string): Dom;
         render(): this;
         remove(): this;
@@ -3784,7 +3955,11 @@ export namespace connectors {
 
 export namespace anchors {
 
-    interface RotateAnchorArguments {
+    interface ElementAnchorArguments {
+        useModelGeometry?: boolean;
+    }
+
+    interface RotateAnchorArguments extends ElementAnchorArguments {
         rotate?: boolean;
     }
 
@@ -3793,12 +3968,13 @@ export namespace anchors {
         dy?: number | string;
     }
 
-    interface PaddingAnchorArguments {
+    interface PaddingAnchorArguments extends ElementAnchorArguments {
         padding?: number;
     }
 
     interface MidSideAnchorArguments extends RotateAnchorArguments, PaddingAnchorArguments {
-
+        mode?: 'prefer-horizontal' | 'prefer-vertical' | 'horizontal' | 'vertical' | 'auto';
+        preferenceThreshold?: dia.Sides;
     }
 
     interface ModelCenterAnchorArguments {
@@ -4356,7 +4532,7 @@ export namespace elementTools {
 
     namespace Boundary {
         interface Options extends dia.ToolView.Options<dia.ElementView> {
-            padding?: number | dia.Sides;
+            padding?: dia.Sides;
             useModelGeometry?: boolean;
             rotate?: boolean;
         }
@@ -4599,7 +4775,7 @@ export namespace linkTools {
 
     namespace Boundary {
         interface Options extends dia.ToolView.Options<dia.LinkView> {
-            padding?: number | dia.Sides;
+            padding?: dia.Sides;
             useModelGeometry?: boolean;
         }
     }