@focus.matters/diagrams 0.1.1 → 0.2.1

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDocumentNode.d.ts

@@ -0,0 +1,71 @@
+import { DocumentNode } from '../../bpmn/nodes/DocumentNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN data object with optional execution metadata support. */
+export declare class BPMNExecutionDocumentNode extends DocumentNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof DocumentNode>[0], state: ConstructorParameters<typeof DocumentNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside normal data-object semantics. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/DocumentNode').DataObjectTypes;
+        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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores data-object state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionEventNode.d.ts

@@ -0,0 +1,81 @@
+import { EventNode } from '../../bpmn/nodes/EventNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN event with independent process execution state. */
+export declare class BPMNExecutionEventNode extends EventNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof EventNode>[0], state: ConstructorParameters<typeof EventNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN event. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/BPMNEventDefinition').EventTypes;
+        eventDefinition: Readonly<{
+            stage: import('../../bpmn/nodes/BPMNEventDefinition').EventStage;
+            kind: import('../../bpmn/nodes/BPMNEventDefinition').EventKind;
+            direction: import('../../bpmn/nodes/BPMNEventDefinition').EventDirection;
+        }>;
+        attachedToTaskId: string | null;
+        attachmentOffset: import('../../bpmn/nodes/EventNode').EventAttachmentOffset | null;
+        interrupting: boolean;
+        subprocessStart: boolean;
+        subprocessId: string | null;
+        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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores event semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionGateNode.d.ts

@@ -0,0 +1,71 @@
+import { GateNode } from '../../bpmn/nodes/GateNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN gateway with runtime token and synchronization state. */
+export declare class BPMNExecutionGateNode extends GateNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof GateNode>[0], state: ConstructorParameters<typeof GateNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN gateway. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/GateNode').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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores gateway semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionLanes.d.ts

