@joint/core 4.2.0-alpha.0 → 4.2.0-beta.1

package/dist/joint.d.ts

@@ -1,10 +1,10 @@
-/*! JointJS v4.2.0-alpha.0 (2025-06-16) - JavaScript diagramming library
-
+/*! JointJS v4.2.0-beta.1 (2025-11-03) - JavaScript diagramming library
 
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
+
 // Definitions by:
 // Aidan Reel <http://github.com/areel>,
 // David Durman <http://github.com/DavidDurman>,
@@ -38,7 +38,8 @@ export declare namespace anchors {
     }
 
     export interface MidSideAnchorArguments extends RotateAnchorArguments, PaddingAnchorArguments {
-
+        mode?: 'prefer-horizontal' | 'prefer-vertical' | 'horizontal' | 'vertical' | 'auto';
+        preferenceThreshold?: dia.Sides;
     }
 
     export interface ModelCenterAnchorArguments {
@@ -428,6 +429,9 @@ export declare namespace config {
     var classNamePrefix: string;
     var defaultTheme: string;
     var doubleTapInterval: number;
+    var cellMergeStrategy: util.MergeCustomizer | null;
+    var cellDefaultsMergeStrategy: util.MergeCustomizer | null;
+    var layerAttribute: string;
 }
 
 export declare namespace connectionPoints {
@@ -758,6 +762,89 @@ export declare namespace dia {
     util.filter.FilterJSON<'brightness'> |
     util.filter.FilterJSON<'contrast'>;
 
+    export class CellCollection<C extends Cell = Cell> extends mvc.Collection<C> {
+
+        cellNamespace: any;
+        layer: GraphLayer;
+
+        minZIndex(): number;
+
+        maxZIndex(): number;
+    }
+
+    export class GraphLayerCollection<L extends GraphLayer = GraphLayer> extends mvc.Collection<L> {
+
+        cellNamespace: any;
+        layerNamespace: any;
+        graph: Graph;
+
+        insert(layer: Graph.LayerInit, beforeId: GraphLayer.ID | null, opt?: ObjectHash): void;
+
+        getCell(cellRef: Graph.CellRef): Cell | undefined;
+
+        getCells(): Cell[];
+
+        removeCell(cell: Cell, opt?: ObjectHash): void;
+
+        moveCellBetweenLayers(cell: Cell, targetLayerId: GraphLayer.ID, opt?: ObjectHash): void;
+
+        addCellToLayer(cell: Cell, layerId: GraphLayer.ID, opt?: ObjectHash): void;
+    }
+
+    export class GraphLayersController extends mvc.Listener<[]> {
+
+        graph: Graph;
+
+        layerCollection: GraphLayerCollection;
+
+        startListening(): void;
+
+        protected onCellChange(cell: Cell, opt: ObjectHash): void;
+
+        protected onCellRemove(cell: Cell, opt: ObjectHash): void;
+
+        protected onLayerCollectionEvent(eventName: string, ...args: any[]): void;
+
+        protected forwardLayerEvent(...args: any[]): void;
+
+        protected forwardCellEvent(...args: any[]): void;
+
+        protected forwardCellCollectionEvent(...args: any[]): void;
+
+        protected forwardLayerCollectionEvent(...args: any[]): void;
+    }
+
+    export class GraphTopologyIndex extends mvc.Listener<[]> {
+
+        layerCollection: GraphLayerCollection;
+
+        startListening(): void;
+
+        getOutboundEdges(id: Cell.ID): { [edgeId: string]: true };
+
+        getInboundEdges(id: Cell.ID): { [edgeId: string]: true };
+
+        getSinkNodes(): string[];
+
+        getSourceNodes(): string[];
+
+        isSinkNode(id: Cell.ID): boolean;
+
+        isSourceNode(id: Cell.ID): boolean;
+
+        protected initializeIndex(): void;
+
+        protected _restructureOnReset(): void;
+
+        protected _restructureOnAdd(cell: Cell): void;
+
+        protected _restructureOnRemove(cell: Cell): void;
+
+        protected _restructureOnChangeSource(cell: Cell): void;
+
+        protected _restructureOnChangeTarget(cell: Cell): void;
+    }
+
     export namespace Graph {
 
         export interface Options {
@@ -781,35 +868,100 @@ export declare namespace dia {
             strict?: boolean;
         }
 
+        export interface SyncCellOptions extends Options {
+            remove?: boolean;
+        }
+
+        export interface RemoveCellOptions extends Options {
+            disconnectLinks?: boolean;
+            replace?: boolean;
+            clear?: 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;
-        }
+        export type Cells = CellCollection;
+
+        export type CellInit = Cell | Cell.JSON;
+
+        export type CellRef = Cell | Cell.ID;
+
+        export type LayerInit = GraphLayer | GraphLayer.Attributes;
+
+        export type LayerRef = GraphLayer | GraphLayer.ID;
 
         export interface Attributes {
-            cells?: Cells;
+            /** @deprecated use cellsCollection property **/
+            cells?: CellCollection;
             [key: string]: any;
         }
