@focus.matters/diagrams 0.0.7

package/dist/Diagrams/DiagramEditor.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { Diagram } from './store/Diagram';
+type DiagramEditorProps = {
+    diagram: Diagram;
+    leftPanel?: ReactNode;
+    toolbar?: ReactNode;
+};
+export declare const DiagramEditor: (({ diagram, leftPanel, toolbar }: DiagramEditorProps) => import("react").JSX.Element) & {
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export declare const Canvas: (({ children }: {
+    children?: ReactNode;
+}) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/Diagrams/components/extra/AlignmentSuggestions.d.ts

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

package/dist/Diagrams/components/extra/GatewayRender.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+import { Gateway } from '../../store/elements/Gateway';
+export declare const GatewayRender: ({ gateway, }: {
+    gateway: Gateway;
+}) => ReactElement;

package/dist/Diagrams/components/extra/Measurement.d.ts

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

package/dist/Diagrams/components/extra/MouseTracker.d.ts

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

package/dist/Diagrams/components/extra/NodesConnectorRenderer.d.ts

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

package/dist/Diagrams/components/extra/PathFindingRenderer.d.ts

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

package/dist/Diagrams/components/extra/Selection.d.ts

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

package/dist/Diagrams/components/extra/Stats.d.ts

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

package/dist/Diagrams/components/extra/Svg.d.ts

@@ -0,0 +1,2 @@
+import { SVGProps } from 'react';
+export declare const Svg: import('react').ForwardRefExoticComponent<Omit<SVGProps<SVGSVGElement>, "ref"> & import('react').RefAttributes<any>>;

package/dist/Diagrams/components/extra/Theme.d.ts

@@ -0,0 +1,8 @@
+export declare class Theme {
+    static instance: Theme;
+    isLight: boolean;
+    private constructor();
+    _get(): boolean;
+    get(): boolean;
+    toggle(): void;
+}

package/dist/Diagrams/components/extra/ToolsState.d.ts

@@ -0,0 +1,5 @@
+export declare class ToolsStates {
+    static instance: ToolsStates;
+    showDragHints: boolean;
+    private constructor();
+}

package/dist/Diagrams/components/nodes/NodeTools.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare const NodeTools: ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;

package/dist/Diagrams/components/objects/Cross.d.ts

@@ -0,0 +1,9 @@
+import { Coordinates } from '../../store/primitives/Coordinates';
+export interface RedCrossProps {
+    coordinates: Coordinates;
+    size?: number;
+    strokeWidth?: number;
+    rounded?: boolean;
+    stroke?: string;
+}
+export declare const Cross: React.FC<RedCrossProps>;

package/dist/Diagrams/components/objects/CustomRenderers.d.ts

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

package/dist/Diagrams/components/objects/Grid.d.ts

@@ -0,0 +1 @@
+export declare const Grid: () => null;

package/dist/Diagrams/components/objects/RenderEdge/EdgeMarker.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { EdgeArrowHead } from '../../../store/types';
+interface EdgeMarkerProps {
+    id: string;
+    color?: string;
+    type: EdgeArrowHead;
+    width: number;
+    arrowSize: number;
+    flip?: boolean;
+}
+export declare const EdgeMarker: React.FC<EdgeMarkerProps>;
+export {};

package/dist/Diagrams/components/objects/RenderEdge/EdgeMidpoints.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Midpoint } from './types';
+import { Edge } from '../../../store/elements/Edge';
+interface EdgeMidpointsProps {
+    edge: Edge;
+    onMouseDown: (m: Midpoint, ev: React.MouseEvent) => unknown;
+    points: Coordinates[];
+}
+export declare const EdgeMidpoints: React.FC<EdgeMidpointsProps>;
+export {};

package/dist/Diagrams/components/objects/RenderEdge/debugEdges.d.ts

@@ -0,0 +1,14 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Midpoint } from './types';
+type DebugClickTarget = {
+    type: 'edge';
+} | {
+    type: 'drag-point';
+    midpoint: Midpoint;
+    renderedIndex: number;
+} | {
+    type: 'endpoint';
+    endpoint: 'from' | 'to';
+};
+export declare function copyEdgeDebugToClipboard(edge: Edge | undefined, target: DebugClickTarget): void;
+export {};

package/dist/Diagrams/components/objects/RenderEdge/index.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { RenderEdgeProps } from './types';
+export type * from './types';
+export declare const RenderEdge: React.FC<RenderEdgeProps>;