@@ -0,0 +1,14 @@
+import { Lanes } from '../../bpmn/nodes/Lanes';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends standard BPMN lanes while retaining the complete pool and lane behavior. */
+export declare class BPMNExecutionLanes extends Lanes {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof Lanes>[0], state: ConstructorParameters<typeof Lanes>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution metadata together with the complete lane and pool model. */
+    serialize(): any;
+    /** Restores lane structure before applying independently stored execution metadata. */
+    deserialize(state: any): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionTaskNode.d.ts

@@ -0,0 +1,76 @@
+import { TaskNode } from '../../bpmn/nodes/TaskNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN activity with independent process execution state. */
+export declare class BPMNExecutionTaskNode extends TaskNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof TaskNode>[0], state: ConstructorParameters<typeof TaskNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN task. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/TaskNode').TaskTypes;
+        multiInstance: import('../../bpmn/nodes/TaskNode').TaskMultiInstance;
+        loop: boolean;
+        compensation: boolean;
+        adHoc: boolean;
+        transaction: boolean;
+        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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores task semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionTextAnnotationNode.d.ts

@@ -0,0 +1,70 @@
+import { TextAnnotationNode } from '../../bpmn/nodes/TextAnnotationNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN text annotation with optional execution metadata support. */
+export declare class BPMNExecutionTextAnnotationNode extends TextAnnotationNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof TextAnnotationNode>[0], state: ConstructorParameters<typeof TextAnnotationNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside normal text annotation state. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores annotation state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionUnknownNode.d.ts

@@ -0,0 +1,71 @@
+import { UnknownBPMNNode } from '../../bpmn/nodes/UnknownBPMNNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends unsupported imported BPMN elements so execution snapshots remain lossless. */
+export declare class BPMNExecutionUnknownNode extends UnknownBPMNNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof UnknownBPMNNode>[0], state: ConstructorParameters<typeof UnknownBPMNNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution metadata while preserving the unsupported source type. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        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;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | 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;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores unknown BPMN state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/promoteBPMNExecutionEdge.d.ts

@@ -0,0 +1,3 @@
+import { Edge } from '../../store/elements/Edge';
+/** Promotes externally constructed BPMN edges while preserving their endpoint references. */
+export declare function promoteBPMNExecutionEdge<T extends Edge>(edge: T): T;

package/dist/src/Diagrams/custom/bpmnExecution/promoteBPMNExecutionNode.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '../../store/elements/Node';
+/** Promotes catalog-created BPMN nodes in place while preserving all external references. */
+export declare function promoteBPMNExecutionNode<T extends Node>(node: T): T;

package/dist/src/Diagrams/custom/bpmnExecution/types.d.ts

@@ -0,0 +1,38 @@
+export type BPMNExecutionStatus = "idle" | "active" | "waiting" | "completed" | "failed";
+export type BPMNExecutionMarkerKind = "token" | "error" | "waiting" | "completed" | (string & {});
+export type BPMNExecutionMarkerSnapshot = {
+    id?: string;
+    kind: BPMNExecutionMarkerKind;
+    value?: number | string | null;
+    message?: string;
+    color?: string;
+};
+export type BPMNNodeExecutionSnapshot = {
+    status?: BPMNExecutionStatus;
+    tokenCount?: number;
+    error?: string | null;
+    markers?: BPMNExecutionMarkerSnapshot[];
+};
+export type BPMNEdgeExecutionSnapshot = {
+    visited?: boolean;
+    visitCount?: number;
+    visitedAt?: string | null;
+};
+export type BPMNExecutionSnapshot = {
+    version?: 1;
+    replace?: boolean;
+    nodes?: Record<string, BPMNNodeExecutionSnapshot>;
+    edges?: Record<string, BPMNEdgeExecutionSnapshot>;
+};
+export type BPMNExecutionApplyResult = {
+    appliedNodes: number;
+    appliedEdges: number;
+    unresolvedNodeIds: string[];
+    unresolvedEdgeIds: string[];
+};
+export type BPMNExecutionSettings = {
+    visitedEdgeColor: string;
+    tokenColor: string;
+    errorColor: string;
+};
+export type BPMNExecutionSettingsInput = Partial<BPMNExecutionSettings>;

package/dist/src/Diagrams/custom/bpmnExecution/ui/BPMNExecutionMarkers.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNExecutionExtension } from '../BPMNExecutionExtension';
+/** Renders token, exception, and future custom badges at each node's top-right edge. */
+export declare const BPMNExecutionMarkers: (({ diagram, }: TDiagramExtensionRenderProps<BPMNExecutionExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/bpmnExecution/ui/BPMNExecutionPropertiesPanel.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNModelerExtension } from '../../bpmn/extensions/BPMNModelerExtension';
+/** Adds execution fields as a collapsible section in the standard BPMN inspector. */
+export declare const BPMNExecutionPropertiesPanel: (({ diagram, extension, }: TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/mr/MRDiagram.d.ts

@@ -0,0 +1,17 @@
+import { TDiagramSettings } from '../../store/Diagram';
+import { EditableDiagram } from '../editable/EditableDiagram';
+import { MRForeignKeyEdge } from './edges/MRForeignKeyEdge';
+import { MRTableNode } from './nodes/MRTableNode';
+import { MRForeignKeyModel, MRTableKind } from './types';
+/** Configures an editable relational/UML data model with tables and foreign keys. */
+export declare class MRDiagram extends EditableDiagram {
+    constructor(settings?: TDiagramSettings);
+    /** Creates and selects one table centered on an exact client-space point. */
+    createTableFromClientPoint(kind: MRTableKind, clientX: number, clientY: number, label?: string): MRTableNode;
+    /** Creates and selects one table centered on an exact canvas-space point. */
+    createTableAtCanvasPoint(kind: MRTableKind, x: number, y: number, label?: string): MRTableNode;
+    /** Arranges relational dependencies in readable left-to-right Dagre layers. */
+    autoLayout(): boolean;
+    /** Connects a dependent table to a referenced table with foreign-key metadata. */
+    connectForeignKey(source: MRTableNode, target: MRTableNode, model?: Partial<MRForeignKeyModel>): MRForeignKeyEdge;
+}

package/dist/src/Diagrams/custom/mr/edges/MRForeignKeyEdge.d.ts

@@ -0,0 +1,77 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Element } from '../../../store/elements/Element';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { TEdgeState } from '../../../store/types';
+import { MRCardinality, MRForeignKeyModel, MRMatchType, MRReferentialAction } from '../types';
+type MRForeignKeyEdgeState = Partial<TEdgeState> & Partial<MRForeignKeyModel>;
+/** Models one relational foreign-key constraint on top of a routed diagram edge. */
+export declare class MRForeignKeyEdge extends Edge {
+    constraintId: string;
+    mappingIndex: number;
+    name: string;
+    sourceAttributeIds: string[];
+    targetAttributeIds: string[];
+    sourceCardinality: MRCardinality;
+    targetCardinality: MRCardinality;
+    onDelete: MRReferentialAction;
+    onUpdate: MRReferentialAction;
+    matchType: MRMatchType;
+    identifying: boolean;
+    deferrable: boolean;
+    initiallyDeferred: boolean;
+    constructor(parent: Element | null, state: MRForeignKeyEdgeState);
+    /** Updates foreign-key semantics and refreshes its identifying line style. */
+    updateModel(patch: Partial<MRForeignKeyModel>): void;
+    /** Stores a first route and positions the generated constraint label at its midpoint. */
+    setSteps(steps: Coordinates[]): void;
+    private applyStyle;
+    /** Serializes every referential action, mapping, cardinality, and edge route. */
+    serialize(): {
+        constraintId: string;
+        mappingIndex: number;
+        name: string;
+        sourceAttributeIds: string[];
+        targetAttributeIds: string[];
+        sourceCardinality: MRCardinality;
+        targetCardinality: MRCardinality;
+        onDelete: MRReferentialAction;
+        onUpdate: MRReferentialAction;
+        matchType: MRMatchType;
+        identifying: boolean;
+        deferrable: boolean;
+        initiallyDeferred: boolean;
+        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;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: import('../../../store/types').EdgePathType;
+        startAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    /** Restores foreign-key semantics after generic edge routing has been imported. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}
+export {};