@focus.matters/diagrams 0.0.7

package/dist/Diagrams/custom/bpmn/nodes/GateNode.d.ts

@@ -0,0 +1,58 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { BPMNode } from './BPMNode';
+export declare enum GateTypes {
+    inclusive = 0,
+    exclusive = 1,
+    parallel = 2,
+    eventBased = 3
+}
+export declare class GateNode extends BPMNode {
+    type: GateTypes;
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        type?: GateTypes;
+    });
+    setType(type: GateTypes): void;
+    serialize(): {
+        type: GateTypes;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                pathType: import('../../../store/types').EdgePathType | undefined;
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    deserialize(o: ReturnType<this['serialize']>): void;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/bpmn/nodes/Lanes/LanesResizer.d.ts

@@ -0,0 +1,6 @@
+import { Lanes } from '.';
+export declare const LanesResizer: (({ lanes }: {
+    lanes: Lanes;
+}) => import("react").JSX.Element | null) & {
+    displayName: string;
+};

package/dist/Diagrams/custom/bpmn/nodes/Lanes/index.d.ts

@@ -0,0 +1,66 @@
+import { FC } from 'react';
+import { BPMNode } from '../BPMNode';
+import { Element } from '../../../../store/elements/Element';
+import { Dimensions } from '../../../../store/primitives/Dimensions';
+export type TPool = {
+    name: string;
+    label: string;
+};
+export declare class Lanes extends BPMNode {
+    static readonly laneHeaderWidth = 50;
+    static readonly laneHeight = 250;
+    static readonly lanePadding = 25;
+    static readonly laneHeaderFontSize = 14;
+    constructor(parent: Element | null, state: {
+        id: string;
+    });
+    get box(): Dimensions;
+    addPool(): TPool;
+    protected editionIndex: number;
+    protected previousPools: TPool[];
+    cancel(): void;
+    confirm(): boolean;
+    edit(): void;
+    resetPools(): void;
+    deserialize(o: ReturnType<this['serialize']>): void;
+    serialize(): {
+        pools: TPool[];
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../../store/types').EdgeLineStyle | undefined;
+                pathType: import('../../../../store/types').EdgePathType | undefined;
+                steps: import('../../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    pools: TPool[];
+    Render: FC;
+}

package/dist/Diagrams/custom/bpmn/nodes/TaskNode.d.ts

@@ -0,0 +1,9 @@
+import { BPMNode } from './BPMNode';
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+export declare class TaskNode extends BPMNode {
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/bpmn/nodes/UnknownBPMNNode.d.ts

@@ -0,0 +1,51 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { BPMNode } from './BPMNode';
+export declare class UnknownBPMNNode extends BPMNode {
+    sourceType: string;
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        sourceType?: string;
+    });
+    serialize(): {
+        sourceType: string;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                pathType: import('../../../store/types').EdgePathType | undefined;
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    deserialize(o: ReturnType<this['serialize']>): void;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/communication/CommunicationDiagram.d.ts

@@ -0,0 +1,15 @@
+import { TDiagramSettings } from '../../store/Diagram';
+import { EditableDiagram } from '../editable/EditableDiagram';
+import { CommunicationActorNode } from './nodes/CommunicationActorNode';
+import { CommunicationObjectNode } from './nodes/CommunicationObjectNode';
+import { CommunicationControllerNode } from './nodes/CommunicationControllerNode';
+import { CommunicationNodeType } from './types';
+export declare class CommunicationDiagram extends EditableDiagram {
+    constructor(settings?: TDiagramSettings);
+    get selectedNodes(): import('../../store/elements/Node').Node<import('../../store/types').TOrientation>[];
+    get selectedEdges(): import('../../store/elements/Edge').Edge[];
+    createNodeFromClientPoint(type: CommunicationNodeType, clientX: number, clientY: number): CommunicationActorNode | CommunicationObjectNode | CommunicationControllerNode;
+    createNodeAtCanvasPoint(type: CommunicationNodeType, x: number, y: number): CommunicationActorNode | CommunicationObjectNode | CommunicationControllerNode;
+    createNodeInViewportCenter(type: CommunicationNodeType): CommunicationActorNode | CommunicationObjectNode | CommunicationControllerNode;
+    private instantiateNode;
+}

package/dist/Diagrams/custom/communication/CommunicationNode.d.ts

@@ -0,0 +1,12 @@
+import { EditableNode } from '../editable/EditableNode';
+import { Element } from '../../store/elements/Element';
+import { TNodeConstructorProps } from '../../store/elements/Node';
+import { Dimensions } from '../../store/primitives/Dimensions';
+export declare abstract class CommunicationNode extends EditableNode {
+    abstract readonly communicationNodeType: string;
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        box?: Dimensions;
+        fill?: string;
+        stroke?: string;
+    });
+}

package/dist/Diagrams/custom/communication/edges/CommunicationEdge.d.ts

@@ -0,0 +1,35 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Element } from '../../../store/elements/Element';
+import { TEdgeState } from '../../../store/types';
+type CommunicationEdgeState = Partial<TEdgeState>;
+type SerializedCommunicationEdge = ReturnType<Edge['serialize']> & {
+    label?: string;
+    labelPositioning?: [number, number];
+};
+export declare class CommunicationEdge extends Edge {
+    isEditingLabel: boolean;
+    labelDraft: string;
+    constructor(parent: Element | null, state: CommunicationEdgeState);
+    setLabel(label: string): void;
+    beginLabelEdit(): void;
+    cancelLabelEdit(): void;
+    confirmLabelEdit(): void;
+    serialize(): {
+        label: string;
+        labelPositioning: [number, number];
+        arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+        pathType: import('../../../store/types').EdgePathType | undefined;
+        steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    deserialize(o: SerializedCommunicationEdge): void;
+}
+export {};

package/dist/Diagrams/custom/communication/nodes/CommunicationActorNode.d.ts

@@ -0,0 +1,10 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { CommunicationNode } from '../CommunicationNode';
+export declare class CommunicationActorNode extends CommunicationNode {
+    readonly communicationNodeType: "actor";
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/communication/nodes/CommunicationControllerNode.d.ts

@@ -0,0 +1,10 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { CommunicationNode } from '../CommunicationNode';
+export declare class CommunicationControllerNode extends CommunicationNode {
+    readonly communicationNodeType: "controller";
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/communication/nodes/CommunicationObjectNode.d.ts

@@ -0,0 +1,10 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { CommunicationNode } from '../CommunicationNode';
+export declare class CommunicationObjectNode extends CommunicationNode {
+    readonly communicationNodeType: "object";
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/communication/types.d.ts

@@ -0,0 +1 @@
+export type CommunicationNodeType = 'actor' | 'object' | 'controller';

package/dist/Diagrams/custom/editable/EditableDiagram.d.ts

@@ -0,0 +1,4 @@
+import { Diagram, TDiagramSettings } from '../../store/Diagram';
+export declare class EditableDiagram extends Diagram {
+    constructor(settings?: TDiagramSettings);
+}

package/dist/Diagrams/custom/editable/EditableLabel.d.ts

@@ -0,0 +1,3 @@
+export declare const EditableLabel: (() => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/Diagrams/custom/editable/EditableNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, TNodeConstructorProps } from '../../store/elements/Node';
+import { Element } from '../../store/elements/Element';
+import { FC } from 'react';
+export declare abstract class EditableNode extends Node {
+    editionMode: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    get label(): string;
+    private previous;
+    edit(): void;
+    cancel(): void;
+    confirm(): boolean;
+    get isChanged(): boolean;
+    protected abstract Render: FC;
+    Renderer: () => import("react").JSX.Element;
+}

package/dist/Diagrams/custom/editable/EditableNodeContext.d.ts

@@ -0,0 +1,3 @@
+import { EditableNode } from './EditableNode';
+export declare const EditableNodeContext: import('react').Context<EditableNode | null>;
+export declare function useEditableNode(): EditableNode;

package/dist/Diagrams/custom/editable/EditionMode.d.ts

@@ -0,0 +1,10 @@
+import { DiagramExtension } from '../../store/extensions/DiagramExtension';
+import { EditableNode } from './EditableNode';
+export declare function allowEventInEdition(ev: KeyboardEvent): boolean;
+export declare class EditionMode extends DiagramExtension {
+    private inEdition;
+    private cancel;
+    private confirm;
+    editNode(node: EditableNode): void;
+    init(): void;
+}

package/dist/Diagrams/custom/editable/events.d.ts

@@ -0,0 +1,9 @@
+import { DChangeEvent } from '../../store/elements/Events';
+import { Element } from '../../store/elements/Element';
+export declare class DEditNodeEvent extends DChangeEvent {
+    src: Element;
+    previousLabel: string;
+    nextLabel: string;
+    protected readonly __brand: void;
+    constructor(src: Element, previousLabel: string, nextLabel: string);
+}

package/dist/Diagrams/layout/HStack.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes, PropsWithChildren } from 'react';
+type StageProps = PropsWithChildren<HTMLAttributes<HTMLDivElement>>;
+export declare function Stage({ children, className, ...rest }: StageProps): import("react").JSX.Element;
+export {};

package/dist/Diagrams/store/Canvas.d.ts

@@ -0,0 +1,69 @@
+import { Coordinates } from './primitives/Coordinates';
+import { Dimensions } from './primitives/Dimensions';
+import { Diagram } from './Diagram';
+import { Element } from './elements/Element';
+export type ScaleEvent = {
+    previousScale: number;
+    newScale: number;
+    displacement: Coordinates;
+};
+export declare class Canvas extends Element {
+    private unbindDocumentEvents;
+    private mouseSessionStartedInFrame;
+    protected _displacement: Coordinates;
+    _scale: number;
+    private gridSize;
+    size: Coordinates;
+    get scale(): number;
+    element: HTMLElement | null;
+    get elementPosition(): Coordinates;
+    get elementDimensions(): Dimensions;
+    get displacement(): Coordinates;
+    get framePosition(): Coordinates;
+    get frameDimensions(): Dimensions;
+    constructor(parent: Diagram);
+    dispose(): void;
+    markMouseSessionStartedInFrame(): void;
+    get dragging(): boolean;
+    protected _dragging: boolean;
+    displacementStart: null | Coordinates;
+    eventStart: null | Coordinates;
+    protected bound(): void;
+    centerOnPoint(c: Coordinates): void;
+    /**
+     * @returns how much it displaced
+     */
+    displace(c: Coordinates): Coordinates;
+    setDisplacement(c: Coordinates): void;
+    setScale(newScale: number, zoomCenter?: Coordinates): void;
+    /**
+     * Given a pair of coordinates in the canvas, returns the matching coordinates in the screen
+     */
+    fit<T extends Coordinates | Dimensions | number>(value: T): T;
+    /**
+     * Given a pair of coordinates in the screen, returns the matching coordinates in the canvas
+     */
+    inverseFit<T extends Coordinates | Dimensions>(value: T): T;
+    getDisplacementStyles(): {
+        position: string;
+        width: string;
+        height: string;
+        transform: string;
+        transformOrigin: string;
+        willChange: string;
+    };
+    protected setDisplacementStyles(element?: HTMLElement | null): void;
+    setGridSize(gridSize: number): void;
+    useRef: (el: HTMLElement | null) => void;
+    private isInsideFrameFromTarget;
+    private isInsideFrameEvent;
+    protected handleMouseMove(originalEvent: MouseEvent): void;
+    protected handleDoubleClick(originalEvent: MouseEvent): void;
+    protected handleClick(originalEvent: MouseEvent): void;
+    protected handleMouseUp(originalEvent: MouseEvent): void;
+    protected handleMouseDown(originalEvent: MouseEvent): void;
+    protected handleKeyDown(originalEvent: KeyboardEvent): void;
+    protected handleKeyUp(originalEvent: KeyboardEvent): void;
+    protected handleKeyPress(originalEvent: KeyboardEvent): void;
+    protected handleWheel(originalEvent: WheelEvent): void;
+}

package/dist/Diagrams/store/Diagram.d.ts

@@ -0,0 +1,134 @@
+import { ReactNode } from 'react';
+import { Canvas } from './Canvas';
+import { Node } from './elements/Node';
+import { Coordinates } from './primitives/Coordinates';
+import { Edge } from './elements/Edge';
+import { Gateway } from './elements/Gateway';
+import { Element, Class } from './elements/Element';
+import { Priorities } from './extensions/Priorities';
+import { Rules } from './extensions/Rules';
+import { DiagramExtension } from './extensions/DiagramExtension';
+import { NodesAligner } from './extensions/NodesAligner';
+import { Creator } from './extensions/Creator';
+import { EdgesDragger } from './extensions/EdgesDragger';
+import { Hotkeys } from './extensions/Hotkeys';
+import { Measurer } from './extensions/Measurer';
+import { Selector } from './extensions/Selector';
+import { NodesConnector } from './extensions/NodesConnector';
+import { GridSnap } from './extensions/GridSnap';
+import { StraightDrag } from './extensions/StraightDrag';
+import { DistancesBalancer } from './extensions/DistancesBalancer';
+import { NodesResizer } from './extensions/NodesResizer';
+import { History } from './extensions/History';
+import { Dragger } from './extensions/Dragger';
+import { PathFindingRenderer } from './extensions/PathFindingRenderer';
+declare const DefaultExtensions: Readonly<{
+    Creator: typeof Creator;
+    DistancesBalancer: typeof DistancesBalancer;
+    Dragger: typeof Dragger;
+    EdgesDragger: typeof EdgesDragger;
+    GridSnap: typeof GridSnap;
+    History: typeof History;
+    Hotkeys: typeof Hotkeys;
+    Measurer: typeof Measurer;
+    NodesAligner: typeof NodesAligner;
+    NodesConnector: typeof NodesConnector;
+    NodesResizer: typeof NodesResizer;
+    PathFindingRenderer: typeof PathFindingRenderer;
+    Selector: typeof Selector;
+    StraightDrag: typeof StraightDrag;
+}>;
+export type TDefaultExensions = {
+    [key in keyof typeof DefaultExtensions]: boolean;
+};
+export type TDiagramSettings = Partial<{
+    extensions: TDefaultExensions;
+}>;
+export declare class Diagram extends Element {
+    readonly priorities: Priorities;
+    rules: Rules;
+    private focusContentTimer;
+    private knownClasses;
+    getClass(name: string): any;
+    registerClass(clazz: any, className?: any): void;
+    edgeClass: typeof Edge;
+    setDefaultEdge(clazz: typeof Edge): void;
+    protected _extensions: Map<Class<DiagramExtension>, DiagramExtension>;
+    protected _nodes: Map<string, Node<import('./types').TOrientation>>;
+    protected _edges: Map<string, Edge>;
+    canvas: Canvas;
+    constructor(settings?: TDiagramSettings);
+    get edges(): Readonly<Edge[]>;
+    get nodes(): Readonly<Node[]>;
+    private getUniqueNodeId;
+    add<T extends Node>(node: T): T;
+    addEdge(edge: Edge): void;
+    connect(from: Gateway, to: Gateway, options?: {
+        fromDisplacement?: Coordinates;
+        toDisplacement?: Coordinates;
+    }): Edge;
+    connectWithEdge(from: Gateway, to: Gateway, existentEdge: Edge): Edge;
+    delete(node: Node<any>): void;
+    disconnect(edge: Edge): void;
+    Context: ({ children }: {
+        children: ReactNode;
+    }) => import("react").JSX.Element;
+    getEdgeById(id: string): Edge | undefined;
+    getNodeById(id: string): Node<import('./types').TOrientation> | undefined;
+    get showGrid(): boolean;
+    getExtension<T extends DiagramExtension>(e: Class<T>): T;
+    registerExtension(e: Class<DiagramExtension>): void;
+    toggleGrid(): void;
+    static use: () => Diagram;
+    export(): string;
+    reset(): Promise<boolean>;
+    serialize(): {
+        position: {
+            x: number;
+            y: number;
+            scale: number;
+        };
+        nodes: {
+            box: [number, number, number, number];
+            id: string;
+            label: string;
+            movable: boolean | undefined;
+            selectable: boolean | undefined;
+            selected: boolean | undefined;
+            gateways: {
+                coordinates: [number, number];
+                fill: string | undefined;
+                id: string;
+                orientation: import('./types').TOrientation;
+                radius: number;
+                stroke: string | undefined;
+                strokeWidth: number;
+                outEdges: {
+                    arrowHeadEnd: import('./types').EdgeArrowHead | undefined;
+                    arrowHeadStart: import('./types').EdgeArrowHead | undefined;
+                    displacementEnd: [number, number] | undefined;
+                    displacementStart: [number, number] | undefined;
+                    lineStyle: import('./types').EdgeLineStyle | undefined;
+                    pathType: import('./types').EdgePathType | undefined;
+                    steps: import('./elements/EdgePoint').TSerializedEdgePoint[];
+                    stroke: string | undefined;
+                    strokeWidth: number | undefined;
+                    to: string;
+                    toParentId: string;
+                    class: string;
+                }[];
+                class: string;
+            }[];
+            fill: string | undefined;
+            labelFontSize: number | undefined;
+            stroke: string | undefined;
+            strokewWidth: number | undefined;
+            class: string;
+        }[];
+    };
+    import(w: string): void;
+    paste(w: string): void;
+    focusContentInViewport(padding?: number): boolean;
+    focusContentInViewportWithRetry(attempts?: number, delayMs?: number): void;
+}
+export {};

package/dist/Diagrams/store/elements/Edge.d.ts

@@ -0,0 +1,42 @@
+import { TEdgeState } from '../types';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgePoint, TSerializedEdgePoint } from './EdgePoint';
+import { Element } from './Element';
+import { Midpoint } from '../../components/objects/RenderEdge';
+import { MouseEvent } from 'react';
+import { Dimensions } from '../primitives/Dimensions';
+export declare class Edge extends Element {
+    state: TEdgeState;
+    id: Readonly<string>;
+    constructor(parent: Element | null, state: TEdgeState);
+    get arrowHeadEnd(): import('../types').EdgeArrowHead | undefined;
+    get arrowHeadStart(): import('../types').EdgeArrowHead | undefined;
+    get from(): import('./Gateway').Gateway;
+    get hasManualSteps(): EdgePoint | undefined;
+    get lineStyle(): import('../types').EdgeLineStyle | undefined;
+    get pathType(): import('../types').EdgePathType | undefined;
+    get steps(): EdgePoint[];
+    get stroke(): string | undefined;
+    get strokeWidth(): number | undefined;
+    collides(box: Dimensions): boolean;
+    setState<K extends keyof TEdgeState>(prop: K, value: TEdgeState[K]): void;
+    setSteps(steps: Coordinates[]): void;
+    get to(): import('./Gateway').Gateway;
+    deserialize(o: ReturnType<(typeof this)['serialize']>): void;
+    serialize(): {
+        arrowHeadEnd: import('../types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../types').EdgeLineStyle | undefined;
+        pathType: import('../types').EdgePathType | undefined;
+        steps: TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    dragStart(midpoint: Midpoint, ev: MouseEvent): void;
+    dragEndpoint(endpoint: 'from' | 'to', ev: MouseEvent): void;
+}

package/dist/Diagrams/store/elements/EdgePoint.d.ts

@@ -0,0 +1,19 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { Element } from './Element';
+import { AnyMouseEvent } from './Events';
+export type TEdgePointType = 'auto' | 'manual' | 'static';
+export type TEdgePointManualAxes = 'none' | 'x' | 'y' | 'both';
+export type TSerializedEdgePoint = [number, number, TEdgePointType] | [number, number, TEdgePointType, TEdgePointManualAxes];
+export declare class EdgePoint extends Coordinates {
+    parent: Element | null;
+    mode: TEdgePointType;
+    manualAxes: TEdgePointManualAxes;
+    constructor(parent: Element | null, items?: AnyMouseEvent | Event | Coordinates | number[] | TSerializedEdgePoint);
+    get manualX(): boolean;
+    get manualY(): boolean;
+    addManualAxis(axis: 'x' | 'y' | 'both'): this;
+    hasManualAxis(axis: 'x' | 'y'): boolean;
+    markStatic(): this;
+    copy(): EdgePoint;
+    toString(includeMode?: boolean): string;
+}

package/dist/Diagrams/store/elements/Element.d.ts

@@ -0,0 +1,19 @@
+import { Diagram } from '../Diagram';
+import { DEvent } from './Events';
+export type Callback<X extends DEvent> = (ev: X) => unknown;
+export type AbstractClass<X> = abstract new (...args: any[]) => X;
+export type Class<X> = new (...args: any[]) => X;
+interface PrioritizedCallback<X extends DEvent = DEvent> {
+    cb: Callback<X>;
+    priority: number;
+}
+export declare class Element {
+    parent: Element | null;
+    constructor(parent: Element | null);
+    protected callbacks: Map<AbstractClass<any>, PrioritizedCallback<any>[]>;
+    protected emit(ev: DEvent): DEvent;
+    get diagram(): Diagram | null;
+    onEvent<X extends DEvent>(type: AbstractClass<X>, cb: Callback<X>, priority?: number): () => void;
+    offEvent<X extends DEvent = DEvent>(type: AbstractClass<X>, cb: Callback<X>): void;
+}
+export {};