package/dist/Diagrams/components/objects/RenderEdge/types.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { EdgeArrowHead, EdgeLineStyle } from '../../../store/types';
+import { EdgePoint } from '../../../store/elements/EdgePoint';
+import { Edge } from '../../../store/elements/Edge';
+import { AnyMouseEvent } from '../../../store/elements/Events';
+export interface RenderEdgeProps {
+    edge?: Edge;
+    points: (Coordinates | EdgePoint)[];
+    color?: string;
+    width?: number;
+    arrowSize?: number;
+    className?: string;
+    endStroke?: string;
+    startStroke?: string;
+    startType?: EdgeArrowHead;
+    endType?: EdgeArrowHead;
+    lineStyle?: EdgeLineStyle;
+    draggable?: boolean;
+    onMidpointMouseDown?: (p: Midpoint, ev: React.MouseEvent) => void;
+    onEndpointMouseDown?: (endpoint: 'from' | 'to', ev: React.MouseEvent) => void;
+}
+export declare class Midpoint extends Coordinates {
+    id: string;
+    edge: Edge;
+    points: [Coordinates, Coordinates];
+    constructor(id: string, edge: Edge, points: [Coordinates, Coordinates], items?: AnyMouseEvent | Event | Coordinates | number[]);
+    copy(): Midpoint;
+}

package/dist/Diagrams/components/objects/RenderEdge/util.d.ts

@@ -0,0 +1,6 @@
+import { Edge } from '../../../store/elements/Edge';
+import { EdgePoint } from '../../../store/elements/EdgePoint';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Midpoint } from './types';
+export declare function arePointsAligned(p1: Coordinates, p2: Coordinates, p3: Coordinates): boolean;
+export declare function getSegmentMidpoints(edge: Edge, points: (Coordinates | EdgePoint)[]): Midpoint[];

package/dist/Diagrams/components/objects/Shape.d.ts

@@ -0,0 +1,49 @@
+import { default as React, MouseEventHandler, ReactNode, SVGProps } from 'react';
+import { Coordinates } from '../../store/primitives/Coordinates';
+/**
+ * Estilo del borde: sólido, rayado o punteado.
+ */
+export type StrokeStyle = 'solid' | 'dashed' | 'dotted';
+export type ArrowPosition = 'start' | 'end' | 'both';
+export interface ArrowSpec {
+    position?: ArrowPosition;
+    size?: number;
+    color?: string;
+    filled?: boolean;
+    sharpness?: number;
+}
+/**
+ * Configuración de un path individual dentro del Shape.
+ */
+export interface PathSpec {
+    /** Atributo SVG "d" */
+    d: string;
+    arrow?: ArrowSpec;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    strokeStyle?: StrokeStyle;
+    animated?: boolean;
+    animationDuration?: number;
+    nonScalingStroke?: boolean;
+    roundedBorders?: boolean;
+}
+export interface ShapeProps extends SVGProps<SVGGElement> {
+    paths: PathSpec[];
+    transform?: string;
+    selected?: boolean;
+    onClick?: React.MouseEventHandler<SVGGElement>;
+    className?: string;
+    roundedBorders?: boolean;
+    label?: string;
+    labelColor?: string;
+    labelFontSize?: number;
+    labelFontFamily?: string;
+    labelOffset?: Coordinates;
+    onMouseDown?: MouseEventHandler<SVGGElement>;
+    'data-id'?: string;
+    children?: ReactNode;
+}
+declare const UnobservedShape: React.ForwardRefExoticComponent<Omit<ShapeProps, "ref"> & React.RefAttributes<any>>;
+export declare const Shape: typeof UnobservedShape;
+export {};

package/dist/Diagrams/components/objects/Shapes.d.ts

@@ -0,0 +1 @@
+export declare function shapes(): import("react").JSX.Element[];

package/dist/Diagrams/components/objects/customRendererProps.d.ts

