@likec4/diagram 1.45.0 → 1.46.2

package/dist/editor/editorActor.d.ts

@@ -0,0 +1,653 @@
+import { ActorRef, NonReducibleUnknown, SnapshotFrom, SetupReturn, PromiseActorLogic, EventObject, MetaObject, StateMachine, ActorRefFromLogic, Values, ConditionalRequired, InputFrom, RequiredActorOptions, IsNotNever, GetConcreteByKey, AnyActorLogic, RequiredLogicInput, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, CancelAction, ActionFunction, LogAction, DoneActorEvent, ErrorActorEvent, ActionArgs, StopAction } from 'xstate';
+import { Types } from '../likec4diagram/types';
+import { HotKeyEvent, HotkeyActorLogic } from './hotkeyActor';
+import type * as t from '@likec4/core/types';
+export declare namespace EditorCalls {
+    type ApplyLatestToManual = (params: {
+        input: ApplyLatestToManual.Input;
+    }) => Promise<ApplyLatestToManual.Output>;
+    namespace ApplyLatestToManual {
+        type Input = {
+            viewId: t.ViewId;
+            current: t.LayoutedView | undefined;
+        };
+        type Output = {
+            updated: t.LayoutedView;
+        };
+    }
+    type ExecuteChange = (params: {
+        input: ExecuteChange.Input;
+    }) => Promise<ExecuteChange.Output>;
+    namespace ExecuteChange {
+        type Input = {
+            viewId: t.ViewId;
+            changes: t.ViewChange[];
+        };
+        type Output = NonReducibleUnknown;
+    }
+}
+export type EditorActorEvent = {
+    type: 'sync';
+} | {
+    type: 'change';
+    change: t.ViewChange;
+} | {
+    type: 'edit.start';
+    subject: 'node' | 'edge';
+} | {
+    type: 'edit.finish';
+    wasChanged?: boolean;
+} | {
+    type: 'applyLatestToManual';
+} | {
+    type: 'synced';
+} | {
+    type: 'cancel';
+} | {
+    type: 'reset';
+} | HotKeyEvent;
+type HistorySnapshot = {
+    view: t.LayoutedView;
+    change: t.ViewChange.SaveViewSnapshot;
+    xynodes: Types.Node[];
+    xyedges: Types.Edge[];
+    synched: boolean;
+};
+export interface EditorActorInput {
+    viewId: t.ViewId;
+}
+export interface EditorActorContext {
+    viewId: t.ViewId;
+    pendingChanges: t.ViewChange[];
+    history: ReadonlyArray<HistorySnapshot>;
+    /**
+     * The state before editing started
+     */
+    beforeEditing: HistorySnapshot | null;
+    /**
+     * The subject of the edit
+     */
+    editing: 'node' | 'edge' | null;
+}
+export type EditorActorEmitedEvent = {
+    type: 'idle';
+};
+export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
+    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+    executeChange: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+    hotkey: HotkeyActorLogic;
+}, {
+    hotkey: "hotkey";
+}, {}, {
+    'has pending': unknown;
+    'can undo': unknown;
+}, "350ms" | "waitBeforeSync", "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;
+declare const _editorActorLogic: StateMachine<EditorActorContext, EditorActorEvent, {
+    [x: string]: ActorRefFromLogic<HotkeyActorLogic> | ActorRefFromLogic<PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>> | ActorRefFromLogic<PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>> | undefined;
+    hotkey?: ActorRefFromLogic<HotkeyActorLogic>;
+}, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", "pending" | "idle" | "editing" | "afterEdit" | "executeChanges" | {
+    applyLatestToManual: "call" | "wait";
+}, "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject, {
+    readonly id: "editor";
+    readonly context: ({ input }: {
+        spawn: {
+            <TSrc extends "hotkey" | "applyLatest" | "executeChange">(logic: TSrc, ...[options]: ({
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } extends infer T ? T extends {
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } ? T extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T["id"];
+                systemId?: string;
+                input?: InputFrom<T["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K in RequiredActorOptions<T>]: unknown; }], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
+                src: "applyLatest";
+                logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } extends infer T_1 ? T_1 extends {
+                src: "applyLatest";
+                logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } ? T_1 extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T_1["id"];
+                systemId?: string;
+                input?: InputFrom<T_1["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never) | ({
+                src: "executeChange";
+                logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } extends infer T_2 ? T_2 extends {
+                src: "executeChange";
+                logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } ? T_2 extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T_2["id"];
+                systemId?: string;
+                input?: InputFrom<T_2["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K_2 in RequiredActorOptions<T_2>]: unknown; }], IsNotNever<RequiredActorOptions<T_2>>> : never : never : never)): ActorRefFromLogic< GetConcreteByKey<Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, "src", TSrc>["logic"]>;
+            <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: EditorActorInput;
+        self: ActorRef< MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+    }) => {
+        viewId: t.ViewId;
+        beforeEditing: null;
+        editing: null;
+        pendingChanges: never[];
+        history: never[];
+    };
+    readonly initial: "idle";
+    readonly states: {
+        readonly idle: {
+            id: string;
+            on: {
+                sync: {
+                    target: "#pending";
+                };
+                'edit.start': {
+                    target: "#editing";
+                };
+            };
+        };
+        readonly editing: {
+            id: string;
+            tags: "pending";
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            on: {
+                change: {
+                    target: "#executeChanges";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                'edit.finish': {
+                    target: "#afterEdit";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                undo: {
+                    target: "#idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+            };
+        };
+        readonly pending: {
+            id: string;
+            tags: "pending"[];
+            entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, Values<{
+                "has pending": {
+                    type: "has pending";
+                    params: unknown;
+                };
+                "can undo": {
+                    type: "can undo";
+                    params: unknown;
+                };
+            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+            on: {
+                sync: {
+                    target: "#pending";
+                    reenter: true;
+                };
+                'edit.start': {
+                    target: "#editing";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>[];
+                };
+            };
+            after: {
+                waitBeforeSync: {
+                    target: "#executeChanges";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>[];
+                };
+            };
+        };
+        readonly afterEdit: {
+            id: string;
+            always: ({
+                target: "#pending";
+                guard: "has pending";
+            } | {
+                target: "#idle";
+            })[];
+        };
+        readonly applyLatestToManual: {
+            id: string;
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            initial: string;
+            on: {
+                '*': {
+                    actions: LogAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+                };
+            };
+            states: {
+                call: {
+                    invoke: {
+                        src: "applyLatest";
+                        input: ({ context }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef< MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            current: t.DiagramView | undefined;
+                            viewId: t.ViewId;
+                        };
+                        onDone: {
+                            actions: ActionFunction<EditorActorContext, DoneActorEvent<EditorCalls.ApplyLatestToManual.Output, string>, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+                            target: string;
+                        };
+                        onError: {
+                            target: "#idle";
+                            actions: ( ActionFunction<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent, undefined, Values<{
+                                hotkey: {
+                                    src: "hotkey";
+                                    logic: HotkeyActorLogic;
+                                    id: "hotkey";
+                                };
+                                applyLatest: {
+                                    src: "applyLatest";
+                                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                                executeChange: {
+                                    src: "executeChange";
+                                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, never, never, never> | (({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void))[];
+                        };
+                    };
+                };
+                wait: {
+                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>;
+                    after: {
+                        '350ms': {
+                            target: "#executeChanges";
+                            actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                                hotkey: {
+                                    src: "hotkey";
+                                    logic: HotkeyActorLogic;
+                                    id: "hotkey";
+                                };
+                                applyLatest: {
+                                    src: "applyLatest";
+                                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                                executeChange: {
+                                    src: "executeChange";
+                                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, Values<{
+                                "has pending": {
+                                    type: "has pending";
+                                    params: unknown;
+                                };
+                                "can undo": {
+                                    type: "can undo";
+                                    params: unknown;
+                                };
+                            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>[];
+                        };
+                    };
+                };
+            };
+        };
+        readonly executeChanges: {
+            id: string;
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            invoke: {
+                src: "executeChange";
+                input: ({ context }: {
+                    context: EditorActorContext;
+                    event: EditorActorEvent;
+                    self: ActorRef< MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                }) => {
+                    changes: t.ViewChange[];
+                    viewId: t.ViewId;
+                };
+                onDone: {
+                    target: "#idle";
+                    actions: ActionFunction<EditorActorContext, DoneActorEvent<NonReducibleUnknown, string>, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                onError: {
+                    target: "#afterEdit";
+                    actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
+                };
+            };
+            on: {
+                '*': {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+                };
+            };
+        };
+    };
+    readonly on: {
+        readonly cancel: {
+            readonly target: "#idle";
+            readonly actions: readonly [ CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>, ActionFunction<EditorActorContext, {
+                type: "cancel";
+            }, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>];
+        };
+        readonly synced: {
+            readonly actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>;
+        };
+        readonly undo: {
+            readonly target: "#idle";
+            readonly guard: "can undo";
+            readonly actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, Values<{
+                "has pending": {
+                    type: "has pending";
+                    params: unknown;
+                };
+                "can undo": {
+                    type: "can undo";
+                    params: unknown;
+                };
+            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+        };
+        readonly change: {
+            readonly target: "#executeChanges";
+        };
+        readonly applyLatestToManual: {
+            readonly target: "#applyLatestToManual";
+        };
+        readonly reset: {
+            readonly target: "#idle";
+            readonly actions: readonly [ CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>, ActionFunction<EditorActorContext, {
+                type: "reset";
+            }, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>, StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>];
+        };
+    };
+}>;
+type InferredMachine = typeof _editorActorLogic;
+export interface EditorActorLogic extends InferredMachine {
+}
+export declare const editorActorLogic: EditorActorLogic;
+export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;
+export interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
+}
+export {};