@likec4/diagram 1.28.1 → 1.29.1

package/dist/state/diagram-machine.d.ts

@@ -808,6 +808,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
         type: "enabled: Readonly";
         params: unknown;
     };
+    "enabled: RelationshipDetails": {
+        type: "enabled: RelationshipDetails";
+        params: unknown;
+    };
     "not readonly": {
         type: "not readonly";
         params: unknown;
@@ -836,6 +840,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
         type: "click: node has connections";
         params: unknown;
     };
+    "click: selected edge": {
+        type: "click: selected edge";
+        params: unknown;
+    };
 }>, never, "isReady" | "initializing" | "navigating" | {
     ready: "idle" | "walkthrough" | "focused";
 }, string, Input, NonReducibleUnknown, EventObject, MetaObject, {
@@ -5168,6 +5176,19 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             }>, never, never, never, never>;
                             readonly target: "focused";
                         };
+                        readonly 'xyflow.edgeClick': readonly [{
+                            readonly guard: any;
+                            readonly actions: ActionFunction<Context, {
+                                type: "xyflow.edgeClick";
+                                edge: Types.Edge;
+                            }, Events, undefined, never, never, never, never, never>;
+                        }, {
+                            readonly guard: any;
+                            readonly actions: ActionFunction<Context, {
+                                type: "xyflow.edgeClick";
+                                edge: Types.Edge;
+                            }, Events, undefined, never, never, never, never, never>;
+                        }];
                     };
                 };
                 readonly focused: {
@@ -6058,6 +6079,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "enabled: Readonly";
                             params: unknown;
                         };
+                        "enabled: RelationshipDetails": {
+                            type: "enabled: RelationshipDetails";
+                            params: unknown;
+                        };
                         "not readonly": {
                             type: "not readonly";
                             params: unknown;
@@ -6086,6 +6111,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "click: node has connections";
                             params: unknown;
                         };
+                        "click: selected edge": {
+                            type: "click: selected edge";
+                            params: unknown;
+                        };
                     }>, never, EventObject>;
                     readonly on: {
                         readonly 'xyflow.nodeClick': readonly [{
@@ -8542,6 +8571,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                                     type: "enabled: Readonly";
                                     params: unknown;
                                 };
+                                "enabled: RelationshipDetails": {
+                                    type: "enabled: RelationshipDetails";
+                                    params: unknown;
+                                };
                                 "not readonly": {
                                     type: "not readonly";
                                     params: unknown;
@@ -8570,11 +8603,16 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                                     type: "click: node has connections";
                                     params: unknown;
                                 };
+                                "click: selected edge": {
+                                    type: "click: selected edge";
+                                    params: unknown;
+                                };
                             }>, never, EventObject>;
                         };
