@metadev/daga 1.4.1 → 1.4.3

package/lib/diagram-editor/diagram/diagram-action.d.ts

@@ -1,13 +1,7 @@
 import { Canvas } from '../../interfaces/canvas';
 import { Point } from '../../util/canvas-util';
-import { Side } from '../../util/svg-util';
-import { DiagramConnection, DiagramConnectionType } from './diagram-connection';
-import { DiagramField } from './diagram-field';
-import { DiagramModel } from './diagram-model';
-import { DiagramNode, DiagramNodeType } from './diagram-node';
-import { DiagramPort } from './diagram-port';
-import { ValueSet } from './diagram-property';
-import { DiagramSection } from './diagram-section';
+import { DiagramConnectionType } from './diagram-connection';
+import { DiagramNodeType, DiagramNodeGeometry } from './diagram-node';
 /**
  * A queue of recent actions taken by the user that can be undone and redone.
  * @private
@@ -56,7 +50,21 @@ export declare class ActionQueue {
  * @private
  */
 export interface DiagramAction {
+    /**
+     * Perform this action on the diagram for the first time.
+     * Performing the same action with the same parameters on a diagram with the same state should always result in the same changes to the state of the diagram.
+     */
+    do(): void;
+    /**
+     * Undo the changes in the diagram caused by this action.
+     * After having called `do()` followed by `undo()`, calling `redo()` followed by `undo()` any number of times should always result in no net changes to the state of the diagram.
+     */
     undo(): void;
+    /**
+     * Redo the changes in the diagram caused by this action.
+     * After having called `do()`, calling `undo()` followed by `redo()` any number of times should always result in no net changes to the state of the diagram.
+     * `redo()` is usually equivalent to `do()`, but not always.
+     */
     redo(): void;
 }
 /**
@@ -85,7 +93,7 @@ export declare enum DiagramActions {
     EditField = "edit-field",
     /**
      * Action that corresponds to moving a node.
-     * @see MoveNodeAction
+     * @see SetGeometryAction
      * @public
      */
     MoveNode = "move-node",
@@ -97,13 +105,13 @@ export declare enum DiagramActions {
     Remove = "remove",
     /**
      * Action that corresponds to altering a node's dimensions.
-     * @see StretchNodeAction
+     * @see SetGeometryActionAction
      * @public
      */
     StretchNode = "stretch-node",
     /**
      * Action that corresponds to altering a sections's dimensions.
-     * @see StretchSectionAction
+     * @see SetGeometryAction
      * @public
      */
     StretchSection = "stretch-section",
@@ -132,60 +140,27 @@ export declare class AddNodeAction implements DiagramAction {
     values?: {
         [key: string]: unknown;
     };
-    id?: string | undefined;
-    sectionIds?: (string | undefined)[];
-    sectionPortIds?: (string | undefined)[][];
-    sectionPortLabelIds?: (string | undefined)[][];
-    portIds?: (string | undefined)[];
-    portLabelIds?: (string | undefined)[];
-    labelId?: string | undefined;
+    id: string;
     constructor(canvas: Canvas, type: DiagramNodeType, coords: Point, label?: string, values?: {
         [key: string]: unknown;
-    }, id?: string);
-    undo(): void;
-    redo(): void;
-}
-/**
- * Action which consists of moving a node.
- * @see DiagramNode
- * @private
- */
-export declare class MoveNodeAction implements DiagramAction {
-    canvas: Canvas;
-    nodeId: string;
-    from: Point;
-    to: Point;
-    constructor(canvas: Canvas, nodeId: string, from: Point, to: Point);
+    });
+    do(): void;
     undo(): void;
     redo(): void;
 }
 /**
- * Action which consists of changing the dimensions of a node in a given direction.
+ * Action which consists of changing a node's geometry: moving, stretching, or stretching sections.
  * @see DiagramNode
  * @private
  */