@@ -0,0 +1,7 @@
+import { Node } from '../../store/elements/Node';
+type DivProps = React.DetailedHTMLProps<React.HTMLAttributes<any>, any> & {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export declare function customRendererStyles(node: Node<any>): React.DetailedHTMLProps<React.HTMLAttributes<any>, any>['style'];
+export declare function customRendererProps(node: Node<any>): DivProps;
+export {};

package/dist/Diagrams/components/objects/makeScalableComponent.d.ts

@@ -0,0 +1,2 @@
+export declare function makeScalableComponent<T extends object>(c: T): T;
+export declare function makeBackScalableComponent<T extends object>(c: T): T;

package/dist/Diagrams/context-menu/ContextMenu.d.ts

@@ -0,0 +1,22 @@
+import { ContextMenuElement, ContextMenuOpenOptions } from './types';
+type Position = {
+    x: number;
+    y: number;
+};
+declare class ContextMenuStore {
+    private _elements;
+    private _opened;
+    private _position;
+    private _openVersion;
+    readonly Component: () => import("react").JSX.Element;
+    constructor();
+    get elements(): ContextMenuElement[];
+    get opened(): boolean;
+    get position(): Position;
+    get openVersion(): number;
+    open(elements: ContextMenuElement[], options?: ContextMenuOpenOptions): void;
+    close(): void;
+    execute(item: ContextMenuElement): void;
+}
+export declare const ContextMenu: ContextMenuStore;
+export {};

package/dist/Diagrams/context-menu/buildDiagramContextMenu.d.ts

@@ -0,0 +1,6 @@
+import { Diagram } from '../store/Diagram';
+import { ContextMenuElement } from './types';
+export declare function buildDiagramContextMenu(diagram: Diagram, target: HTMLElement, cursor: {
+    x: number;
+    y: number;
+}): ContextMenuElement[];

package/dist/Diagrams/context-menu/index.d.ts

@@ -0,0 +1,3 @@
+export { ContextMenu } from './ContextMenu';
+export { buildDiagramContextMenu } from './buildDiagramContextMenu';
+export type { ContextMenuAction, ContextMenuElement, ContextMenuOpenOptions, } from './types';

package/dist/Diagrams/context-menu/types.d.ts

@@ -0,0 +1,12 @@
+export type ContextMenuAction = () => void | Promise<void>;
+export interface ContextMenuElement {
+    label: string;
+    onClick: ContextMenuAction;
+    submenu?: ContextMenuElement[];
+    disabled?: boolean;
+    danger?: boolean;
+}
+export interface ContextMenuOpenOptions {
+    x?: number;
+    y?: number;
+}

package/dist/Diagrams/custom/agent/AgentDiagram.d.ts

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

package/dist/Diagrams/custom/agent/edges/AgentEdge.d.ts

@@ -0,0 +1,32 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Element } from '../../../store/elements/Element';
+import { TEdgeState } from '../../../store/types';
+import { AgentEdgeKind } from '../types';
+type AgentEdgeState = Partial<TEdgeState> & {
+    kind?: AgentEdgeKind;
+};
+type AgentSerializedEdge = ReturnType<Edge['serialize']> & {
+    kind?: AgentEdgeKind;
+};
+export declare class AgentEdge extends Edge {
+    kind: AgentEdgeKind;
+    constructor(parent: Element | null, state: AgentEdgeState);
+    setKind(kind: AgentEdgeKind): void;
+    serialize(): {
+        kind: AgentEdgeKind;
+        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: AgentSerializedEdge): void;
+}
+export {};

package/dist/Diagrams/custom/agent/index.d.ts

@@ -0,0 +1,2 @@
+export { AgentDiagram } from './AgentDiagram';
+export type * from './types';

package/dist/Diagrams/custom/agent/nodes/ActionNode.d.ts

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { ActionPayload } from '../types';
+import { AgentNode } from './AgentNode';
+export declare class ActionNode extends AgentNode<ActionPayload> {
+    readonly kind: "action";
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        payload?: Partial<ActionPayload>;
+    });
+    protected defaultPayload(): ActionPayload;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/agent/nodes/AgentNode.d.ts

@@ -0,0 +1,58 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { EditableNode } from '../../editable/EditableNode';
+import { AgentNodeKind } from '../types';
+type AgentNodeConstructorProps<TPayload> = TNodeConstructorProps & {
+    payload?: Partial<TPayload>;
+};
+export declare abstract class AgentNode<TPayload> extends EditableNode {
+    abstract readonly kind: AgentNodeKind;
+    payload: TPayload;
+    constructor(parent: Element | null, state: AgentNodeConstructorProps<TPayload>);
+    protected abstract defaultPayload(): TPayload;
+    protected mergePayload(payload?: Partial<TPayload>): TPayload;
+    replacePayload(payload: TPayload): void;
+    updatePayload(patch: Partial<TPayload>): void;
+    serialize(): {
+        kind: AgentNodeKind;
+        payload: TPayload;
+        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<(typeof this)['serialize']>): void;
+}
+export declare function isAgentNode(node: unknown): node is AgentNode<unknown>;
+export {};