-                        readonly 'notations.unhighlight': {
-                            readonly actions: ActionFunction<Context, {
-                                type: "notations.unhighlight";
+                        readonly 'xyflow.edgeClick': {
+                            readonly actions: readonly [ ActionFunction<Context, {
+                                type: "xyflow.edgeClick";
+                                edge: Types.Edge;
                             }, Events, undefined, Values<{
                                 syncManualLayoutActorLogic: {
                                     src: "syncManualLayoutActorLogic";
@@ -8828,159 +8866,670 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                                     }>;
                                     id: "overlays";
                                 };
-                            }>, never, never, never, never>;
-                        };
-                        readonly 'walkthrough.end': {
-                            readonly target: "idle";
-                        };
-                        readonly 'xyflow.paneDblClick': {
-                            readonly target: "idle";
-                        };
-                        readonly 'update.view': {
-                            readonly guard: "is another view";
-                            readonly actions: ActionFunction<Context, {
-                                type: "update.view";
-                                view: DiagramView;
-                                xynodes: Types.Node[];
-                                xyedges: Types.Edge[];
-                            }, Events, undefined, never, never, never, never, never>;
-                            readonly target: "idle";
-                        };
-                    };
-                    readonly exit: ActionFunction<Context, Events, Events, undefined, Values<{
-                        syncManualLayoutActorLogic: {
-                            src: "syncManualLayoutActorLogic";
-                            logic: StateMachine<Readonly< Input>, SyncLayoutEvents, {}, never, {
-                                type: "trigger:OnChange";
-                                params: {
-                                    change: ViewChange;
-                                };
-                            }, {
-                                type: "same view";
-                                params: unknown;
-                            }, "timeout", "synced" | "pending" | "stopped" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
-                                readonly initial: "idle";
-                                readonly context: ({ input }: {
-                                    spawn: {
-                                        <TSrc extends never>(logic: TSrc, ...[options]: never): ActorRefFromLogic<never>;
-                                        <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
-                                            id?: never;
-                                            systemId?: string;
-                                            input?: InputFrom<TLogic>;
-                                            syncSnapshot?: boolean;
-                                        } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
-                                    };
-                                    input: Input;
-                                    self: ActorRef< MachineSnapshot<Readonly< Input>, SyncLayoutEvents, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, SyncLayoutEvents, AnyEventObject>;
-                                }) => {
-                                    parent: ActorRef< MachineSnapshot<Context, Events, any, any, any, any, any, any>, Events, any>;
-                                    viewId: ViewId;
-                                };
-                                readonly states: {
-                                    readonly idle: {
-                                        readonly tags: "ready";
-                                        readonly on: {
-                                            readonly sync: {
-                                                readonly target: "pending";
-                                            };
+                            }>, never, never, never, never>, ActionFunction<Context, Events, Events, undefined, Values<{
+                                syncManualLayoutActorLogic: {
+                                    src: "syncManualLayoutActorLogic";
+                                    logic: StateMachine<Readonly< Input>, SyncLayoutEvents, {}, never, {
+                                        type: "trigger:OnChange";
+                                        params: {
+                                            change: ViewChange;
                                         };
-                                    };
-                                    readonly paused: {
-                                        readonly tags: "pending";
-                                        readonly on: {
-                                            readonly sync: {
-                                                readonly target: "pending";
+                                    }, {
+                                        type: "same view";
+                                        params: unknown;
+                                    }, "timeout", "synced" | "pending" | "stopped" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
+                                        readonly initial: "idle";
+                                        readonly context: ({ input }: {
+                                            spawn: {
+                                                <TSrc extends never>(logic: TSrc, ...[options]: never): ActorRefFromLogic<never>;
+                                                <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
+                                                    id?: never;
+                                                    systemId?: string;
+                                                    input?: InputFrom<TLogic>;
+                                                    syncSnapshot?: boolean;
+                                                } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
                                             };
+                                            input: Input;
+                                            self: ActorRef< MachineSnapshot<Readonly< Input>, SyncLayoutEvents, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, SyncLayoutEvents, AnyEventObject>;
+                                        }) => {
+                                            parent: ActorRef< MachineSnapshot<Context, Events, any, any, any, any, any, any>, Events, any>;
+                                            viewId: ViewId;
                                         };
-                                    };
-                                    readonly pending: {
-                                        readonly tags: "pending";
-                                        readonly on: {
-                                            readonly sync: {
-                                                readonly target: "pending";
-                                                readonly reenter: true;
+                                        readonly states: {
+                                            readonly idle: {
+                                                readonly tags: "ready";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
                                             };
-                                            readonly cancel: {
-                                                readonly target: "paused";
+                                            readonly paused: {
+                                                readonly tags: "pending";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
                                             };
-                                        };
-                                        readonly after: {
-                                            readonly timeout: readonly [{
-                                                readonly guard: "same view";
-                                                readonly actions: {
-                                                    readonly type: "trigger:OnChange";
-                                                    readonly params: ({ context }: {
-                                                        context: Readonly< Input>;
-                                                        event: SyncLayoutEvents;
-                                                    }) => {
-                                                        change: ViewChange.SaveManualLayout;
+                                            readonly pending: {
+                                                readonly tags: "pending";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                        readonly reenter: true;
+                                                    };
+                                                    readonly cancel: {
+                                                        readonly target: "paused";
                                                     };
                                                 };
-                                                readonly target: "synced";
-                                            }, {
-                                                readonly target: "stopped";
-                                            }];
+                                                readonly after: {
+                                                    readonly timeout: readonly [{
+                                                        readonly guard: "same view";
+                                                        readonly actions: {
+                                                            readonly type: "trigger:OnChange";
+                                                            readonly params: ({ context }: {
+                                                                context: Readonly< Input>;
+                                                                event: SyncLayoutEvents;
+                                                            }) => {
+                                                                change: ViewChange.SaveManualLayout;
+                                                            };
+                                                        };
+                                                        readonly target: "synced";
+                                                    }, {
+                                                        readonly target: "stopped";
+                                                    }];
+                                                };
+                                            };
+                                            readonly synced: {
+                                                readonly tags: "ready";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
+                                            };
+                                            readonly stopped: {
+                                                readonly entry: ActionFunction<Readonly< Input>, SyncLayoutEvents, SyncLayoutEvents, undefined, never, never, never, never, never>;
+                                                readonly type: "final";
+                                            };
                                         };
-                                    };
-                                    readonly synced: {
-                                        readonly tags: "ready";
                                         readonly on: {
-                                            readonly sync: {
-                                                readonly target: "pending";
+                                            readonly synced: {
+                                                readonly target: ".synced";
+                                            };
+                                            readonly stop: {
+                                                readonly target: ".stopped";
                                             };
                                         };
-                                    };
-                                    readonly stopped: {
-                                        readonly entry: ActionFunction<Readonly< Input>, SyncLayoutEvents, SyncLayoutEvents, undefined, never, never, never, never, never>;
-                                        readonly type: "final";
-                                    };
-                                };
-                                readonly on: {
-                                    readonly synced: {
-                                        readonly target: ".synced";
-                                    };
-                                    readonly stop: {
-                                        readonly target: ".stopped";
-                                    };
-                                };
-                            }>;
-                            id: "syncLayout";
-                        };
-                        hotkeyActorLogic: {
-                            src: "hotkeyActorLogic";
-                            logic: CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent>;
-                            id: "hotkey";
-                        };
-                        overlaysActorLogic: {
-                            src: "overlaysActorLogic";
-                            logic: StateMachine<OverlaysContext, OverlayActorEvent, {
-                                [x: `elementDetails-${number}`]: ActorRefFromLogic<ElementDetailsLogic> | undefined;
-                                [x: `relationshipsBrowser-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipsBrowser.Logic> | undefined;
-                                [x: `relationshipDetails-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipDetails.Logic> | undefined;
-                                hotkey?: ActorRefFromLogic<CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>>;
-                            }, Values<{
-                                elementDetails: {
-                                    src: "elementDetails";
-                                    logic: ElementDetailsLogic;
-                                    id: `elementDetails-${number}`;
-                                };
-                                relationshipsBrowser: {
-                                    src: "relationshipsBrowser";
-                                    logic: import("../overlays/types").Overlays.RelationshipsBrowser.Logic;
-                                    id: `relationshipsBrowser-${number}`;
-                                };
-                                relationshipDetails: {
-                                    src: "relationshipDetails";
-                                    logic: import("../overlays/types").Overlays.RelationshipDetails.Logic;
-                                    id: `relationshipDetails-${number}`;
+                                    }>;
+                                    id: "syncLayout";
                                 };
-                                hotkey: {
-                                    src: "hotkey";
-                                    logic: CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>;
+                                hotkeyActorLogic: {
+                                    src: "hotkeyActorLogic";
+                                    logic: CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent>;
                                     id: "hotkey";
                                 };
-                            }>, Values<{
-                                closeLastOverlay: {
+                                overlaysActorLogic: {
+                                    src: "overlaysActorLogic";
+                                    logic: StateMachine<OverlaysContext, OverlayActorEvent, {
+                                        [x: `elementDetails-${number}`]: ActorRefFromLogic<ElementDetailsLogic> | undefined;
+                                        [x: `relationshipsBrowser-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipsBrowser.Logic> | undefined;
+                                        [x: `relationshipDetails-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipDetails.Logic> | undefined;
+                                        hotkey?: ActorRefFromLogic<CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>>;
+                                    }, Values<{
+                                        elementDetails: {
+                                            src: "elementDetails";
+                                            logic: ElementDetailsLogic;
+                                            id: `elementDetails-${number}`;
+                                        };
+                                        relationshipsBrowser: {
+                                            src: "relationshipsBrowser";
+                                            logic: import("../overlays/types").Overlays.RelationshipsBrowser.Logic;
+                                            id: `relationshipsBrowser-${number}`;
+                                        };
+                                        relationshipDetails: {
+                                            src: "relationshipDetails";
+                                            logic: import("../overlays/types").Overlays.RelationshipDetails.Logic;
+                                            id: `relationshipDetails-${number}`;
+                                        };
+                                        hotkey: {
+                                            src: "hotkey";
+                                            logic: CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>;
+                                            id: "hotkey";
+                                        };
+                                    }>, Values<{
+                                        closeLastOverlay: {
+                                            type: "closeLastOverlay";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        closeSpecificOverlay: {
+                                            type: "closeSpecificOverlay";
+                                            params: {
+                                                actorId: string;
+                                            };
+                                        };
+                                        closeAllOverlays: {
+                                            type: "closeAllOverlays";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openElementDetails: {
+                                            type: "openElementDetails";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openRelationshipDetails: {
+                                            type: "openRelationshipDetails";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openRelationshipsBrowser: {
+                                            type: "openRelationshipsBrowser";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        listenToEsc: {
+                                            type: "listenToEsc";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        stopListeningToEsc: {
+                                            type: "stopListeningToEsc";
+                                            params: NonReducibleUnknown;
+                                        };
+                                    }>, Values<{
+                                        "has overlays?": {
+                                            type: "has overlays?";
+                                            params: unknown;
+                                        };
+                                        "close specific overlay?": {
+                                            type: "close specific overlay?";
+                                            params: unknown;
+                                        };
+                                        "last: is relationshipDetails?": {
+                                            type: "last: is relationshipDetails?";
+                                            params: unknown;
+                                        };
+                                        "last: is relationshipsBrowser?": {
+                                            type: "last: is relationshipsBrowser?";
+                                            params: unknown;
+                                        };
+                                    }>, never, "active" | "idle" | "closing", string, NonReducibleUnknown, NonReducibleUnknown, OverlayActorEmitedEvent, MetaObject, {
+                                        readonly id: "overlays";
+                                        readonly context: () => {
+                                            seq: number;
+                                            overlays: never[];
+                                        };
+                                        readonly initial: "idle";
+                                        readonly on: {
+                                            readonly 'open.elementDetails': {
+                                                readonly actions: "openElementDetails";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                            readonly 'open.relationshipDetails': {
+                                                readonly actions: "openRelationshipDetails";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                            readonly 'open.relationshipsBrowser': {
+                                                readonly actions: "openRelationshipsBrowser";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                        };
+                                        readonly states: {
+                                            readonly idle: {};
+                                            readonly active: {
+                                                readonly entry: "listenToEsc";
+                                                readonly exit: "stopListeningToEsc";
+                                                readonly on: {
+                                                    readonly close: readonly [{
+                                                        readonly guard: "close specific overlay?";
+                                                        readonly actions: {
+                                                            readonly type: "closeSpecificOverlay";
+                                                            readonly params: ({ event }: {
+                                                                context: OverlaysContext;
+                                                                event: {
+                                                                    type: "close";
+                                                                    actorId?: string | undefined;
+                                                                };
+                                                            }) => {
+                                                                actorId: string;
+                                                            };
+                                                        };
+                                                        readonly target: "closing";
+                                                    }, {
+                                                        readonly actions: "closeLastOverlay";
+                                                        readonly target: "closing";
+                                                    }];
+                                                    readonly 'close.all': {
+                                                        readonly actions: readonly ["closeAllOverlays", "stopListeningToEsc"];
+                                                        readonly target: "idle";
+                                                    };
+                                                };
+                                            };
+                                            readonly closing: {
+                                                readonly always: readonly [{
+                                                    readonly guard: "has overlays?";
+                                                    readonly target: "active";
+                                                }, {
+                                                    readonly actions: "stopListeningToEsc";
+                                                    readonly target: "idle";
+                                                }];
+                                            };
+                                        };
+                                        readonly exit: readonly ["stopListeningToEsc", "closeAllOverlays"];
+                                    }>;
+                                    id: "overlays";
+                                };
+                            }>, never, never, never, never>, "xyflow:fitFocusedBounds"];
+                        };
+                        readonly 'notations.unhighlight': {
+                            readonly actions: ActionFunction<Context, {
+                                type: "notations.unhighlight";
+                            }, Events, undefined, Values<{
+                                syncManualLayoutActorLogic: {
+                                    src: "syncManualLayoutActorLogic";
+                                    logic: StateMachine<Readonly< Input>, SyncLayoutEvents, {}, never, {
+                                        type: "trigger:OnChange";
+                                        params: {
+                                            change: ViewChange;
+                                        };
+                                    }, {
+                                        type: "same view";
+                                        params: unknown;
+                                    }, "timeout", "synced" | "pending" | "stopped" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
+                                        readonly initial: "idle";
+                                        readonly context: ({ input }: {
+                                            spawn: {
+                                                <TSrc extends never>(logic: TSrc, ...[options]: never): ActorRefFromLogic<never>;
+                                                <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
+                                                    id?: never;
+                                                    systemId?: string;
+                                                    input?: InputFrom<TLogic>;
+                                                    syncSnapshot?: boolean;
+                                                } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+                                            };
+                                            input: Input;
+                                            self: ActorRef< MachineSnapshot<Readonly< Input>, SyncLayoutEvents, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, SyncLayoutEvents, AnyEventObject>;
+                                        }) => {
+                                            parent: ActorRef< MachineSnapshot<Context, Events, any, any, any, any, any, any>, Events, any>;
+                                            viewId: ViewId;
+                                        };
+                                        readonly states: {
+                                            readonly idle: {
+                                                readonly tags: "ready";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
+                                            };
+                                            readonly paused: {
+                                                readonly tags: "pending";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
+                                            };
+                                            readonly pending: {
+                                                readonly tags: "pending";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                        readonly reenter: true;
+                                                    };
+                                                    readonly cancel: {
+                                                        readonly target: "paused";
+                                                    };
+                                                };
+                                                readonly after: {
+                                                    readonly timeout: readonly [{
+                                                        readonly guard: "same view";
+                                                        readonly actions: {
+                                                            readonly type: "trigger:OnChange";
+                                                            readonly params: ({ context }: {
+                                                                context: Readonly< Input>;
+                                                                event: SyncLayoutEvents;
+                                                            }) => {
+                                                                change: ViewChange.SaveManualLayout;
+                                                            };
+                                                        };
+                                                        readonly target: "synced";
+                                                    }, {
+                                                        readonly target: "stopped";
+                                                    }];
+                                                };
+                                            };
+                                            readonly synced: {
+                                                readonly tags: "ready";
+                                                readonly on: {
+                                                    readonly sync: {
+                                                        readonly target: "pending";
+                                                    };
+                                                };
+                                            };
+                                            readonly stopped: {
+                                                readonly entry: ActionFunction<Readonly< Input>, SyncLayoutEvents, SyncLayoutEvents, undefined, never, never, never, never, never>;
+                                                readonly type: "final";
+                                            };
+                                        };
+                                        readonly on: {
+                                            readonly synced: {
+                                                readonly target: ".synced";
+                                            };
+                                            readonly stop: {
+                                                readonly target: ".stopped";
+                                            };
+                                        };
+                                    }>;
+                                    id: "syncLayout";
+                                };
+                                hotkeyActorLogic: {
+                                    src: "hotkeyActorLogic";
+                                    logic: CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent>;
+                                    id: "hotkey";
+                                };
+                                overlaysActorLogic: {
+                                    src: "overlaysActorLogic";
+                                    logic: StateMachine<OverlaysContext, OverlayActorEvent, {
+                                        [x: `elementDetails-${number}`]: ActorRefFromLogic<ElementDetailsLogic> | undefined;
+                                        [x: `relationshipsBrowser-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipsBrowser.Logic> | undefined;
+                                        [x: `relationshipDetails-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipDetails.Logic> | undefined;
+                                        hotkey?: ActorRefFromLogic<CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>>;
+                                    }, Values<{
+                                        elementDetails: {
+                                            src: "elementDetails";
+                                            logic: ElementDetailsLogic;
+                                            id: `elementDetails-${number}`;
+                                        };
+                                        relationshipsBrowser: {
+                                            src: "relationshipsBrowser";
+                                            logic: import("../overlays/types").Overlays.RelationshipsBrowser.Logic;
+                                            id: `relationshipsBrowser-${number}`;
+                                        };
+                                        relationshipDetails: {
+                                            src: "relationshipDetails";
+                                            logic: import("../overlays/types").Overlays.RelationshipDetails.Logic;
+                                            id: `relationshipDetails-${number}`;
+                                        };
+                                        hotkey: {
+                                            src: "hotkey";
+                                            logic: CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>;
+                                            id: "hotkey";
+                                        };
+                                    }>, Values<{
+                                        closeLastOverlay: {
+                                            type: "closeLastOverlay";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        closeSpecificOverlay: {
+                                            type: "closeSpecificOverlay";
+                                            params: {
+                                                actorId: string;
+                                            };
+                                        };
+                                        closeAllOverlays: {
+                                            type: "closeAllOverlays";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openElementDetails: {
+                                            type: "openElementDetails";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openRelationshipDetails: {
+                                            type: "openRelationshipDetails";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        openRelationshipsBrowser: {
+                                            type: "openRelationshipsBrowser";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        listenToEsc: {
+                                            type: "listenToEsc";
+                                            params: NonReducibleUnknown;
+                                        };
+                                        stopListeningToEsc: {
+                                            type: "stopListeningToEsc";
+                                            params: NonReducibleUnknown;
+                                        };
+                                    }>, Values<{
+                                        "has overlays?": {
+                                            type: "has overlays?";
+                                            params: unknown;
+                                        };
+                                        "close specific overlay?": {
+                                            type: "close specific overlay?";
+                                            params: unknown;
+                                        };
+                                        "last: is relationshipDetails?": {
+                                            type: "last: is relationshipDetails?";
+                                            params: unknown;
+                                        };
+                                        "last: is relationshipsBrowser?": {
+                                            type: "last: is relationshipsBrowser?";
+                                            params: unknown;
+                                        };
+                                    }>, never, "active" | "idle" | "closing", string, NonReducibleUnknown, NonReducibleUnknown, OverlayActorEmitedEvent, MetaObject, {
+                                        readonly id: "overlays";
+                                        readonly context: () => {
+                                            seq: number;
+                                            overlays: never[];
+                                        };
+                                        readonly initial: "idle";
+                                        readonly on: {
+                                            readonly 'open.elementDetails': {
+                                                readonly actions: "openElementDetails";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                            readonly 'open.relationshipDetails': {
+                                                readonly actions: "openRelationshipDetails";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                            readonly 'open.relationshipsBrowser': {
+                                                readonly actions: "openRelationshipsBrowser";
+                                                readonly target: ".active";
+                                                readonly reenter: false;
+                                            };
+                                        };
+                                        readonly states: {
+                                            readonly idle: {};
+                                            readonly active: {
+                                                readonly entry: "listenToEsc";
+                                                readonly exit: "stopListeningToEsc";
+                                                readonly on: {
+                                                    readonly close: readonly [{
+                                                        readonly guard: "close specific overlay?";
+                                                        readonly actions: {
+                                                            readonly type: "closeSpecificOverlay";
+                                                            readonly params: ({ event }: {
+                                                                context: OverlaysContext;
+                                                                event: {
+                                                                    type: "close";
+                                                                    actorId?: string | undefined;
+                                                                };
+                                                            }) => {
+                                                                actorId: string;
+                                                            };
+                                                        };
+                                                        readonly target: "closing";
+                                                    }, {
+                                                        readonly actions: "closeLastOverlay";
+                                                        readonly target: "closing";
+                                                    }];
+                                                    readonly 'close.all': {
+                                                        readonly actions: readonly ["closeAllOverlays", "stopListeningToEsc"];
+                                                        readonly target: "idle";
+                                                    };
+                                                };
+                                            };
+                                            readonly closing: {
+                                                readonly always: readonly [{
+                                                    readonly guard: "has overlays?";
+                                                    readonly target: "active";
+                                                }, {
+                                                    readonly actions: "stopListeningToEsc";
+                                                    readonly target: "idle";
+                                                }];
+                                            };
+                                        };
+                                        readonly exit: readonly ["stopListeningToEsc", "closeAllOverlays"];
+                                    }>;
+                                    id: "overlays";
+                                };
+                            }>, never, never, never, never>;
+                        };
+                        readonly 'walkthrough.end': {
+                            readonly target: "idle";
+                        };
+                        readonly 'xyflow.paneDblClick': {
+                            readonly target: "idle";
+                        };
+                        readonly 'update.view': {
+                            readonly guard: "is another view";
+                            readonly actions: ActionFunction<Context, {
+                                type: "update.view";
+                                view: DiagramView;
+                                xynodes: Types.Node[];
+                                xyedges: Types.Edge[];
+                            }, Events, undefined, never, never, never, never, never>;
+                            readonly target: "idle";
+                        };
+                    };
+                    readonly exit: ActionFunction<Context, Events, Events, undefined, Values<{
+                        syncManualLayoutActorLogic: {
+                            src: "syncManualLayoutActorLogic";
+                            logic: StateMachine<Readonly< Input>, SyncLayoutEvents, {}, never, {
+                                type: "trigger:OnChange";
+                                params: {
+                                    change: ViewChange;
+                                };
+                            }, {
+                                type: "same view";
+                                params: unknown;
+                            }, "timeout", "synced" | "pending" | "stopped" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
+                                readonly initial: "idle";
+                                readonly context: ({ input }: {
+                                    spawn: {
+                                        <TSrc extends never>(logic: TSrc, ...[options]: never): ActorRefFromLogic<never>;
+                                        <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
+                                            id?: never;
+                                            systemId?: string;
+                                            input?: InputFrom<TLogic>;
+                                            syncSnapshot?: boolean;
+                                        } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+                                    };
+                                    input: Input;
+                                    self: ActorRef< MachineSnapshot<Readonly< Input>, SyncLayoutEvents, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, SyncLayoutEvents, AnyEventObject>;
+                                }) => {
+                                    parent: ActorRef< MachineSnapshot<Context, Events, any, any, any, any, any, any>, Events, any>;
+                                    viewId: ViewId;
+                                };
+                                readonly states: {
+                                    readonly idle: {
+                                        readonly tags: "ready";
+                                        readonly on: {
+                                            readonly sync: {
+                                                readonly target: "pending";
+                                            };
+                                        };
+                                    };
+                                    readonly paused: {
+                                        readonly tags: "pending";
+                                        readonly on: {
+                                            readonly sync: {
+                                                readonly target: "pending";
+                                            };
+                                        };
+                                    };
+                                    readonly pending: {
+                                        readonly tags: "pending";
+                                        readonly on: {
+                                            readonly sync: {
+                                                readonly target: "pending";
+                                                readonly reenter: true;
+                                            };
+                                            readonly cancel: {
+                                                readonly target: "paused";
+                                            };
+                                        };
+                                        readonly after: {
+                                            readonly timeout: readonly [{
+                                                readonly guard: "same view";
+                                                readonly actions: {
+                                                    readonly type: "trigger:OnChange";
+                                                    readonly params: ({ context }: {
+                                                        context: Readonly< Input>;
+                                                        event: SyncLayoutEvents;
+                                                    }) => {
+                                                        change: ViewChange.SaveManualLayout;
+                                                    };
+                                                };
+                                                readonly target: "synced";
+                                            }, {
+                                                readonly target: "stopped";
+                                            }];
+                                        };
+                                    };
+                                    readonly synced: {
+                                        readonly tags: "ready";
+                                        readonly on: {
+                                            readonly sync: {
+                                                readonly target: "pending";
+                                            };
+                                        };
+                                    };
+                                    readonly stopped: {
+                                        readonly entry: ActionFunction<Readonly< Input>, SyncLayoutEvents, SyncLayoutEvents, undefined, never, never, never, never, never>;
+                                        readonly type: "final";
+                                    };
+                                };
+                                readonly on: {
+                                    readonly synced: {
+                                        readonly target: ".synced";
+                                    };
+                                    readonly stop: {
+                                        readonly target: ".stopped";
+                                    };
+                                };
+                            }>;
+                            id: "syncLayout";
+                        };
+                        hotkeyActorLogic: {
+                            src: "hotkeyActorLogic";
+                            logic: CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent>;
+                            id: "hotkey";
+                        };
+                        overlaysActorLogic: {
+                            src: "overlaysActorLogic";
+                            logic: StateMachine<OverlaysContext, OverlayActorEvent, {
+                                [x: `elementDetails-${number}`]: ActorRefFromLogic<ElementDetailsLogic> | undefined;
+                                [x: `relationshipsBrowser-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipsBrowser.Logic> | undefined;
+                                [x: `relationshipDetails-${number}`]: ActorRefFromLogic<import("../overlays/types").Overlays.RelationshipDetails.Logic> | undefined;
+                                hotkey?: ActorRefFromLogic<CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>>;
+                            }, Values<{
+                                elementDetails: {
+                                    src: "elementDetails";
+                                    logic: ElementDetailsLogic;
+                                    id: `elementDetails-${number}`;
+                                };
+                                relationshipsBrowser: {
+                                    src: "relationshipsBrowser";
+                                    logic: import("../overlays/types").Overlays.RelationshipsBrowser.Logic;
+                                    id: `relationshipsBrowser-${number}`;
+                                };
+                                relationshipDetails: {
+                                    src: "relationshipDetails";
+                                    logic: import("../overlays/types").Overlays.RelationshipDetails.Logic;
+                                    id: `relationshipDetails-${number}`;
+                                };
+                                hotkey: {
+                                    src: "hotkey";
+                                    logic: CallbackActorLogic<EventObject, NonReducibleUnknown, EventObject>;
+                                    id: "hotkey";
+                                };
+                            }>, Values<{
+                                closeLastOverlay: {
                                     type: "closeLastOverlay";
                                     params: NonReducibleUnknown;
                                 };
@@ -9227,6 +9776,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "enabled: Readonly";
                             params: unknown;
                         };
+                        "enabled: RelationshipDetails": {
+                            type: "enabled: RelationshipDetails";
+                            params: unknown;
+                        };
                         "not readonly": {
                             type: "not readonly";
                             params: unknown;
@@ -9255,6 +9808,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "click: node has connections";
                             params: unknown;
                         };
+                        "click: selected edge": {
+                            type: "click: selected edge";
+                            params: unknown;
+                        };
                     }>, never, EventObject>;
                 };
             };
@@ -9657,6 +10214,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "enabled: Readonly";
                             params: unknown;
                         };
+                        "enabled: RelationshipDetails": {
+                            type: "enabled: RelationshipDetails";
+                            params: unknown;
+                        };
                         "not readonly": {
                             type: "not readonly";
                             params: unknown;
@@ -9685,6 +10246,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                             type: "click: node has connections";
                             params: unknown;
                         };
+                        "click: selected edge": {
+                            type: "click: selected edge";
+                            params: unknown;
+                        };
                     }>, never, EventObject>;
                     readonly target: "#idle";
                 };
@@ -11639,6 +12204,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                     type: "enabled: Readonly";
                     params: unknown;
                 };
+                "enabled: RelationshipDetails": {
+                    type: "enabled: RelationshipDetails";
+                    params: unknown;
+                };
                 "not readonly": {
                     type: "not readonly";
                     params: unknown;
@@ -11667,6 +12236,10 @@ export declare const diagramMachine: StateMachine<Context, Events, {
                     type: "click: node has connections";
                     params: unknown;
                 };
+                "click: selected edge": {
+                    type: "click: selected edge";
+                    params: unknown;
+                };
             }>, never, EventObject>];
         };
         readonly 'update.inputs': {