+
+        export interface JSON {
+            cells: Array<Cell.JSON>;
+            layers?: Array<GraphLayer.Attributes>;
+            defaultLayer?: string;
+            [key: string]: any;
+        }
+
+        export interface InsertLayerOptions extends Options {
+            before?: GraphLayer.ID | null;
+            index?: number;
+        }
     }
 
     export class Graph<A extends ObjectHash = Graph.Attributes, S = dia.ModelSetOptions> extends mvc.Model<A, S> {
 
-        constructor(attributes?: Graph.Attributes, opt?: { cellNamespace?: any, cellModel?: typeof Cell });
+        layerCollection: GraphLayerCollection;
+
+        defaultLayerId: GraphLayer.ID;
+
+        layersController: GraphLayersController;
+
+        topologyIndex: GraphTopologyIndex;
+
+        constructor(attributes?: Graph.Attributes, opt?: {
+            cellNamespace?: any,
+            layerNamespace?: any,
+            /** @deprecated use cellNamespace instead */
+            cellModel?: typeof Cell
+        });
+
+        addCell(cell: Graph.CellInit, opt?: CollectionAddOptions): this;
+        addCell(cell: Array<Graph.CellInit>, opt?: CollectionAddOptions): this;
+
+        addCells(cells: Array<Graph.CellInit>, opt?: CollectionAddOptions): this;
+
+        removeCell(cell: Graph.CellRef, opt?: Graph.RemoveCellOptions): void;
+
+        removeCells(cells: Array<Graph.CellRef>, opt?: Graph.RemoveCellOptions): this;
 
-        addCell(cell: Cell.JSON | Cell, opt?: CollectionAddOptions): this;
-        addCell(cell: Array<Cell | Cell.JSON>, opt?: CollectionAddOptions): this;
+        resetCells(cells: Array<Graph.CellInit>, opt?: Graph.Options): this;
 
-        addCells(cells: Array<Cell | Cell.JSON>, opt?: CollectionAddOptions): this;
+        syncCells(cells: Array<Graph.CellInit>, opt?: Graph.SyncCellOptions): void;
 
-        resetCells(cells: Array<Cell | Cell.JSON>, opt?: Graph.Options): this;
+        addLayer(layerInit: Graph.LayerInit, opt?: Graph.InsertLayerOptions): void;
 
-        getCell(id: Cell.ID | Cell): Cell;
+        moveLayer(layerRef: Graph.LayerRef, opt?: Graph.InsertLayerOptions): void;
+
+        removeLayer(layerRef: Graph.LayerRef, opt?: Graph.Options): void;
+
+        getDefaultLayer(): GraphLayer;
+
+        setDefaultLayer(id: string, opt?: Graph.Options): void;
+
+        getLayer(id: string): GraphLayer;
+
+        hasLayer(id: string): boolean;
+
+        getLayers(): GraphLayer[];
+
+        getCellLayerId(cell: Graph.CellRef): GraphLayer.ID;
+
+        getCell(id: Graph.CellRef): Cell;
 
         getElements(): Element[];
 
@@ -817,15 +969,15 @@ export declare namespace dia {
 
         getCells(): Cell[];
 
-        getFirstCell(): Cell | undefined;
+        getFirstCell(layerId?: string): Cell | undefined;
 
-        getLastCell(): Cell | undefined;
+        getLastCell(layerId?: string): Cell | undefined;
 
         getConnectedLinks(cell: Cell, opt?: Graph.ConnectionOptions): Link[];
 
         disconnectLinks(cell: Cell, opt?: S): void;
 
-        removeLinks(cell: Cell, opt?: Cell.DisconnectableOptions): void;
+        removeLinks(cell: Graph.CellRef, opt?: Graph.RemoveCellOptions): void;
 
         translate(tx: number, ty?: number, opt?: Element.TranslateOptions): this;
 
@@ -897,6 +1049,12 @@ export declare namespace dia {
 
         protected _filterCellsUnderElement(cells: Cell[], element: Element, opt: Graph.FindUnderElementOptions): Cell[];
 
+        protected _syncCell(cellInit: Graph.CellInit, opt?: Graph.Options): void;
+
+        protected _replaceCell(currentCell: Cell, newCellInit: Graph.CellInit,  opt?: Graph.Options): void;
+
+        protected _resetLayers(layers: Array<Graph.LayerInit>, defaultLayerId: GraphLayer.ID | null, opt?: Graph.Options): this;
+
         /** @deprecated use `findElementsAtPoint` instead */
         findModelsFromPoint(p: Point): Element[];
 
@@ -912,11 +1070,9 @@ export declare namespace dia {
 
         hasActiveBatch(name?: string | string[]): boolean;
 
-        maxZIndex(): number;
-
-        minZIndex(): number;
+        maxZIndex(layerId?: GraphLayer.ID): number;
 
-        removeCells(cells: Cell[], opt?: Cell.DisconnectableOptions): this;
+        minZIndex(layerId?: GraphLayer.ID): number;
 
         transferCellEmbeds(sourceCell: Cell, targetCell: Cell, opt?: S): void;
 
@@ -975,9 +1131,7 @@ export declare namespace dia {
             deep?: T;
         }
 
-        export interface DisconnectableOptions extends Options {
-            disconnectLinks?: boolean;
-        }
+        export type DisconnectableOptions = Graph.RemoveCellOptions;
 
         export interface GetEmbeddedCellsOptions extends EmbeddableOptions {
             breadthFirst?: boolean;
@@ -1057,9 +1211,9 @@ export declare namespace dia {
 
         protected generateId(): string | number;
 
-        protected stopPendingTransitions(path?: string, delim?: string): void;
+        protected stopPendingTransitions(path?: Path, delim?: string): void;
 
-        protected stopScheduledTransitions(path?: string, delim?: string): void;
+        protected stopScheduledTransitions(path?: Path, delim?: string): void;
 
         toJSON(opt?: dia.Cell.ExportOptions): Cell.JSON<any, A>;
 
@@ -1097,11 +1251,11 @@ export declare namespace dia {
 
         removeAttr(path: Path, opt?: Cell.Options): this;
 
-        transition(path: string, value?: any, opt?: Cell.TransitionOptions, delim?: string): number;
+        transition(path: Path, value?: any, opt?: Cell.TransitionOptions, delim?: string): number;
 
         getTransitions(): string[];
 
-        stopTransitions(path?: string, delim?: string): this;
+        stopTransitions(path?: Path, delim?: string): this;
 
         embed(cell: Cell | Cell[], opt?: Cell.EmbedOptions): this;
 
@@ -1125,6 +1279,9 @@ export declare namespace dia {
 
         z(): number;
 
+        layer(): string | null;
+        layer(id: string | null, opt?: Graph.Options): this;
+
         angle(): number;
 
         getBBox(): g.Rect;
@@ -1146,6 +1303,8 @@ export declare namespace dia {
 
         static define(type: string, defaults?: any, protoProps?: any, staticProps?: any): Cell.Constructor<Cell>;
 
+        static getAttributeDefinition(attrName: string): Cell.PresentationAttributeDefinition<CellView> | null;
+
         /**
          * @deprecated
          */
@@ -1170,24 +1329,40 @@ export declare namespace dia {
         export interface Attributes extends GenericAttributes<Cell.Selectors> {
         }
 
-        export type PortPositionCallback = (ports: Port[], bbox: g.Rect) => dia.Point[];
+        export interface ConstructorOptions extends Cell.ConstructorOptions {
+            portLayoutNamespace?: { [key: string]: layout.Port.LayoutFunction };
+            portLabelLayoutNamespace?: { [key: string]: layout.PortLabel.LayoutFunction };
+        }
+
+        export type PortPositionCallback = layout.Port.LayoutFunction;
+
+        export type PortLabelPositionCallback = layout.PortLabel.LayoutFunction;
 
         export interface PortPositionJSON {
             name?: string;
-            args?: { [key: string]: any };
+            args?: layout.Port.Options;
+        }
+
+        export interface PortLabelPositionJSON {
+            name?: string;
+            args?: layout.PortLabel.Options;
         }
 
         export type PositionType = string | PortPositionCallback | PortPositionJSON;
 
+        export type PortLabelPositionType = PortLabelPositionCallback | PortPositionJSON;
+
         export interface PortGroup {
             position?: PositionType;
             markup?: string | MarkupJSON;
             attrs?: Cell.Selectors;
             size?: Size;
-            label?: {
-                markup?: string | MarkupJSON;
-                position?: PositionType;
-            };
+            label?: PortLabel;
+        }
+
+        export interface PortLabel {
+            markup?: string | MarkupJSON;
+            position?: PortLabelPositionType;
         }
 
         export interface Port {
@@ -1196,14 +1371,12 @@ export declare namespace dia {
             group?: string;
             attrs?: Cell.Selectors;
             position?: {
-                args?: { [key: string]: any };
+                args?: layout.Port.Options;
             };
-            args?: { [key: string]: any };
+            /** @deprecated use `position.args` instead */
+            args?: layout.Port.Options;
             size?: Size;
-            label?: {
-                markup?: string | MarkupJSON;
-                position?: PositionType;
-            };
+            label?: PortLabel;
             z?: number | 'auto';
         }
 
@@ -1233,13 +1406,13 @@ export declare namespace dia {
             filter?: (cell: Cell) => boolean;
             deep?: boolean;
             padding?: Padding;
-            minRect?: g.Rect;
+            minRect?: Partial<BBox>;
             expandOnly?: boolean;
             shrinkOnly?: boolean;
         }
 
         export interface FitParentOptions extends FitToChildrenOptions {
-            terminator?: Cell | Cell.ID;
+            terminator?: Graph.CellRef;
         }
 
         export interface RotateOptions {
@@ -1253,6 +1426,8 @@ export declare namespace dia {
 
     export 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;
@@ -1964,44 +2139,105 @@ export declare namespace dia {
         }
 
         export enum Layers {
-            CELLS = 'cells',
             LABELS = 'labels',
             BACK = 'back',
             FRONT = 'front',
+            /** @deprecated */
+            CELLS = 'cells',
             TOOLS = 'tools',
             GRID = 'grid',
         }
 
-        export type UpdateStats = {
+        export type LayerRef = Layers | string | dia.LayerView | dia.GraphLayer;
+
+        export interface RenderStats {
             priority: number;
             updated: number;
-            empty?: boolean;
-            postponed?: number;
-            unmounted?: number;
-            mounted?: number;
+        }
+
+        export interface UpdateVisibilityStats {
+            mounted: number;
+            unmounted: number;
+        }
+
+        export interface RenderBatchStats extends RenderStats, UpdateVisibilityStats {
+            postponed: number;
+            empty: boolean;
+        }
+
+        export type UpdateStats = RenderStats & Partial<RenderBatchStats> & {
             batches?: number;
         };
 
         export type ViewportCallback = (view: mvc.View<any, any>, isMounted: boolean, paper: Paper) => boolean;
+        export type CellVisibilityCallback = (cell: Cell, isMounted: boolean, paper: Paper) => boolean;
         export type ProgressCallback = (done: boolean, processed: number, total: number, stats: UpdateStats, paper: Paper) => void;
         export type BeforeRenderCallback = (opt: { [key: string]: any }, paper: Paper) => void;
         export type AfterRenderCallback = (stats: UpdateStats, opt: { [key: string]: any }, paper: Paper) => void;
 
-        export interface FreezeOptions {
-            key?: string;
+        export interface CellVisibilityOptions {
+            cellVisibility?: CellVisibilityCallback | null;
+
+            /** @deprecated disable `legacyMode` and use `cellVisibility` instead */
+            viewport?: ViewportCallback | null;
         }
 
-        export interface UnfreezeOptions {
-            key?: string;
+        export interface MountOptions {
             mountBatchSize?: number;
+        }
+
+        export interface UnmountOptions {
             unmountBatchSize?: number;
+        }
+
+        export interface BatchSizeOptions {
             batchSize?: number;
-            viewport?: ViewportCallback;
-            progress?: ProgressCallback;
+        }
+
+        export interface BeforeRenderOptions {
             beforeRender?: BeforeRenderCallback;
+        }
+
+        export interface AfterRenderOptions {
             afterRender?: AfterRenderCallback;
         }
 
+        export interface RenderCallbackOptions extends BeforeRenderOptions, AfterRenderOptions, mvc.Silenceable {
+
+        }
+
+        export interface KeyOptions {
+            key?: string;
+        }
+
+        export interface UpdateViewOptions {
+            [key: string]: any;
+        }
+
+        export interface UpdateViewsBatchOptions extends UpdateViewOptions, BatchSizeOptions, CellVisibilityOptions {
+
+        }
+
+        export interface UpdateViewsOptions extends UpdateViewsBatchOptions, RenderCallbackOptions {
+
+        }
+
+        export interface UpdateViewsAsyncOptions extends UpdateViewsBatchOptions, ScheduleCellsVisibilityUpdateOptions, RenderCallbackOptions {
+            progress?: ProgressCallback;
+        }
+
+        export interface ScheduleCellsVisibilityUpdateOptions extends CellVisibilityOptions, MountOptions, UnmountOptions {
+
+        }
+
+        export interface FreezeOptions extends KeyOptions {
+
+        }
+
+        export interface UnfreezeOptions extends KeyOptions, UpdateViewsAsyncOptions, UpdateViewsOptions {
+
+        }
+
         export interface SnapLinksOptions {
             radius?: number;
             findInAreaOptions?: FindInAreaOptions;
@@ -2013,7 +2249,7 @@ export declare namespace dia {
         export type FindParentByCallback = ((this: dia.Graph, elementView: ElementView, evt: dia.Event, x: number, y: number) => Cell[]);
         export type MeasureNodeCallback = (node: SVGGraphicsElement, cellView: dia.CellView) => g.Rect;
 
-        export interface Options extends mvc.ViewOptions<Graph> {
+        export interface Options extends mvc.ViewOptions<Graph>, CellVisibilityOptions, BeforeRenderOptions, AfterRenderOptions {
             // appearance
             width?: Dimension;
             height?: Dimension;
@@ -2056,6 +2292,7 @@ export declare namespace dia {
             validateUnembedding?: (this: Paper, childView: ElementView) => boolean;
             // default views, models & attributes
             cellViewNamespace?: any;
+            layerViewNamespace?: any;
             routerNamespace?: any;
             connectorNamespace?: any;
             highlighterNamespace?: any;
@@ -2075,14 +2312,17 @@ export declare 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;
         }
 
+        export interface ViewManagementOptions {
+            lazyInitialize?: boolean;
+            disposeHidden?: boolean;
+        }
+
         export interface TransformToFitContentOptions {
             padding?: Padding;
             preserveAspectRatio?: boolean;
@@ -2215,6 +2455,22 @@ export declare namespace dia {
 
         export interface FindInAreaOptions extends Graph.FindInAreaOptions, BufferOptions {
         }
+
+        export interface FindClosestMagnetToPointOptions {
+            radius?: number;
+            findInAreaOptions?: FindInAreaOptions;
+            filter?: (view: CellView, magnet: SVGElement) => boolean;
+        }
+
+        export interface ClosestMagnet {
+            view: CellView;
+            magnet: SVGElement;
+        }
+
+        export interface InsertLayerViewOptions {
+            before?: LayerRef | null;
+            index?: number;
+        }
     }
 
     export class Paper extends mvc.View<Graph> {
@@ -2227,10 +2483,14 @@ export declare namespace dia {
 
         svg: SVGSVGElement;
         defs: SVGDefsElement;
+
+        /** @deprecated use getLayerViewNode()*/
         cells: SVGGElement;
+        /** @deprecated use layers property*/
+        viewport: SVGGElement;
+
         tools: SVGGElement;
         layers: SVGGElement;
-        viewport: SVGGElement;
 
         GUARDED_TAG_NAMES: string[];
         FORM_CONTROLS_TAG_NAMES: string[];
@@ -2306,7 +2566,7 @@ export declare namespace dia {
 
         findView<T extends ElementView | LinkView>(element: mvc.$SVGElement): T;
 
-        findViewByModel<T extends ElementView | LinkView>(model: Cell | Cell.ID): T;
+        findViewByModel<T extends ElementView | LinkView>(model: Graph.CellRef): T;
 
         /**
          * Finds all the element views at the specified point
@@ -2350,6 +2610,13 @@ export declare 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;
 
@@ -2361,7 +2628,7 @@ export declare namespace dia {
 
         getDefaultLink(cellView: CellView, magnet: SVGElement): Link;
 
-        getModelById(id: Cell.ID | Cell): Cell;
+        getModelById(id: Graph.CellRef): Cell;
 
         setDimensions(width: Paper.Dimension, height: Paper.Dimension, data?: any): void;
 
@@ -2397,29 +2664,38 @@ export declare namespace dia {
 
         // layers
 
-        getLayerNode(layerName: Paper.Layers | string): SVGGElement;
+        getLayerView(layerRef: Paper.LayerRef): LayerView;
+        getLayerView(layer: GraphLayer): GraphLayerView;
+
+        hasLayerView(layerRef: Paper.LayerRef): boolean;
+
+        getLayerViews(): Array<LayerView>;
+
+        getGraphLayerViews(): Array<GraphLayerView>;
+
+        addLayerView(layerView: LayerView, options?: Paper.InsertLayerViewOptions): void;
 
-        getLayerView(layerName: Paper.Layers | string): PaperLayer;
+        moveLayerView(layerRef: Paper.LayerRef, options?: Paper.InsertLayerViewOptions): void;
 
-        hasLayerView(layerName: Paper.Layers | string): boolean;
+        removeLayerView(layerRef: Paper.LayerRef): void;
 
-        renderLayers(layers: Array<{ name: string }>): void;
+        protected insertLayerView(layerView: LayerView, before?: Paper.LayerRef): void;
 
-        protected removeLayers(): void;
+        protected requestLayerViewRemoval(layerRef: Paper.LayerRef): void;
 
-        protected resetLayers(): void;
+        protected createLayerView(options: Omit<LayerView.Options, 'paper'>): LayerView;
 
-        addLayer(layerName: string, layerView: PaperLayer, options?: { insertBefore?: string }): void;
+        protected getLayerViewOrder(): string[];
 
-        removeLayer(layer: string | PaperLayer): void;
+        protected renderLayerViews(): void;
 
-        moveLayer(layer: string | PaperLayer, insertBefore: string | PaperLayer | null): void;
+        protected renderImplicitLayerViews(): void;
 
-        hasLayer(layer: string | PaperLayer): boolean;
+        protected renderGraphLayerViews(): void;
 
-        getLayerNames(): string[];
+        protected removeLayerViews(): void;
 
-        getLayers(): Array<PaperLayer>;
+        protected resetLayerViews(): void;
 
         // rendering
 
@@ -2427,39 +2703,33 @@ export declare namespace dia {
 
         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;
-
-        dumpViews(opt?: {
-            batchSize?: number;
-            mountBatchSize?: number;
-            unmountBatchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): void;
+        requestCellViewInsertion(cell: Graph.CellRef, opt?: { [key: string]: any }): void;
 
-        checkViewport(opt?: {
-            mountBatchSize?: number;
-            unmountBatchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): {
-            mounted: number;
-            unmounted: number;
-        };
+        requireView<T extends ElementView | LinkView>(cellOrId: Graph.CellRef, opt?: Paper.UpdateViewOptions & Paper.RenderCallbackOptions): T;
 
-        updateViews(opt?: {
-            batchSize?: number;
-            viewport?: Paper.ViewportCallback;
-        }): {
-            updated: number;
-            batches: number;
-            priority: number;
-        };
+        updateViews(opt?: Paper.UpdateViewsOptions): Paper.RenderStats & { batches: number };
 
         hasScheduledUpdates(): boolean;
 
+        disposeHiddenCellViews(): void;
+
+        isCellVisible(cellOrId: Graph.CellRef): boolean;
+
+        updateCellVisibility(
+        cell: Graph.CellRef,
+        opt?: Paper.CellVisibilityOptions & Paper.UpdateViewOptions & Paper.RenderCallbackOptions
+        ): void;
+
+        updateCellsVisibility(
+        opt?: Paper.ScheduleCellsVisibilityUpdateOptions & Paper.UpdateViewsOptions
+        ): void;
+
         // events
 
         on<T extends keyof Paper.EventMap = keyof Paper.EventMap>(eventName: T, callback: Paper.EventMap[T], context?: any): this;
@@ -2469,52 +2739,51 @@ export declare 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: Graph.CellRef): boolean;
 
-        protected checkUnmountedViews(viewport: Paper.ViewportCallback, opt?: { mountBatchSize?: number }): number;
+        protected prioritizeCellViewUnmount(cellOrId: Graph.CellRef): boolean;
+
+        protected isViewMounted(viewOrCid: dia.CellView | string): boolean;
 
         protected isAsync(): boolean;
 
+        protected isIdle(): boolean;
+
         protected isExactSorting(): boolean;
 
         protected sortViews(): void;
@@ -2568,6 +2837,14 @@ export declare namespace dia {
         protected onCellChanged(cell: Cell, opt: dia.Cell.Options): void;
         protected onCellChanged(cell: mvc.Collection<Cell>, opt: dia.Graph.Options): void;
 
+        protected onGraphLayerAdd(layer: GraphLayer, collection: mvc.Collection<GraphLayer>, opt: dia.Graph.Options): void;
+
+        protected onGraphLayerRemove(layer: GraphLayer, collection: mvc.Collection<GraphLayer>, opt: dia.Graph.Options): void;
+
+        protected onGraphLayerCollectionReset(layer: mvc.Collection<GraphLayer>, opt: dia.Graph.Options): void;
+
+        protected onGraphLayerCollectionSort(layer: GraphLayer[]): void;
+
         protected onGraphReset(cells: mvc.Collection<Cell>, opt: dia.Graph.Options): void;
 
         protected onGraphSort(): void;
@@ -2590,12 +2867,19 @@ export declare 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;
 
         protected addStylesheet(stylesheet: string): void;
 
+        /**
+         * @deprecated use `getLayerView(id).el` instead
+         * **/
+        getLayerNode(id: Paper.Layers | string): SVGElement;
+
         /**
          * @deprecated use `findElementViewsAtPoint()
          */
@@ -2610,19 +2894,32 @@ export declare 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;
     }
 
-    export namespace PaperLayer {
+    export namespace LayerView {
 
-        export interface Options extends mvc.ViewOptions<undefined, SVGElement> {
-            name: string;
+        export interface Options<T extends mvc.Model | undefined = undefined> extends mvc.ViewOptions<T, SVGElement> {
+            id: string;
+            paper: Paper;
+            type?: string;
         }
     }
-    export class PaperLayer extends mvc.View<undefined, SVGElement> {
 
-        constructor(opt?: PaperLayer.Options);
+    export class LayerView<T extends mvc.Model | undefined = undefined> extends mvc.View<T, SVGElement> {
 
-        options: PaperLayer.Options;
+        constructor(opt?: LayerView.Options);
+
+        options: LayerView.Options;
 
         pivotNodes: { [z: number]: Comment };
 
@@ -2632,7 +2929,78 @@ export declare namespace dia {
 
         insertPivot(z: number): Comment;
 
-        removePivots(): void;
+        isEmpty(): boolean;
+
+        reset(): void;
+
+        setPaperReference(paper: Paper): void;
+
+        unsetPaperReference(): void;
+
+        protected removePivots(): void;
+
+        protected afterPaperReferenceSet(paper: Paper): void;
+
+        protected beforePaperReferenceUnset(paper: Paper): void;
+
+        protected assertPaperReferenceSet(): void;
+    }
+
+    export namespace GraphLayer {
+
+        export type ID = string;
+
+        export interface Attributes extends mvc.ObjectHash {
+            id: ID;
+            type?: string;
+        }
+    }
+
+    export class GraphLayer<C extends CellCollection = CellCollection, A extends GraphLayer.Attributes = GraphLayer.Attributes, S extends mvc.ModelSetOptions = dia.ModelSetOptions> extends mvc.Model<A, S> {
+
+        id: string;
+
+        cellCollection: C;
+        graph: Graph | null;
+
+        constructor(attributes?: DeepPartial<A>, options?: mvc.ModelConstructorOptions<GraphLayer>);
+
+        getCells(): Cell[];
+    }
+
+    export class GraphLayerView<T extends GraphLayer = GraphLayer> extends LayerView<T> {
+
+        sort(): void;
+
+        sortExact(): void;
+
+        insertCellView(cellView: CellView): void;
+
+        protected onCellMove(cell: Cell, opt: Graph.Options): void;
+
+        protected onCellChange(cell: Cell, opt: Cell.Options): void;
+
+        protected onCellCollectionSort(collection: CellCollection, opt: Graph.Options): void;
+
+        protected onGraphBatchStop(data: any): void;
+    }
+
+    export namespace GridLayerView {
+
+        export interface Options extends LayerView.Options {
+            patterns?: Record<string, Paper.GridOptions[]>;
+        }
+    }
+
+    export class GridLayerView extends LayerView {
+
+        setGrid(opt?: null | boolean | string | Paper.GridOptions | Paper.GridOptions[]): void;
+
+        renderGrid(): void;
+
+        updateGrid(): void;
+
+        removeGrid(): void;
     }
 
     export namespace ToolsView {
@@ -2668,6 +3036,10 @@ export declare namespace dia {
         hide(): this;
 
         mount(): this;
+
+        getLayer(): string | null;
+
+        hasLayer(): boolean;
     }
 
     export namespace ToolView {
@@ -2711,6 +3083,8 @@ export declare namespace dia {
 
         update(): void;
 
+        isOverlay(): boolean;
+
         protected guard(evt: dia.Event): boolean;
     }
 
@@ -2802,6 +3176,8 @@ export declare 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;
@@ -2879,7 +3255,7 @@ export declare namespace elementTools {
 
     export namespace Boundary {
         export interface Options extends dia.ToolView.Options<dia.ElementView> {
-            padding?: number | dia.Sides;
+            padding?: dia.Sides;
             useModelGeometry?: boolean;
             rotate?: boolean;
         }
@@ -2957,12 +3333,16 @@ export declare namespace g {
     }
 
     export type Shape = Path | Point | Line | Polyline | Polygon | Rect | Ellipse;
+
     export interface PlainPoint {
 
         x: number;
         y: number;
     }
 
+    /** Can be understood by `g.Point` constructor */
+    export type PointInit = Partial<PlainPoint> | string;
+
     export interface PlainRect {
 
         x: number;
@@ -3022,15 +3402,15 @@ export declare namespace g {
 
         clone(): Segment;
 
-        closestPoint(p: Point, opt?: SubdivisionsOpt): Point;
+        closestPoint(p: PlainPoint, opt?: SubdivisionsOpt): Point;
 
-        closestPointLength(p: Point, opt?: SubdivisionsOpt): number;
+        closestPointLength(p: PlainPoint, opt?: SubdivisionsOpt): number;
 
-        closestPointNormalizedLength(p: Point, opt?: SubdivisionsOpt): number;
+        closestPointNormalizedLength(p: PlainPoint, opt?: SubdivisionsOpt): number;
 
-        closestPointT(p: Point): number;
+        closestPointT(p: PlainPoint): number;
 
-        closestPointTangent(p: Point): Line | null;
+        closestPointTangent(p: PlainPoint): Line | null;
 
         divideAt(ratio: number, opt?: SubdivisionsOpt): [Segment, Segment];
 
@@ -3056,7 +3436,7 @@ export declare namespace g {
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         tangentAt(ratio: number): Line | null;
 
@@ -3113,7 +3493,7 @@ export declare namespace g {
         end: Point;
         type: types.Curve;
 
-        constructor(p1: PlainPoint | string, p2: PlainPoint | string, p3: PlainPoint | string, p4: PlainPoint | string);
+        constructor(p1: PointInit, p2: PointInit, p3: PointInit, p4: PointInit);
         constructor(curve: Curve);
 
         bbox(): Rect;
@@ -3161,7 +3541,7 @@ export declare namespace g {
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint | string): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         tangentAt(ratio: number, opt?: SubdivisionsOpt): Line | null;
 
@@ -3193,7 +3573,7 @@ export declare namespace g {
         b: number;
         type: types.Ellipse;
 
-        constructor(center: PlainPoint | string, a: number, b: number);
+        constructor(center: PointInit, a: number, b: number);
         constructor(ellipse: Ellipse);
 
         bbox(): Rect;
@@ -3210,7 +3590,7 @@ export declare namespace g {
 
         intersectionWithLine(l: Line): Point[] | null;
 
-        intersectionWithLineFromCenterToPoint(p: PlainPoint, angle?: number): Point;
+        intersectionWithLineFromCenterToPoint(p: PointInit, angle?: number): Point;
 
         normalizedDistance(point: PlainPoint): number;
 
@@ -3229,7 +3609,7 @@ export declare namespace g {
         end: Point;
         type: types.Line;
 
-        constructor(p1: PlainPoint | string, p2: PlainPoint | string);
+        constructor(p1: PointInit, p2: PointInit);
         constructor(line: Line);
         constructor();
 
@@ -3243,13 +3623,13 @@ export declare namespace g {
 
         parallel(distance: number): Line;
 
-        closestPoint(p: PlainPoint | string): Point;
+        closestPoint(p: PointInit): Point;
 
-        closestPointLength(p: PlainPoint | string): number;
+        closestPointLength(p: PointInit): number;
 
-        closestPointNormalizedLength(p: PlainPoint | string): number;
+        closestPointNormalizedLength(p: PointInit): number;
 
-        closestPointTangent(p: PlainPoint | string): Line | null;
+        closestPointTangent(p: PointInit): Line | null;
 
         containsPoint(p: PlainPoint): boolean;
 
@@ -3277,13 +3657,13 @@ export declare namespace g {
 
         pointAtLength(length: number): Point;
 
-        pointOffset(p: PlainPoint | string): number;
+        pointOffset(p: PointInit): number;
 
         rotate(origin: PlainPoint, angle: number): this;
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         setLength(length: number): this;
 
@@ -3322,13 +3702,13 @@ export declare namespace g {
 
         clone(): Path;
 
-        closestPoint(p: Point, opt?: SegmentSubdivisionsOpt): Point | null;
+        closestPoint(p: PlainPoint, opt?: SegmentSubdivisionsOpt): Point | null;
 
-        closestPointLength(p: Point, opt?: SegmentSubdivisionsOpt): number;
+        closestPointLength(p: PlainPoint, opt?: SegmentSubdivisionsOpt): number;
 
-        closestPointNormalizedLength(p: Point, opt?: SegmentSubdivisionsOpt): number;
+        closestPointNormalizedLength(p: PlainPoint, opt?: SegmentSubdivisionsOpt): number;
 
-        closestPointTangent(p: Point, opt?: SegmentSubdivisionsOpt): Line | null;
+        closestPointTangent(p: PlainPoint, opt?: SegmentSubdivisionsOpt): Line | null;
 
         containsPoint(p: PlainPoint, opt?: SegmentSubdivisionsOpt): boolean;
 
@@ -3364,7 +3744,7 @@ export declare namespace g {
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint | string): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         segmentAt(ratio: number, opt?: SegmentSubdivisionsOpt): Segment | null;
 
@@ -3391,7 +3771,7 @@ export declare namespace g {
 
         validate(): this;
 
-        private closestPointT(p: Point, opt?: SegmentSubdivisionsOpt): PathT | null;
+        private closestPointT(p: PlainPoint, opt?: SegmentSubdivisionsOpt): PathT | null;
 
         private lengthAtT(t: PathT, opt?: SegmentSubdivisionsOpt): number;
 
@@ -3419,17 +3799,17 @@ export declare namespace g {
         type: types.Point;
 
         constructor(x?: number, y?: number);
-        constructor(p: PlainPoint | string);
+        constructor(p: PointInit);
 
-        chooseClosest(points: PlainPoint[]): Point | null;
+        chooseClosest(points: PointInit[]): Point | null;
 
         adhereToRect(r: Rect): this;
 
         angleBetween(p1: PlainPoint, p2: PlainPoint): number;
 
-        bearing(p: Point): CardinalDirection;
+        bearing(p: PlainPoint): CardinalDirection;
 
-        changeInAngle(dx: number, dy: number, ref: PlainPoint | string): number;
+        changeInAngle(dx: number, dy: number, ref: PointInit): number;
 
         clone(): Point;
 
@@ -3438,42 +3818,42 @@ export declare namespace g {
         difference(dx?: number, dy?: number): Point;
         difference(p: PlainPoint): Point;
 
-        distance(p: PlainPoint | string): number;
+        distance(p: PlainPoint): number;
 
         dot(p: PlainPoint): number;
 
-        equals(p: Point): boolean;
+        equals(p: PlainPoint): boolean;
 
-        lerp(p: Point, t: number): Point;
+        lerp(p: PlainPoint, t: number): Point;
 
         magnitude(): number;
 
         manhattanDistance(p: PlainPoint): number;
 
-        move(ref: PlainPoint | string, distance: number): this;
+        move(ref: PointInit, distance: number): this;
 
         normalize(length: number): this;
 
         offset(dx?: number, dy?: number): this;
         offset(p: PlainPoint): this;
 
-        reflection(ref: PlainPoint | string): Point;
+        reflection(ref: PointInit): Point;
 
-        rotate(origin: PlainPoint | string, angle: number): this;
+        rotate(origin: PlainPoint, angle: number): this;
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint | string): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         snapToGrid(gx: number, gy?: number): this;
 
-        squaredDistance(p: PlainPoint | string): number;
+        squaredDistance(p: PlainPoint): number;
 
-        theta(p: PlainPoint | string): number;
+        theta(p: PointInit): number;
 
         toJSON(): PlainPoint;
 
-        toPolar(origin?: PlainPoint | string): this;
+        toPolar(origin?: PointInit): this;
 
         toString(): string;
 
@@ -3487,7 +3867,7 @@ export declare namespace g {
 
         vectorAngle(p: PlainPoint): number;
 
-        static fromPolar(distance: number, angle: number, origin?: PlainPoint | string): Point;
+        static fromPolar(distance: number, angle: number, origin?: PointInit): Point;
 
         static random(x1: number, x2: number, y1: number, y2: number): Point;
     }
@@ -3499,17 +3879,17 @@ export declare namespace g {
 
         constructor();
         constructor(svgString: string);
-        constructor(points: PlainPoint[]);
+        constructor(points: PointInit[]);
 
         bbox(): Rect | null;
 
-        closestPoint(p: PlainPoint | string): Point | null;
+        closestPoint(p: PlainPoint): Point | null;
 
-        closestPointLength(p: PlainPoint | string): number;
+        closestPointLength(p: PlainPoint): number;
 
-        closestPointNormalizedLength(p: PlainPoint | string): number;
+        closestPointNormalizedLength(p: PlainPoint): number;
 
-        closestPointTangent(p: PlainPoint | string): Line | null;
+        closestPointTangent(p: PlainPoint): Line | null;
 
         containsPoint(p: PlainPoint): boolean;
 
@@ -3529,7 +3909,7 @@ export declare namespace g {
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint | string): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
         simplify(opt?: { threshold?: number }): this;
 
@@ -3594,7 +3974,7 @@ export declare namespace g {
 
         clone(): Rect;
 
-        containsPoint(p: PlainPoint | string, opt?: StrictOpt): boolean;
+        containsPoint(p: PointInit, opt?: StrictOpt): boolean;
 
         containsRect(r: PlainRect): boolean;
 
@@ -3608,7 +3988,7 @@ export declare namespace g {
 
         intersectionWithLine(l: Line): Point[] | null;
 
-        intersectionWithLineFromCenterToPoint(p: PlainPoint | string, angle?: number): Point;
+        intersectionWithLineFromCenterToPoint(p: PointInit, angle?: number): Point;
 
         leftLine(): Line;
 
@@ -3620,7 +4000,7 @@ export declare namespace g {
 
         moveAndExpand(r: PlainRect): this;
 
-        moveAroundPoint(origin: PlainPoint | string, angle: number): this;
+        moveAroundPoint(origin: PlainPoint, angle: number): this;
 
         normalize(): this;
 
@@ -3629,7 +4009,7 @@ export declare namespace g {
 
         origin(): Point;
 
-        pointNearestToPoint(point: PlainPoint | string): Point;
+        pointNearestToPoint(point: PointInit): Point;
 
         rightLine(): Line;
 
@@ -3637,9 +4017,9 @@ export declare namespace g {
 
         round(precision?: number): this;
 
-        scale(sx: number, sy: number, origin?: PlainPoint | string): this;
+        scale(sx: number, sy: number, origin?: PointInit): this;
 
-        sideNearestToPoint(point: PlainPoint | string): RectangleSide;
+        sideNearestToPoint(point: PointInit): RectangleSide;
 
         snapToGrid(gx: number, gy?: number): this;
 
@@ -3679,24 +4059,24 @@ export declare namespace g {
             p3: Point;
         }
 
-        export function curveThroughPoints(points: PlainPoint[] | Point[]): string[];
+        export function curveThroughPoints(points: PlainPoint[]): string[];
 
-        export function getCurveControlPoints(points: PlainPoint[] | Point[]): [Point[], Point[]];
+        export function getCurveControlPoints(points: PlainPoint[]): [Point[], Point[]];
 
         export function getCurveDivider(
-        p0: string | PlainPoint,
-        p1: string | PlainPoint,
-        p2: string | PlainPoint,
-        p3: string | PlainPoint
+        p0: PointInit,
+        p1: PointInit,
+        p2: PointInit,
+        p3: PointInit
         ): (t: number) => [IBezierCurve, IBezierCurve];
 
         export function getFirstControlPoints(rhs: number[]): number[];
 
         export function getInversionSolver(
-        p0: PlainPoint,
-        p1: PlainPoint,
-        p2: PlainPoint,
-        p3: PlainPoint
+        p0: PointInit,
+        p1: PointInit,
+        p2: PointInit,
+        p3: PointInit
         ): (p: PlainPoint) => number;
     }
 
@@ -3882,7 +4262,7 @@ export declare namespace highlighters {
             position?: Positions | dia.PositionName;
             size?: number | dia.Size;
             gap?: number;
-            margin?: number | dia.Sides;
+            margin?: dia.Sides;
         }
     }
 
@@ -3931,7 +4311,7 @@ export declare namespace layout {
             angle: number;
         };
 
-        export type LayoutFunction = (ports: Array<Object>, elBBox: g.Rect, opt: Options) => Array<Transformation>;
+        export type LayoutFunction = (ports: Array<dia.Element.Port>, elBBox: g.Rect, opt: Options) => Array<Transformation>;
 
         export interface Options {
             x?: number | string;
@@ -3944,9 +4324,11 @@ export declare namespace layout {
             startAngle?: number;
             step?: number;
             compensateRotation?: boolean;
+            [key: string]: any;
         }
 
         var absolute: LayoutFunction;
+        /** @deprecated */
         var fn: LayoutFunction;
         var line: LayoutFunction;
         var left: LayoutFunction;
@@ -3965,6 +4347,7 @@ export declare namespace layout {
             angle?: number;
             offset?: number;
             attrs?: dia.Cell.Selectors;
+            [key: string]: any;
         }
 
         export interface LabelAttributes {
@@ -4201,7 +4584,7 @@ export declare namespace linkTools {
 
     export namespace Boundary {
         export interface Options extends dia.ToolView.Options<dia.LinkView> {
-            padding?: number | dia.Sides;
+            padding?: dia.Sides;
             useModelGeometry?: boolean;
         }
     }
@@ -4411,6 +4794,7 @@ export declare namespace mvc {
 
     export interface ModelConstructorOptions<TModel extends Model = Model> extends ModelSetOptions, Parseable {
         collection?: Collection<TModel> | undefined;
+        eventPrefix?: string | undefined;
     }
 
     export type CombinedModelConstructorOptions<E, M extends Model<any, any, E> = Model> = ModelConstructorOptions<M> & E;
@@ -4699,6 +5083,7 @@ export declare 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;
@@ -4741,9 +5126,9 @@ export declare 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;
@@ -5555,6 +5940,8 @@ export declare namespace util {
 
     export function merge(destinationObject: object, ...args: any[]): object;
 
+    export 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;
@@ -5606,6 +5993,7 @@ export declare namespace Vectorizer {
         annotations?: TextAnnotation[];
         includeAnnotationIndices?: boolean;
         displayEmpty?: boolean;
+        useNoBreakSpace?: boolean;
     }
 
     export interface GetBBoxOptions {
@@ -5627,6 +6015,10 @@ export declare namespace Vectorizer {
         attrs: { [key: string]: any };
     }
 
+    export interface TransformToElementOptions {
+        safe?: boolean;
+    }
+
     // modifiable Matrix. SVGMatrix doesn't allow set on properties or a constructor.
     export interface Matrix {
         a: number;
@@ -5696,7 +6088,7 @@ export declare class VElement {
     id: string;
     node: SVGElement;
 
-    getTransformToElement(toElem: SVGGElement | VElement): SVGMatrix;
+    getTransformToElement(target: SVGElement | VElement, opt?: Vectorizer.TransformToElementOptions): SVGMatrix;
 
     transform(): SVGMatrix;
     transform(matrix: SVGMatrix | Vectorizer.Matrix, opt?: Vectorizer.TransformOptions): this;
@@ -5805,6 +6197,9 @@ declare interface VStatic {
 
     ensureId(node: SVGElement | VElement): string;
 
+    /**
+     * @deprecated Use regular spaces and rely on xml:space="preserve" instead.
+     */
     sanitizeText(text: string): string;
 
     isUndefined(value: any): boolean;
@@ -5819,6 +6214,8 @@ declare interface VStatic {
 
     qualifyAttr(name: string): Vectorizer.QualifiedAttribute;
 
+    getCommonAncestor(node1: SVGElement | VElement, node2: SVGElement | VElement): SVGElement | null;
+
     transformStringToMatrix(transform: string): SVGMatrix;
 
     matrixToTransformString(matrix: SVGMatrix | Vectorizer.Matrix): string;