package/dist/Diagrams/custom/agent/nodes/ConditionNode.d.ts

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { ConditionPayload } from '../types';
+import { AgentNode } from './AgentNode';
+export declare class ConditionNode extends AgentNode<ConditionPayload> {
+    readonly kind: "condition";
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        payload?: Partial<ConditionPayload>;
+    });
+    protected defaultPayload(): ConditionPayload;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/agent/nodes/OutcomeNode.d.ts

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { OutcomePayload } from '../types';
+import { AgentNode } from './AgentNode';
+export declare class OutcomeNode extends AgentNode<OutcomePayload> {
+    readonly kind: "outcome";
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        payload?: Partial<OutcomePayload>;
+    });
+    protected defaultPayload(): OutcomePayload;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/Diagrams/custom/agent/nodes/TriggerNode.d.ts

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { TriggerPayload } from '../types';
+import { AgentNode } from './AgentNode';
+export declare class TriggerNode extends AgentNode<TriggerPayload> {
+    readonly kind: "trigger";
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        payload?: Partial<TriggerPayload>;
+    });
+    protected defaultPayload(): TriggerPayload;
+    protected Render: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

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

@@ -0,0 +1,54 @@
+import { TOrientation } from '../../store/types';
+export type AgentNodeKind = 'trigger' | 'action' | 'condition' | 'outcome';
+export type AgentEdgeKind = 'default' | 'condition-true' | 'condition-false' | 'trigger';
+export type AgentMetadata = Record<string, string | number | boolean>;
+export type TriggerPayload = {
+    triggerType: 'manual' | 'event' | 'schedule';
+    source: string;
+    eventName: string;
+    schedule: string;
+    metadata?: AgentMetadata;
+};
+export type ActionPayload = {
+    actionType: 'task' | 'api' | 'notification' | 'human';
+    operation: string;
+    inputRef: string;
+    outputRef: string;
+    metadata?: AgentMetadata;
+};
+export type ConditionPayload = {
+    expression: string;
+    language: 'rule' | 'javascript' | 'jsonpath';
+    trueLabel: string;
+    falseLabel: string;
+    metadata?: AgentMetadata;
+};
+export type OutcomePayload = {
+    status: 'success' | 'failure' | 'neutral';
+    code: string;
+    summary: string;
+    metadata?: AgentMetadata;
+};
+export type AgentPayloadByKind = {
+    trigger: TriggerPayload;
+    action: ActionPayload;
+    condition: ConditionPayload;
+    outcome: OutcomePayload;
+};
+export type AgentPayload = AgentPayloadByKind[AgentNodeKind];
+export type AgentCreateNodeInput<K extends AgentNodeKind = AgentNodeKind> = {
+    kind: K;
+    label?: string;
+    payload?: Partial<AgentPayloadByKind[K]>;
+};
+export type AgentConnectInput = {
+    fromNodeId: string;
+    toNodeId: string;
+    fromGateway?: TOrientation;
+    toGateway?: TOrientation;
+    kind?: AgentEdgeKind;
+};
+export type AgentTemplateResult = {
+    nodeIds: string[];
+    edgeIds: string[];
+};

package/dist/Diagrams/custom/bpmn/BPMDiagram.d.ts

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

package/dist/Diagrams/custom/bpmn/bpmnEvents.d.ts

@@ -0,0 +1,3 @@
+import { DChangeEvent } from '../../store/elements/Events';
+export declare class AddLaneEvent extends DChangeEvent {
+}

package/dist/Diagrams/custom/bpmn/edges/EdgeWithLoad.d.ts

@@ -0,0 +1,4 @@
+import { Edge } from '../../../store/elements/Edge';
+export declare class EdgeWithLoad extends Edge {
+    setLoad(h: number): void;
+}

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

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

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

@@ -0,0 +1,6 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { EditableNode } from '../../editable/EditableNode';
+export declare abstract class BPMNode extends EditableNode {
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+}

package/dist/Diagrams/custom/bpmn/nodes/EventNode.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 EventTypes {
+    start = 0,
+    end = 1,
+    intermediate = 2
+}
+export type TEventNodeType = EventTypes;
+export declare class EventNode extends BPMNode {
+    type: TEventNodeType;
+    constructor(parent: Element | null, state: TNodeConstructorProps & {
+        type?: TEventNodeType;
+    });
+    setType(type: TEventNodeType): void;
+    serialize(): {
+        type: EventTypes;
+        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;
+    };
+}