@likec4/diagram 1.28.1 → 1.29.0

package/dist/hooks/useDiagram.d.ts

@@ -4989,6 +4989,19 @@ export declare function useDiagram(): {
                                 }>, never, never, never, never>;
                                 readonly target: "focused";
                             };
+                            readonly 'xyflow.edgeClick': readonly [{
+                                readonly guard: any;
+                                readonly actions: ActionFunction<DiagramContext, {
+                                    type: "xyflow.edgeClick";
+                                    edge: Types.Edge;
+                                }, Events, undefined, never, never, never, never, never>;
+                            }, {
+                                readonly guard: any;
+                                readonly actions: ActionFunction<DiagramContext, {
+                                    type: "xyflow.edgeClick";
+                                    edge: Types.Edge;
+                                }, Events, undefined, never, never, never, never, never>;
+                            }];
                         };
                     };
                     readonly focused: {
@@ -5879,6 +5892,10 @@ export declare function useDiagram(): {
                                 type: "enabled: Readonly";
                                 params: unknown;
                             };
+                            "enabled: RelationshipDetails": {
+                                type: "enabled: RelationshipDetails";
+                                params: unknown;
+                            };
                             "not readonly": {
                                 type: "not readonly";
                                 params: unknown;
@@ -5907,6 +5924,10 @@ export declare function useDiagram(): {
                                 type: "click: node has connections";
                                 params: unknown;
                             };
+                            "click: selected edge": {
+                                type: "click: selected edge";
+                                params: unknown;
+                            };
                         }>, never, EventObject>;
                         readonly on: {
                             readonly 'xyflow.nodeClick': readonly [{
@@ -8363,6 +8384,10 @@ export declare function useDiagram(): {
                                         type: "enabled: Readonly";
                                         params: unknown;
                                     };
+                                    "enabled: RelationshipDetails": {
+                                        type: "enabled: RelationshipDetails";
+                                        params: unknown;
+                                    };
                                     "not readonly": {
                                         type: "not readonly";
                                         params: unknown;
@@ -8391,11 +8416,16 @@ export declare function useDiagram(): {
                                         type: "click: node has connections";
                                         params: unknown;
                                     };
+                                    "click: selected edge": {
+                                        type: "click: selected edge";
+                                        params: unknown;
+                                    };
                                 }>, never, EventObject>;
                             };
-                            readonly 'notations.unhighlight': {
-                                readonly actions: ActionFunction<DiagramContext, {
-                                    type: "notations.unhighlight";
+                            readonly 'xyflow.edgeClick': {
+                                readonly actions: readonly [ ActionFunction<DiagramContext, {
+                                    type: "xyflow.edgeClick";
+                                    edge: Types.Edge;
                                 }, Events, undefined, Values<{
                                     syncManualLayoutActorLogic: {
                                         src: "syncManualLayoutActorLogic";
@@ -8649,163 +8679,674 @@ export declare function useDiagram(): {
                                         }>;
                                         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<DiagramContext, {
-                                    type: "update.view";
-                                    view: DiagramView;
-                                    xynodes: Types.Node[];
-                                    xyedges: Types.Edge[];
-                                }, Events, undefined, never, never, never, never, never>;
-                                readonly target: "idle";
-                            };
-                        };
-                        readonly exit: ActionFunction<DiagramContext, Events, Events, undefined, Values<{
-                            syncManualLayoutActorLogic: {
-                                src: "syncManualLayoutActorLogic";
-                                logic: StateMachine<Readonly< Input>, Events, {}, 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>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
-                                    }) => {
-                                        parent: ActorRef<MachineSnapshot<DiagramContext, 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<DiagramContext, Events, Events, undefined, Values<{
+                                    syncManualLayoutActorLogic: {
+                                        src: "syncManualLayoutActorLogic";
+                                        logic: StateMachine<Readonly< Input>, Events, {}, 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>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
+                                            }) => {
+                                                parent: ActorRef<MachineSnapshot<DiagramContext, 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: Events;
-                                                        }) => {
-                                                            change: import("@likec4/core").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: Events;
+                                                                }) => {
+                                                                    change: import("@likec4/core").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>, Events, Events, 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>, Events, Events, 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: {
-                                        type: "closeLastOverlay";
-                                        params: NonReducibleUnknown;
-                                    };
-                                    closeSpecificOverlay: {
+                                    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<DiagramContext, {
+                                    type: "notations.unhighlight";
+                                }, Events, undefined, Values<{
+                                    syncManualLayoutActorLogic: {
+                                        src: "syncManualLayoutActorLogic";
+                                        logic: StateMachine<Readonly< Input>, Events, {}, 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>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
+                                            }) => {
+                                                parent: ActorRef<MachineSnapshot<DiagramContext, 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: Events;
+                                                                }) => {
+                                                                    change: import("@likec4/core").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>, Events, Events, 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<DiagramContext, {
+                                    type: "update.view";
+                                    view: DiagramView;
+                                    xynodes: Types.Node[];
+                                    xyedges: Types.Edge[];
+                                }, Events, undefined, never, never, never, never, never>;
+                                readonly target: "idle";
+                            };
+                        };
+                        readonly exit: ActionFunction<DiagramContext, Events, Events, undefined, Values<{
+                            syncManualLayoutActorLogic: {
+                                src: "syncManualLayoutActorLogic";
+                                logic: StateMachine<Readonly< Input>, Events, {}, 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>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
+                                    }) => {
+                                        parent: ActorRef<MachineSnapshot<DiagramContext, 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: Events;
+                                                        }) => {
+                                                            change: import("@likec4/core").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>, Events, Events, 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;
@@ -9048,6 +9589,10 @@ export declare function useDiagram(): {
                                 type: "enabled: Readonly";
                                 params: unknown;
                             };
+                            "enabled: RelationshipDetails": {
+                                type: "enabled: RelationshipDetails";
+                                params: unknown;
+                            };
                             "not readonly": {
                                 type: "not readonly";
                                 params: unknown;
@@ -9076,6 +9621,10 @@ export declare function useDiagram(): {
                                 type: "click: node has connections";
                                 params: unknown;
                             };
+                            "click: selected edge": {
+                                type: "click: selected edge";
+                                params: unknown;
+                            };
                         }>, never, EventObject>;
                     };
                 };
@@ -9478,6 +10027,10 @@ export declare function useDiagram(): {
                                 type: "enabled: Readonly";
                                 params: unknown;
                             };
+                            "enabled: RelationshipDetails": {
+                                type: "enabled: RelationshipDetails";
+                                params: unknown;
+                            };
                             "not readonly": {
                                 type: "not readonly";
                                 params: unknown;
@@ -9506,6 +10059,10 @@ export declare function useDiagram(): {
                                 type: "click: node has connections";
                                 params: unknown;
                             };
+                            "click: selected edge": {
+                                type: "click: selected edge";
+                                params: unknown;
+                            };
                         }>, never, EventObject>;
                         readonly target: "#idle";
                     };
@@ -11460,6 +12017,10 @@ export declare function useDiagram(): {
                         type: "enabled: Readonly";
                         params: unknown;
                     };
+                    "enabled: RelationshipDetails": {
+                        type: "enabled: RelationshipDetails";
+                        params: unknown;
+                    };
                     "not readonly": {
                         type: "not readonly";
                         params: unknown;
@@ -11488,6 +12049,10 @@ export declare function useDiagram(): {
                         type: "click: node has connections";
                         params: unknown;
                     };
+                    "click: selected edge": {
+                        type: "click: selected edge";
+                        params: unknown;
+                    };
                 }>, never, EventObject>];
             };
             readonly 'update.inputs': {