import { ActionFunction, PromiseActorLogic, EventObject, CancelAction, LogAction, GuardArgs, ActorRef, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, DoneActorEvent, ErrorActorEvent, ActionArgs } from 'xstate';
import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
import { HotkeyActorLogic } from './hotkey';
import { DiagramView, Any, ViewId, ViewChange } from '@likec4/core';
export declare const syncQueue: {
    initial: string;
    states: {
        idle: {
            always: {
                target: "#queue-pending";
                guard: "has pending";
            };
            on: {
                'delete.nodes-edges': {
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                };
                'change.sync-snapshot': {
                    target: "#queue-pending";
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                };
                'change.*': {
                    target: "#queue-process";
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                };
                undo: {
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                };
                redo: {
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                };
                cancel: {
                    target: "#queue-idle";
                    actions: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
                };
                'view.synched': {
                    actions: LogAction<EditorActorContext, {
                        type: "view.synched";
                    }, undefined, EditorActorEvent>;
                };
            };
            id: string;
        };
        pending: {
            on: {
                'change.sync-snapshot': {
                    target: "#queue-pending";
                    reenter: true;
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                };
                'change.*': {
                    target: "#queue-process";
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                };
                'delete.nodes-edges': {
                    target: "#queue-pending";
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                    reenter: true;
                };
                'edit.move.start': {
                    target: "#queue-suspended";
                };
                undo: {
                    target: "#queue-pending";
                    reenter: true;
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                };
                redo: {
                    target: "#queue-pending";
                    reenter: true;
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, {
                        type: "has pending";
                        params: unknown;
                    } | {
                        type: "can undo";
                        params: unknown;
                    } | {
                        type: "can redo";
                        params: unknown;
                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                };
                cancel: {
                    target: "#queue-idle";
                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                };
                'view.synched': {
                    actions: LogAction<EditorActorContext, {
                        type: "view.synched";
                    }, undefined, EditorActorEvent>;
                };
            };
            after: {
                'wait-after-edit': ({
                    readonly target: "#queue-idle";
                } | {
                    target: "#queue-process";
                    guard: "has pending";
                })[];
            };
            id: string;
        };
        suspended: {
            on: {
                'edit.*': {
                    readonly target: "#queue-idle";
                };
                cancel: {
                    target: "#queue-idle";
                    actions: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
                };
            };
            id: string;
        };
        process: {
            initial: string;
            tags: "busy"[];
            states: {
                peekFromQueue: {
                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                    always: ({
                        guard: ({ context: { processing } }: GuardArgs<EditorActorContext, EditorActorEvent>) => boolean;
                        target: string;
                    } | {
                        target: "#queue-process";
                        guard: "has pending";
                        reenter: true;
                    } | {
                        target: "#queue-idle";
                        actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                            src: "hotkey";
                            logic: HotkeyActorLogic;
                            id: "hotkey";
                        } | {
                            src: "applyLatest";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                            id: string | undefined;
                        } | {
                            src: "executeChange";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                            id: string | undefined;
                        } | {
                            src: "applySemanticLayout";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                            id: string | undefined;
                        }, never, never, never, never>;
                        guard?: never;
                    })[];
                };
                /**
                 * Syncing state, some edits are not yet synced
                 */
                applyLatestToManual: {
                    initial: string;
                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                    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: DiagramView<Any>;
                                    viewId: ViewId;
                                };
                                onDone: {
                                    actions: ActionFunction<EditorActorContext, DoneActorEvent<import("./setup").EditorCalls.ApplyLatestToManual.Output, string>, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
                                    target: string;
                                };
                                onError: {
                                    target: "#queue-idle";
                                    actions: ActionFunction<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent, undefined, {
                                        src: "hotkey";
                                        logic: HotkeyActorLogic;
                                        id: "hotkey";
                                    } | {
                                        src: "applyLatest";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                                        id: string | undefined;
                                    } | {
                                        src: "executeChange";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                                        id: string | undefined;
                                    } | {
                                        src: "applySemanticLayout";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, never>;
                                };
                            };
                        };
                        wait: {
                            on: {
                                '*': {
                                    actions: LogAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
                                };
                            };
                            after: {
                                '500ms': {
                                    target: "#queue-idle";
                                    actions: ( ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never> | ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                                        src: "hotkey";
                                        logic: HotkeyActorLogic;
                                        id: "hotkey";
                                    } | {
                                        src: "applyLatest";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                                        id: string | undefined;
                                    } | {
                                        src: "executeChange";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                                        id: string | undefined;
                                    } | {
                                        src: "applySemanticLayout";
                                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                                        id: string | undefined;
                                    }, never, never, never, never>)[];
                                };
                            };
                        };
                    };
                };
                /**
                 * User requested semantic layout, we will call the AI
                 */
                applySemanticLayout: {
                    tags: "ai-semantic-layout"[];
                    invoke: {
                        src: "applySemanticLayout";
                        input: ({ context }: {
                            context: EditorActorContext;
                            event: EditorActorEvent;
                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
                        }) => {
                            viewId: ViewId;
                        };
                        onDone: {
                            target: string;
                        };
                        onError: {
                            actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
                            target: string;
                        };
                    };
                };
                /**
                 * Calls `executeChange` to save the snapshot
                 */
                executeChanges: {
                    invoke: {
                        src: "executeChange";
                        input: ({ context: { processing, syncQueue, viewId } }: {
                            context: EditorActorContext;
                            event: EditorActorEvent;
                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
                        }) => {
                            changes: ViewChange[];
                            viewId: ViewId;
                        };
                        onDone: {
                            actions: ActionFunction<EditorActorContext, DoneActorEvent<import("./setup").EditorCalls.ExecuteChange.Output, string>, EditorActorEvent, undefined, {
                                src: "hotkey";
                                logic: HotkeyActorLogic;
                                id: "hotkey";
                            } | {
                                src: "applyLatest";
                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                                id: string | undefined;
                            } | {
                                src: "executeChange";
                                logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                                id: string | undefined;
                            } | {
                                src: "applySemanticLayout";
                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                                id: string | undefined;
                            }, never, {
                                type: "has pending";
                                params: unknown;
                            } | {
                                type: "can undo";
                                params: unknown;
                            } | {
                                type: "can redo";
                                params: unknown;
                            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                            target: string;
                        };
                        onError: {
                            actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
                            target: string;
                        };
                    };
                };
                waitViewSynced: {
                    on: {
                        'view.synched': {
                            target: string;
                        };
                    };
                    after: {
                        2000: string;
                    };
                };
                decideNext: {
                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                        src: "hotkey";
                        logic: HotkeyActorLogic;
                        id: "hotkey";
                    } | {
                        src: "applyLatest";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "executeChange";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                        id: string | undefined;
                    } | {
                        src: "applySemanticLayout";
                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                        id: string | undefined;
                    }, never, never, never, never>;
                    always: ({
                        readonly target: "#queue-idle";
                    } | {
                        target: "#queue-process";
                        guard: "has pending";
                        reenter: true;
                    })[];
                };
                failure: {
                    always: {
                        target: "#queue-idle";
                        actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                            src: "hotkey";
                            logic: HotkeyActorLogic;
                            id: "hotkey";
                        } | {
                            src: "applyLatest";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
                            id: string | undefined;
                        } | {
                            src: "executeChange";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                            id: string | undefined;
                        } | {
                            src: "applySemanticLayout";
                            logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                            id: string | undefined;
                        }, never, never, never, never>;
                    };
                };
            };
            on: {};
            id: string;
        };
    };
    on: {};
};