-export declare class StretchNodeAction implements DiagramAction {
+export declare class SetGeometryAction implements DiagramAction {
     canvas: Canvas;
+    intent: DiagramActions.MoveNode | DiagramActions.StretchNode | DiagramActions.StretchSection;
     nodeId: string;
-    direction: Side;
-    from: number;
-    to: number;
-    constructor(canvas: Canvas, nodeId: string, direction: Side, from: number, to: number);
-    undo(): void;
-    redo(): void;
-}
-/**
- * Action which consists of changing the dimensions of a section in a given direction.
- * @see DiagramSection
- * @private
- */
-export declare class StretchSectionAction implements DiagramAction {
-    canvas: Canvas;
-    sectionId: string;
-    direction: Side;
-    from: number;
-    to: number;
-    constructor(canvas: Canvas, sectionId: string, direction: Side, from: number, to: number);
+    from: DiagramNodeGeometry;
+    to: DiagramNodeGeometry;
+    constructor(canvas: Canvas, intent: DiagramActions.MoveNode | DiagramActions.StretchNode | DiagramActions.StretchSection, nodeId: string, from: DiagramNodeGeometry, to: DiagramNodeGeometry);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -199,8 +174,9 @@ export declare class AddConnectionAction implements DiagramAction {
     type: DiagramConnectionType;
     startId: string;
     endId: string;
-    id?: string;
-    constructor(canvas: Canvas, type: DiagramConnectionType, startId: string, endId: string, id?: string);
+    id: string;
+    constructor(canvas: Canvas, type: DiagramConnectionType, startId: string, endId: string);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -215,6 +191,7 @@ export declare class EditFieldAction implements DiagramAction {
     from: string;
     to: string;
     constructor(canvas: Canvas, fieldId: string, from: string, to: string);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -224,7 +201,7 @@ export declare class EditFieldAction implements DiagramAction {
  * @private
  */
 export declare class UpdateValuesAction implements DiagramAction {
-    model: DiagramModel;
+    canvas: Canvas;
     id: string | undefined;
     from: {
         [key: string]: unknown;
@@ -232,32 +209,35 @@ export declare class UpdateValuesAction implements DiagramAction {
     to: {
         [key: string]: unknown;
     };
-    constructor(model: DiagramModel, id: string | undefined, from: {
+    constructor(canvas: Canvas, id: string | undefined, from: {
         [key: string]: unknown;
     }, to: {
         [key: string]: unknown;
     });
-    getValueSet(): ValueSet | undefined;
+    do(): void;
     undo(): void;
     redo(): void;
 }
 /**
  * Action which consists of removing elements from a diagram.
+ *
+ * You should only include an element in this action if the element itself is explicitly removed.
+ * Elements removed as a consequence of a removing another element
+ * (e.g., removing a node removes all of its sections)
+ * will be handled automatically, in a way that converges in the case
+ * of concurrent collaborative actions.
+ *
  * @private
  */
 export declare class RemoveAction implements DiagramAction {
-    model: DiagramModel;
-    nodes: DiagramNode[];
+    canvas: Canvas;
     nodeIds: string[];
-    sections: DiagramSection[];
     sectionIds: string[];
-    ports: DiagramPort[];
     portIds: string[];
-    connections: DiagramConnection[];
     connectionIds: string[];
-    fields: DiagramField[];
     fieldIds: string[];
-    constructor(model: DiagramModel, nodes: DiagramNode[], sections: DiagramSection[], ports: DiagramPort[], connections: DiagramConnection[], fields: DiagramField[]);
+    constructor(canvas: Canvas, nodeIds: string[], sectionIds: string[], portIds: string[], connectionIds: string[], fieldIds: string[]);
+    do(): void;
     undo(): void;
     redo(): void;
 }

package/lib/diagram-editor/diagram/diagram-canvas.d.ts

@@ -4,6 +4,7 @@ import { DiagramValidator } from '../../errors/diagram-validator';
 import { Canvas } from '../../interfaces/canvas';
 import { DiagramEditor } from '../../interfaces/diagram-editor';
 import { Point } from '../../util/canvas-util';
+import { CursorStyle } from '../../util/style';
 import { ActionQueue, DiagramActions } from './diagram-action';
 import { DiagramConfig } from './diagram-config';
 import { DiagramConnection, DiagramConnectionType } from './diagram-connection';
@@ -11,7 +12,7 @@ import { DiagramElement } from './diagram-element';
 import { DiagramModel } from './diagram-model';
 import { DiagramPort } from './diagram-port';
 import { ValueSet } from './diagram-property';
-import { CursorStyle } from '../../util/style';
+import { CollabEngine } from './collab/collab-engine';
 /**
  * Thickness of the invisible path around a connection used to make it easier to click on, in pixels.
  * @private
@@ -49,6 +50,7 @@ export declare class DiagramCanvas implements Canvas {
         [key in DiagramActions]?: boolean;
     };
     actionQueue: ActionQueue;
+    collabEngine: CollabEngine;
     private static canvasCount;
     private backgroundPatternId;
     private zoomBehavior;

package/lib/diagram-editor/diagram/diagram-connection.d.ts

@@ -25,6 +25,22 @@ export declare const DIAGRAM_CONNECTION_TYPE_DEFAULTS: {
     selectedColor: string;
     properties: never[];
 };
+/**
+ * Whether a connection can have the same port as both its start port and its end port.
+ */
+export declare const CAN_A_CONNECTION_END_ON_THE_SAME_PORT_IT_STARTS = false;
+/**
+ * Whether a connection can have the same ports as another connection.
+ */
+export declare const CAN_A_CONNECTION_HAVE_THE_SAME_PORTS_AS_ANOTHER = false;
+/**
+ * Whether a port can have multiple connections.
+ */
+export declare const CAN_CONNECTIONS_SHARE_PORTS = true;
+/**
+ * Whether tightening connections is allowed.
+ */
+export declare const CAN_TIGHTEN_CONNECTIONS = true;
 /**
  * A connection type, which holds properties that connections of this type share in common.
  * @see ConnectionTypeConfig
@@ -131,19 +147,52 @@ export declare class DiagramConnection extends DiagramElement {
      */
     get name(): string;
     set name(name: string);
-    constructor(model: DiagramModel, type: DiagramConnectionType, start?: DiagramPort, end?: DiagramPort, id?: string);
+    constructor(model: DiagramModel, type: DiagramConnectionType, start: DiagramPort | undefined, end: DiagramPort | undefined, id: string);
+    get removed(): boolean;
     updateInView(): void;
+    /**
+     * Set the start of this connection to the given port or reset this connection's starting port if `undefined`.
+     * Add or remove this connection from the list of outgoing connections of ports correspondingly.
+     * @public
+     * @param start A port.
+     */
     setStart(start?: DiagramPort): void;
+    /**
+     * Set the end of this connection to the given port or reset this connection's ending port if `undefined`.
+     * Add or remove this connection from the list of incoming connections of ports correspondingly.
+     * @public
+     * @param end A port.
+     */
     setEnd(end?: DiagramPort): void;
+    /**
+     * Reassign the start and end ports of this connection to ports with less distance between them that have the same root element.
+     * If no ports with less distance between them are found, do nothing.
+     * @public
+     */
     tighten(): void;
     getPriority(): number;
 }
 export declare class DiagramConnectionSet extends DiagramEntitySet<DiagramConnection> {
     private model;
+    /**
+     * Set of the possible types of connection that the connections of this set can have.
+     * @public
+     */
     types: DiagramEntitySet<DiagramConnectionType>;
+    /**
+     * Instance a set of connections for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
-    new(type: DiagramConnectionType, start?: DiagramPort, end?: DiagramPort, id?: string | undefined): DiagramConnection;
+    /**
+     * Instance a new connection and add it to this set.
+     * @public
+     * @param type The type of the connection given as either the type itself or the id of the type.
+     * @param start The start port of the connection.
+     * @param end The end port of the connection.
+     * @param id The id of the connection.
+     * @returns The instanced connection.
+     */
+    new(type: DiagramConnectionType | string, start: DiagramPort | undefined, end: DiagramPort | undefined, id: string): DiagramConnection;
     remove(id: string): void;
-    filter(type?: string, threshold?: number): DiagramConnection[];
-    find(type?: string, threshold?: number): DiagramConnection | undefined;
 }

package/lib/diagram-editor/diagram/diagram-element.d.ts

@@ -1,5 +1,6 @@
 import * as d3 from 'd3';
 import { DiagramModel } from './diagram-model';
+import { CollabTimestamp } from './collab/primitives';
 /**
  * Default priority value for diagram elements.
  * @private
@@ -41,7 +42,33 @@ export declare abstract class DiagramElement implements DiagramEntity {
      * @private
      */
     selected: boolean;
+    /**
+     * Whether this diagram element has itself been explicitly removed.
+     *
+     * Override the `removed` getter so that it returns true if and only if:
+     * - `selfRemoved` is true, or
+     * - `removed` is true for any of this element's dependencies.
+     *
+     * For example, a DiagramConnection is removed if either of its ports are removed,
+     * even if the connection's own `selfRemoved` field is false.
+     * @private
+     */
+    selfRemoved: boolean;
+    /**
+     * Collaborative timestamp for selfRemoved.
+     * @private
+     */
+    selfRemovedTimestamp: CollabTimestamp | null;
     constructor(model: DiagramModel, id: string);
+    /**
+     * Whether this diagram element has been removed.
+     *
+     * An element can be removed because it was explicitly removed, or because one of
+     * its dependencies was removed. For example, a DiagramConnection depends on both of its ports.
+     *
+     * @private
+     */
+    abstract readonly removed: boolean;
     /**
      * Get the priority of this element to calculate whether it should be filtered out in the view or not.
      * @public
@@ -112,13 +139,13 @@ export declare class DiagramEntitySet<E extends DiagramEntity> implements Iterab
      * @public
      * @returns An array containing the entities of this set that meet the given criteria.
      */
-    filter(): E[];
+    filter(predicate: (value: E, index: number, array: E[]) => unknown): E[];
     /**
      * Gets an entity of this set matching specific criteria.
      * @public
      * @returns An entity of this set.
      */
-    find(): E | undefined;
+    find(predicate: (value: E, index: number, array: E[]) => unknown): E | undefined;
     /**
      * Gets an entity from this set.
      * @public

package/lib/diagram-editor/diagram/diagram-field.d.ts

@@ -1,5 +1,6 @@
 import { Point } from '../../util/canvas-util';
 import { HorizontalAlign, VerticalAlign } from '../../util/svg-util';
+import { CollabTimestamp } from './collab/primitives';
 import { DiagramElement, DiagramEntitySet } from './diagram-element';
 import { DiagramModel } from './diagram-model';
 import { DiagramNode } from './diagram-node';
@@ -92,6 +93,11 @@ export declare class DiagramField extends DiagramElement {
      */
     get text(): string;
     set text(value: string);
+    /**
+     * Collaborative timestamp for text.
+     * @public
+     */
+    textTimestamp: CollabTimestamp | null;
     /**
      * Whether this field's text can be edited by the user.
      * @public
@@ -102,17 +108,29 @@ export declare class DiagramField extends DiagramElement {
      * @public
      */
     fit: boolean;
-    constructor(model: DiagramModel, rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, width: number, height: number, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean, id?: string);
+    constructor(model: DiagramModel, rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, width: number, height: number, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean);
     select(): d3.Selection<SVGGElement, unknown, null, unknown> | undefined;
+    get removed(): boolean;
     updateInView(): void;
+    /**
+     * Change the coordinates of this field to the given coordinates.
+     * @public
+     * @param coords A point in the diagram.
+     */
     move(coords: Point): void;
     getPriority(): number;
 }
 export declare class DiagramFieldSet extends DiagramEntitySet<DiagramField> {
     private model;
+    /**
+     * Instance a set of fields for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
-    new(rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, width: number, height: number, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean, id?: string | undefined): DiagramField;
+    /**
+     * Instance a new field and add it to this set. This method is normally called when instancing an element with a field and it is rarely called by itself.
+     * @private
+     */
+    new(rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, width: number, height: number, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean): DiagramField;
     remove(id: string): void;
-    filter(threshold?: number): DiagramField[];
-    find(threshold?: number): DiagramField | undefined;
 }

package/lib/diagram-editor/diagram/diagram-model.d.ts

@@ -7,6 +7,7 @@ import { Property, ValueSet } from './diagram-property';
 import { DiagramSectionSet } from './diagram-section';
 /**
  * Stores the data of a diagram.
+ * Represents the state of the diagram.
  * @public
  */
 export declare class DiagramModel {
@@ -80,6 +81,11 @@ export declare class DiagramModel {
      * @public
      */
     valueSet: ValueSet;
+    /**
+     * The last-seen logical clock value, used to generate CollabTimestamps.
+     * @public
+     */
+    logicalClock: number;
     constructor(canvas: Canvas | undefined, id: string | undefined, name: string, description: string | undefined, type: string, properties?: Property[]);
     /**
      * Deletes everything in this diagram.

package/lib/diagram-editor/diagram/diagram-node.d.ts

@@ -1,5 +1,6 @@
 import { Point } from '../../util/canvas-util';
 import { Side } from '../../util/svg-util';
+import { CollabTimestamp } from './collab/primitives';
 import { FieldConfig, NodeImageLook, NodeShapedLook, NodeStretchableImageLook, NodeTypeConfig, PortConfig, SectionGridConfig } from './diagram-config';
 import { DiagramConnection } from './diagram-connection';
 import { DiagramElement, DiagramEntity, DiagramEntitySet } from './diagram-element';
@@ -7,7 +8,7 @@ import { DiagramField } from './diagram-field';
 import { DiagramModel } from './diagram-model';
 import { DiagramPort } from './diagram-port';
 import { PropertySet, ValueSet } from './diagram-property';
-import { DiagramSection } from './diagram-section';
+import { DiagramSection, DiagramSectionGeometry } from './diagram-section';
 /**
  * Default values of the look of a diagram node.
  * @see DIAGRAM_NODE_TYPE_DEFAULTS
@@ -35,6 +36,14 @@ export declare const DIAGRAM_NODE_TYPE_DEFAULTS: {
     priority: number;
     properties: never[];
 };
+export type DiagramNodeGeometry = {
+    readonly coords: Point;
+    readonly width: number;
+    readonly height: number;
+    readonly sections: {
+        [sectionId: string]: DiagramSectionGeometry;
+    };
+};
 /**
  * A node type, which holds properties that nodes of this type share in common.
  * @see NodeTypeConfig
@@ -97,6 +106,11 @@ export declare class DiagramNode extends DiagramElement {
      * @public
      */
     coords: Point;
+    /**
+     * Collaborative timestamp for SetGeometryCollabActions.
+     * @public
+     */
+    geometryTimestamp: CollabTimestamp | null;
     /**
      * Dimension of this node along the x axis.
      * @public
@@ -113,24 +127,93 @@ export declare class DiagramNode extends DiagramElement {
      */
     get name(): string;
     set name(name: string);
-    constructor(model: DiagramModel, type: DiagramNodeType, coords?: Point, id?: string);
+    constructor(model: DiagramModel, type: DiagramNodeType, coords: Point | undefined, id: string);
+    get removed(): boolean;
     updateInView(): void;
     getPriority(): number;
+    /**
+     * Get the port of this node which is closest to the given coordinates.
+     * @param coords A point in the diagram.
+     * @returns The port of this node closest to the given coordinates, `undefined` if this node has no ports.
+     */
     getClosestPortToPoint(coords: Point): DiagramPort | undefined;
+    /**
+     * Get all incoming connections of all ports of this node, not including incoming connections of sections of this node.
+     * @public
+     * @returns A list of connections.
+     */
     getIncomingConnections(): DiagramConnection[];
+    /**
+     * Get all outgoing connections of all ports of this node, not including outgoing connections of sections of this node.
+     * @public
+     * @returns A list of connections.
+     */
     getOutgoingConnections(): DiagramConnection[];
+    /**
+     * Get all connections of all ports of this node, not including connections of sections of this node.
+     * @public
+     * @returns A list of connections.
+     */
     getConnections(): DiagramConnection[];
+    /**
+     * Get all nodes that have a direct connection to this node, not including nodes that have a direct connection to sections of this node.
+     * @public
+     * @returns A list of nodes.
+     */
     getAdjacentNodes(): DiagramNode[];
+    /**
+     * Change the coordinates of this node to the given coordinates and move its sections, ports and labels correspondingly.
+     * @public
+     * @param coords A point in the diagram.
+     */
     move(coords: Point): void;
+    /**
+     * Change the dimensions of this node in the given direction by the given amount without changing the dimensions of the sections of this node.
+     * @public
+     * @param direction A direction.
+     * @param distance A distance.
+     */
     stretch(direction: Side, distance: number): void;
+    /**
+     * Change the dimensions of this node and its sections in the given direction by the given amount, with the sections of the given index being stretched.
+     * @public
+     * @param direction A direction.
+     * @param distance A distance.
+     * @param indexX A section index.
+     * @param indexY A section index.
+     */
     stretchSections(direction: Side, distance: number, indexX: number, indexY: number): void;
+    /**
+     * Returns the current values of all geometric properties (coordinates and dimensions) of this node and its sections.
+     * @public
+     */
+    getGeometry(): DiagramNodeGeometry;
+    /**
+     * Sets all geometric properties (coordinates and dimensions) of this node and its sections.
+     * @public
+     */
+    setGeometry(geometry: DiagramNodeGeometry): void;
 }
 export declare class DiagramNodeSet extends DiagramEntitySet<DiagramNode> {
     private model;
+    /**
+     * Set of the possible types of node that the nodes of this set can have.
+     * @public
+     */
     types: DiagramEntitySet<DiagramNodeType>;
+    /**
+     * Instance a set of nodes for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
-    new(type: DiagramNodeType, coords: Point, id?: string | undefined, sectionIds?: (string | undefined)[], sectionPortIds?: (string | undefined)[][], sectionPortLabelIds?: (string | undefined)[][], portIds?: (string | undefined)[], portLabelIds?: (string | undefined)[], labelId?: string | undefined): DiagramNode;
+    /**
+     * Instance a new node and add it to this set.
+     * @public
+     * @param type The type of the node given as either the type itself or the id of the type.
+     * @param coords The coordinates of the top left corner of the node in the diagram.
+     * @param id The id of the node.
+     * @returns The instanced node.
+     */
+    new(type: DiagramNodeType | string, coords: Point, id: string): DiagramNode;
     remove(id: string): void;
-    filter(type?: string, threshold?: number): DiagramNode[];
-    find(type?: string, threshold?: number): DiagramNode | undefined;
 }

package/lib/diagram-editor/diagram/diagram-port.d.ts

@@ -54,20 +54,47 @@ export declare class DiagramPort extends DiagramElement {
      * @public
      */
     incomingConnections: DiagramConnection[];
-    constructor(model: DiagramModel, rootElement: DiagramNode | DiagramSection | undefined, coords: Point, direction: Side, id?: string);
+    constructor(model: DiagramModel, rootElement: DiagramNode | DiagramSection | undefined, coords: Point, direction: Side, id: string);
+    get removed(): boolean;
     updateInView(): void;
+    /**
+     * Add a connection to this port's list of outgoing connections.
+     * @public
+     * @param connection A connection.
+     */
     startConnection(connection: DiagramConnection): void;
+    /**
+     * Add a connection to this port's list of incoming connections.
+     * @public
+     * @param connection A connection.
+     */
     finishConnection(connection: DiagramConnection): void;
+    /**
+     * Get the root node of this port, which is either its rootElement if it's a node or it's rootElement's node if it's a section.
+     * @public
+     * @returns A node if it could be found, `undefined` otherwise.
+     */
     getNode(): DiagramNode | undefined;
     getPriority(): number;
+    /**
+     * Change the coordinates of this port to the given coordinates and move its labels correspondingly.
+     * @public
+     * @param coords A point in the diagram.
+     */
     move(coords: Point): void;
     distanceTo(coords: Point): number;
 }
 export declare class DiagramPortSet extends DiagramEntitySet<DiagramPort> {
     private model;
+    /**
+     * Instance a set of ports for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
-    new(rootElement: DiagramNode | DiagramSection | undefined, coords: Point, direction: Side, id?: string | undefined): DiagramPort;
+    /**
+     * Instance a new port and add it to this set. This method is normally called when instancing an element with a port and it is rarely called by itself.
+     * @private
+     */
+    new(rootElement: DiagramNode | DiagramSection | undefined, coords: Point, direction: Side, id: string): DiagramPort;
     remove(id: string): void;
-    filter(threshold?: number): DiagramPort[];
-    find(threshold?: number): DiagramPort | undefined;
 }