@visuallyjs/browser-ui-angular 1.0.0

package/lib/controls-component.d.ts

@@ -0,0 +1,71 @@
+import { ChangeDetectorRef, ElementRef, OnInit } from "@angular/core";
+import { ControlsComponentButtons, BrowserElement, BrowserUI } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * This component was written for the Visually JS demonstration applications. We've included it in the Toolkit's
+ * angular integration as it may provide a useful base on which to build your own. Out of the box this is "production ready",
+ * but it does assume that either you're including the `visuallyjs.css` stylesheet in your cascade,
+ * or you've pulled out the relevant styles from that stylesheet. Also note that the default prompt for users when they
+ * press the 'clear' button is in English, as are the button tooltips.
+ * @group Components
+ */
+export declare class ControlsComponent implements OnInit {
+    /**
+     * Whether or not to show undo/redo buttons. Defaults to true.
+     * @input
+     */
+    undoRedo?: boolean;
+    /**
+     * Whether or not to show the zoom to extents button. Defaults to true.
+     * @input
+     */
+    zoomToExtents?: boolean;
+    /**
+     * Whether or not to show the zoom in/zoom out buttons. Defaults to false.
+     * @input
+     */
+    zoomButtons?: boolean;
+    /**
+     * Whether or not to show the clear model button. Defaults to true.
+     * @input
+     */
+    clear?: boolean;
+    /**
+     * Message to show when the user clicks the clear model button.
+     * @input
+     */
+    clearMessage?: string;
+    /**
+     * Optional extra buttons to display in the component.
+     * @input
+     */
+    buttons?: ControlsComponentButtons;
+    /**
+     * Orientation of the component - `"row"` or `"column"`
+     * @input
+     */
+    orientation?: string;
+    modeButtons: ControlsComponentButtons;
+    otherButtons: ControlsComponentButtons;
+    ui: BrowserUI;
+    showPanButton: boolean;
+    showLassoButton: boolean;
+    $vjs: VisuallyJsService;
+    $el: ElementRef<any>;
+    $cdr: ChangeDetectorRef;
+    updateSelectionState(): void;
+    ngOnInit(): void;
+    getNativeElement(component: any): BrowserElement;
+    panMode(): void;
+    selectMode(): void;
+    zoomToFit(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetSelection(): void;
+    undo(): void;
+    redo(): void;
+    doClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ControlsComponent, "vjs-controls", never, { "undoRedo": { "alias": "undoRedo"; "required": false; }; "zoomToExtents": { "alias": "zoomToExtents"; "required": false; }; "zoomButtons": { "alias": "zoomButtons"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "clearMessage": { "alias": "clearMessage"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/decorator-component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, OnDestroy } from "@angular/core";
+import { PointXY, FixedElementConstraints } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+export declare class DecoratorComponent implements AfterViewInit, OnDestroy {
+    /**
+     * Whether to float the element over the UI (floating) or place it on the canvas (fixed). Floating is the default.
+     */
+    placement: 'fixed' | 'floating';
+    /**
+     * Position relative to viewport (floating) or canvas (fixed).
+     */
+    position: PointXY;
+    /**
+     * Optional constraints when using fixed placement.
+     */
+    constraints?: FixedElementConstraints;
+    private el;
+    private surface;
+    service: VisuallyJsService;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecoratorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DecoratorComponent, "vjs-decorator", never, { "placement": { "alias": "placement"; "required": false; }; "position": { "alias": "position"; "required": false; }; "constraints": { "alias": "constraints"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/default-group-component.d.ts

@@ -0,0 +1,11 @@
+import { BaseGroupComponent } from "./base.group.component";
+import * as i0 from "@angular/core";
+/**
+ * This component will be used as the default component when rendering groups, if you do not provide a specific `component` mapping for a given group type in your view. It will attempt to write the group's `label` property into the template, or will use an empty string if that is not defined.
+ * @group Components
+ */
+export declare class DefaultGroupComponent extends BaseGroupComponent {
+    readonly label: import("@angular/core").Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultGroupComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/lib/default-node-component.d.ts

@@ -0,0 +1,11 @@
+import { BaseNodeComponent } from "./base.node.component";
+import * as i0 from "@angular/core";
+/**
+ * This component will be used as the default component when rendering nodes, if you do not provide a specific `component` mapping for a given node type in your view. It will attempt to write the group's `label` property into the template, or will use an empty string if that is not defined.
+ * @group Components
+ */
+export declare class DefaultNodeComponent extends BaseNodeComponent {
+    readonly label: import("@angular/core").Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultNodeComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/lib/diagram-component.d.ts

@@ -0,0 +1,52 @@
+import { AfterViewInit, ElementRef, NgZone, OnDestroy } from "@angular/core";
+import { Diagram, DiagramOptions, DiagramSaveData, DiagramSaveOptions, ModelOptions, SaveOptions } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * Renders an SVG diagram.
+ * @group Components
+ */
+export declare class DiagramComponent implements AfterViewInit, OnDestroy {
+    /**
+     * Options for the Diagram
+     * @input
+     */
+    options?: DiagramOptions;
+    /**
+     * Optional data to load after creation
+     * @input
+     */
+    data?: any;
+    /**
+     * Optional URL from which to load data after creation
+     * @input
+     */
+    url?: string;
+    /**
+     * Options for the underlying model
+     * @input
+     */
+    modelOptions?: ModelOptions;
+    /**
+     * The underlying Diagram.
+     * @classMember
+     */
+    diagram: Diagram;
+    $ngZone: NgZone;
+    $el: ElementRef<any>;
+    $vjs: VisuallyJsService;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Saves the diagram data and state to an object.
+     * @param options Options for save
+     */
+    save(options?: DiagramSaveOptions): DiagramSaveData;
+    /**
+     * Saves the diagram data and state via POST to a nominated URL. Internally this calls `save` and then posts the result to the url you specify.
+     * @param options Options for save.
+     */
+    saveToUrl(options: SaveOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagramComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DiagramComponent, "vjs-diagram", never, { "options": { "alias": "options"; "required": false; }; "data": { "alias": "data"; "required": false; }; "url": { "alias": "url"; "required": false; }; "modelOptions": { "alias": "modelOptions"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/diagram-palette-component.d.ts

@@ -0,0 +1,92 @@
+import { Diagram, DiagramCell, Size, PaletteMode, OnVertexAddedCallback, PreparedShape } from "@visuallyjs/browser-ui";
+import { AfterViewInit, ElementRef } from "@angular/core";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+export declare class DiagramPaletteComponent implements AfterViewInit {
+    /**
+     * Optional fill color to use for dragged elements. This should be in RGB format, _not_ a color like 'white' or 'cyan' etc.
+     * @input
+     */
+    fill?: string;
+    /**
+     * Optional color to use for outline of dragged elements. Should be in RGB format.
+     * @input
+     */
+    outline?: string;
+    /**
+     * Optional size to use for dragged elements.
+     * @input
+     */
+    dragSize?: Size;
+    /**
+     * Indicates that when one or more vertices are selected, clicking on an entry in the palette will change the type of the selected vertices to that type. Defaults to true.
+     * @input
+     */
+    inspector?: boolean;
+    /**
+     * Optional size to use for icons. Defaults to 150x100 pixels. If you provide this but not `dragSize` this size will also be used for an icon that is being dragged.
+     * @input
+     */
+    iconSize?: Size;
+    /**
+     * Optionally show each shape icon's label underneath it
+     * @input
+     */
+    showLabels?: boolean;
+    /**
+     * Stroke width to use for shapes in palette. Defaults to 1.
+     * @input
+     */
+    paletteStrokeWidth?: number;
+    /**
+     * Message to use for the 'show all' option in the shape set drop down when there is more than one set of shapes. Defaults to `Show all`.
+     * @input
+     */
+    showAllMessage?: string;
+    /**
+     * Callback to invoke when a new diagram cell has been added.
+     * @input
+     */
+    onCellAdded?: (dc: DiagramCell) => any;
+    /**
+     * Mode to operate in - 'drag' or 'tap'. Defaults to 'drag' (PALETTE_MODE_DRAG).
+     * @input
+     */
+    mode?: PaletteMode;
+    /**
+     * When in tap mode, allow addition of new vertices simply by clicking, instead of requiring a shape be drawn. (When this is true, the drawing method also still works)
+     * @input
+     */
+    allowClickToAdd?: boolean;
+    /**
+     * Defaults to true: when in 'tap' mode and a new group/node has been drawn on the canvas, the UI is set back to pan mode.
+     * @input
+     */
+    autoExitDrawMode?: boolean;
+    /**
+     * When true (which is the default), a newly dropped shape will be set as the underlying model's selection.
+     * @input
+     */
+    selectAfterAdd?: boolean;
+    /**
+     * Optional diagram to attach to. It is not generally necessary to supply this as it will be retrieved from the context.
+     * @input
+     */
+    diagram?: Diagram;
+    /**
+     * Optional callback that will be invoked after a new vertex has been dropped and added to the dataset.
+     * @input
+     */
+    onVertexAdded?: OnVertexAddedCallback;
+    /**
+     * Optional set of prepared shapes to show in the palette. When this is provided, the palette will only render these shapes, and not the contents of the shape library.
+     * @input
+     */
+    preparedShapes?: Array<PreparedShape>;
+    $el: ElementRef<any>;
+    $vjs: VisuallyJsService;
+    private $init;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagramPaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DiagramPaletteComponent, "vjs-diagram-palette", never, { "fill": { "alias": "fill"; "required": false; }; "outline": { "alias": "outline"; "required": false; }; "dragSize": { "alias": "dragSize"; "required": false; }; "inspector": { "alias": "inspector"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "showLabels": { "alias": "showLabels"; "required": false; }; "paletteStrokeWidth": { "alias": "paletteStrokeWidth"; "required": false; }; "showAllMessage": { "alias": "showAllMessage"; "required": false; }; "onCellAdded": { "alias": "onCellAdded"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "allowClickToAdd": { "alias": "allowClickToAdd"; "required": false; }; "autoExitDrawMode": { "alias": "autoExitDrawMode"; "required": false; }; "selectAfterAdd": { "alias": "selectAfterAdd"; "required": false; }; "diagram": { "alias": "diagram"; "required": false; }; "onVertexAdded": { "alias": "onVertexAdded"; "required": false; }; "preparedShapes": { "alias": "preparedShapes"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/edge.type.picker.component.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, ElementRef, EventEmitter } from "@angular/core";
+import { EdgePropertyMappings, Inspector } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * A helper component that wraps an EdgeTypePicker, for use in an {@link InspectorComponent}
+ * @group Components
+ */
+export declare class EdgeTypePickerComponent implements AfterViewInit {
+    private el;
+    /**
+     * The name of the property that maps the edge type. Required.
+     * @input
+     */
+    propertyName: string;
+    /**
+     * Set of edge property mappings to render and allow the user to select from.
+     * Optional. By default the component will retrieve these from the surface
+     * @input
+     */
+    edgeMappings?: EdgePropertyMappings;
+    /**
+     * Fires an event when the user selects a new style via mouse click.
+     * @output
+     */
+    changeEvent: EventEmitter<string>;
+    private edgeTypePicker;
+    $vjs: VisuallyJsService;
+    inspector: Inspector;
+    constructor(el: ElementRef);
+    private resolveMappings;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeTypePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeTypePickerComponent, "vjs-edge-type", never, { "propertyName": { "alias": "propertyName"; "required": false; }; "edgeMappings": { "alias": "edgeMappings"; "required": false; }; }, { "changeEvent": "changeEvent"; }, never, never, false, never>;
+}

package/lib/export-controls-component.d.ts

@@ -0,0 +1,59 @@
+import { ElementRef, OnInit } from "@angular/core";
+import { BrowserUI, ImageExportUIOptions, PointXY, SvgExportUIOptions } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * @group Components
+ */
+export declare class ExportControlsComponent implements OnInit {
+    /**
+     * Whether or not to show a label in front of the buttons. Defaults to true.
+     * @input
+     */
+    showLabel?: boolean;
+    /**
+     * What to show in the label, if visible. Defaults to "Export:".
+     * @input
+     */
+    label?: string;
+    /**
+     * Optional margins to apply to both SVG and image exports. Will not override any margins specified in svgOptions or imageOptions.
+     * @input
+     */
+    margins?: PointXY;
+    /**
+     * Options for SVG exports.
+     * @input
+     */
+    svgOptions?: SvgExportUIOptions;
+    /**
+     * Options for image exports.
+     * @input
+     */
+    imageOptions?: ImageExportUIOptions;
+    /**
+     * Defaults to true - whether or not to show an SVG export button.
+     * @input
+     */
+    allowSvgExport?: boolean;
+    /**
+     * Defaults to true - whether or not to show a PNG export button.
+     * @input
+     */
+    allowPngExport?: boolean;
+    /**
+     * Defaults to true - whether or not to show a JPG export button.
+     * @input
+     */
+    allowJpgExport?: boolean;
+    /** @internal */
+    ui: BrowserUI;
+    $vjs: VisuallyJsService;
+    $el: ElementRef<any>;
+    ngOnInit(): void;
+    exportSVG(): void;
+    exportPNG(): void;
+    exportJPG(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportControlsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExportControlsComponent, "vjs-export-controls", never, { "showLabel": { "alias": "showLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "margins": { "alias": "margins"; "required": false; }; "svgOptions": { "alias": "svgOptions"; "required": false; }; "imageOptions": { "alias": "imageOptions"; "required": false; }; "allowSvgExport": { "alias": "allowSvgExport"; "required": false; }; "allowPngExport": { "alias": "allowPngExport"; "required": false; }; "allowJpgExport": { "alias": "allowJpgExport"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/inspector.component.d.ts

@@ -0,0 +1,96 @@
+import { ChangeDetectorRef, ElementRef, AfterViewInit } from "@angular/core";
+import { Inspector, Base, BrowserUI } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * Base inspector component. You can extend this class and just use the `currentObj` and/or `currentType` members in your template for a simple setup, or your subclass can manage its own more complicated state. This class will invoke `reset()` when there is no selected object, and `refresh` when an object is selected.
+ * @group Components
+ */
+export declare class InspectorComponent<T extends Base = Base> implements AfterViewInit {
+    /**
+     * The object that is currently being inspected.
+     * @classMember
+     */
+    currentObj: T;
+    /**
+     * By default, this is the `type` of the current object. You can override `refresh` to implement more sophisticated scenarios.
+     * @classMember
+     */
+    currentType: string;
+    /**
+     * The `objectType` of the current object - `Group`, `Node`, `Edge` or `Port`
+     * @classMember
+     */
+    currentObjectType: string;
+    /**
+     * Edge.objectType is exposed on the class for reference in the template.
+     * @classMember
+     */
+    EDGE: string;
+    /**
+     * Node.objectType is exposed on the class for reference in the template.
+     * @classMember
+     */
+    NODE: string;
+    /**
+     * Group.objectType is exposed on the class for reference in the template.
+     * @classMember
+     */
+    GROUP: string;
+    /**
+     * Port.objectType is exposed on the class for reference in the template.
+     * @classMember
+     */
+    PORT: string;
+    /**
+     * Optional css class(es) to set on the inspector - a space separated list.
+     * @input
+     */
+    cssClass?: string;
+    /**
+     * Whether or not to show a close button. Defaults to false.
+     * @input
+     */
+    showCloseButton?: boolean;
+    /**
+     * Optional context for shared data for inspector templates.
+     * @input
+     */
+    context?: Record<string, any>;
+    /**
+     * @internal
+     */
+    inspector: Inspector;
+    /**
+     * @internal
+     */
+    changeDetector: ChangeDetectorRef;
+    /**
+     * The DOM element representing this component.
+     * @internal
+     */
+    el: ElementRef<any>;
+    ui: BrowserUI;
+    $vjs: VisuallyJsService;
+    /**
+     * @internal
+     */
+    ngAfterViewInit(): void;
+    /**
+     * The base implementation of this method sets the current object type from `objectType`, and it also sets the current type to be the `type` of obj. You can override this method to implement more sophisticated scenarios.
+     * @param obj New object in inspector
+     */
+    refresh(obj: Base): void;
+    /**
+     * The base implementation of this method sets the current type to be an empty string. You can override this
+     * method to implement more sophisticated scenarios.
+     */
+    reset(): void;
+    /**
+     * Invoked after an inspector update. You can override this method to update your UI if you need to.
+     * @param ui The UI that this inspector is attached to.
+     */
+    afterUpdate(ui: BrowserUI): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InspectorComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InspectorComponent<any>, never, never, { "cssClass": { "alias": "cssClass"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/miniview-component.d.ts

@@ -0,0 +1,45 @@
+import { AfterViewInit, ElementRef, NgZone } from "@angular/core";
+import { MiniviewPlugin, Group, Node } from "@visuallyjs/browser-ui";
+import { VisuallyJsService } from "./vjs-service";
+import * as i0 from "@angular/core";
+/**
+ * A component that provides a miniview.
+ * @group Components
+ */
+export declare class MiniviewComponent implements AfterViewInit {
+    private ngZone;
+    /**
+     * Optional filter to determine whether or not include a given vertex in the miniview
+     * @input
+     */
+    elementFilter?: (obj: Node | Group) => boolean;
+    /**
+     * Optional function to determine a `type` for each vertex, which is then written as an attribute onto the DOM element representing the vertex in the miniview.
+     * @input
+     */
+    typeFunction?: (obj: Node | Group) => string;
+    /**
+     * Whether or not to move miniview elements at the same time as their related surface element is being dragged. Defaults to true.
+     * @input
+     */
+    activeTracking?: boolean;
+    /**
+     * Defaults to true, meaning a click on a node/group in the miniview will cause that node/group to be centered in the related surface.
+     * @input
+     */
+    clickToCenter?: boolean;
+    $el: ElementRef<any>;
+    $vjs: VisuallyJsService;
+    $miniview: MiniviewPlugin;
+    constructor(ngZone: NgZone);
+    /**
+     * @internal
+     */
+    ngAfterViewInit(): void;
+    /**
+     * @internal
+     */
+    redraw(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniviewComponent, "vjs-miniview", never, { "elementFilter": { "alias": "elementFilter"; "required": false; }; "typeFunction": { "alias": "typeFunction"; "required": false; }; "activeTracking": { "alias": "activeTracking"; "required": false; }; "clickToCenter": { "alias": "clickToCenter"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/model.d.ts

@@ -0,0 +1,8 @@
+import { BrowserUIModel, Surface, SurfaceOptions } from "@visuallyjs/browser-ui";
+/**
+ * Extension of the VisuallyJsModel for use in Angular. You'll rarely need to create one of these manually, but this is the class of the `model` exposed in several UI components.
+ * @group Classes
+ */
+export declare class BrowserUIAngularModel extends BrowserUIModel {
+    render(container: Element, options?: SurfaceOptions): Surface;
+}

package/lib/overlay-component.d.ts

@@ -0,0 +1,59 @@
+import { Edge, ObjectData, Surface } from "@visuallyjs/browser-ui";
+import { ChangeDetectorRef } from "@angular/core";
+import { VisuallyJsModel } from "@visuallyjs/browser-ui";
+import { VisuallyJsAngularComponent } from "./surface-component";
+/**
+ * Defines the type for an overlay that is represented by an angular component. Use this value in your views instead of "Arrow", "Label" etc.
+ * @group Components
+ */
+export declare const AngularComponentOverlayType = "AngularComponent";
+/**
+ * Definition of an angular component that will act as an overlay. This interface exists largely for convenience; the code will write the members of this interface onto any component it creates.
+ */
+export interface AngularOverlayComponent extends VisuallyJsAngularComponent {
+    /**
+     * The edge that this overlay is drawn on.
+     */
+    edge: Edge;
+}
+/**
+ * A component that you can use as a base for your own overlay component if its convenient for you. This class offers an `updateEdge` and a `removeEdge` method, as helpers.
+ * @group Components
+ */
+export declare abstract class BaseAngularOverlayComponent implements AngularOverlayComponent {
+    /**
+     * The underlying model
+     * @classMember
+     */
+    model: VisuallyJsModel;
+    /**
+     * The surface that this overlay is rendered by
+     * @classMember
+     */
+    surface: Surface;
+    /**
+     * Backing data for the edge this overlay is attached to
+     * @classMember
+     */
+    data: ObjectData;
+    /**
+     * Underlying Edge model object this overlay is attached to
+     * @classMember
+     */
+    edge: Edge;
+    /**
+     * @internal
+     */
+    changeDetectorRef: ChangeDetectorRef;
+    /**
+     * Update the underlying edge with the given data.
+     * @param updates Data to update the edge with
+     * @classMember
+     */
+    updateEdge(updates: ObjectData): void;
+    /**
+     * Remove the underlying edge. This will unload the edge and its visual representation, including this overlay component.
+     * @classMember
+     */
+    removeEdge(): void;
+}