@omnia/fx 8.0.264-dev → 8.0.266-dev

package/internal-do-not-import-from-here/ux/floweditor/stores/FlowEditorToolbarStore.d.ts

@@ -0,0 +1,1901 @@
+import { FlowEditorActionRegistration } from "@omnia/fx-models";
+import { useFlowEditorStore } from "./FlowEditorStore";
+export declare const useFlowEditorToolbarStore: () => {
+    state: {
+        activeEditorStore: {
+            state: {
+                editorContent: import("../models/EditorModels").FlowContent;
+                plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                hideToolbar: boolean;
+                editMode: boolean;
+                maxNodeId: number;
+                toolbarActions: FlowEditorActionRegistration[];
+                editor: HTMLDivElement;
+                nodeSelection: import("../models/EditorModels").NodeSelection;
+                telePorts: JSX.Element[];
+                id: string;
+                pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
+                selectedRange: Range;
+                showPlaceHolder: boolean;
+            };
+            events: {
+                onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").FlowContent>;
+                onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPlugin[]>;
+                onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+                onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+                onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+                onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").NodeSelection>;
+                onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+                onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+                onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPluginContext>;
+                onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+                onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+            } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+            actions: {
+                onDispatching: {
+                    plugin: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+                onDispatched: {
+                    plugin: {
+                        subscribe(fn: (result: {
+                            register: {
+                                plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: (result: {
+                            sync: () => import("../models/EditorModels").FlowContent;
+                            set: {
+                                byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                byString: (content: string) => void;
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: (result: {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: (result: {
+                            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: (result: {
+                            add: (element: HTMLElement) => void;
+                            toggle: (element: HTMLElement) => void;
+                            remove: (dataType: string) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: (result: {
+                            createForComponent: (componentName: string) => HTMLDivElement;
+                            createText: () => HTMLParagraphElement;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createTextNode: (data: any) => Text;
+                            add: (element: HTMLElement) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: (result: {
+                            exec: (command: string, data: object) => void;
+                            builtIn: {
+                                content: {
+                                    convert: (element: HTMLElement) => void;
+                                };
+                                ensure: {
+                                    lastElement: () => void;
+                                    unique: {
+                                        ids: (element: HTMLElement) => void;
+                                    };
+                                };
+                                selection: {
+                                    get: {
+                                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                    };
+                                };
+                                cursor: {
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                                actions: {
+                                    setSelection: () => void;
+                                };
+                                formatting: {
+                                    add: (element: HTMLElement) => void;
+                                    remove: (dataType: string | HTMLElement) => void;
+                                    has: (dataType: string | HTMLElement) => boolean;
+                                };
+                                element: {
+                                    clean: (element: HTMLElement) => void;
+                                    add: (element: HTMLElement) => void;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createText: () => HTMLParagraphElement;
+                                    createTextNode: (data: any) => Text;
+                                    createComponent: (componentName: string) => HTMLDivElement;
+                                    insert: {
+                                        text: (element: Node, text: string, offset: any) => void;
+                                    };
+                                    ids: {
+                                        unique: (element: HTMLElement) => void;
+                                    };
+                                };
+                                helpers: {
+                                    editor: {
+                                        ensure: {
+                                            uniqueIds: (element: HTMLElement, state: {
+                                                maxNodeId: number;
+                                            }) => HTMLElement;
+                                            selectionIsInEditor: (range: Range) => void;
+                                        };
+                                        cursor: {
+                                            storePosition: (state: {
+                                                selectedRange: Range;
+                                            }) => void;
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                    };
+                                    editorNode: {
+                                        get: {
+                                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                        };
+                                    };
+                                    htmlNode: {
+                                        copy: {
+                                            children: (from: HTMLElement, to: HTMLElement) => void;
+                                        };
+                                        insert: {
+                                            text: (element: Node, text: string, offset: any) => void;
+                                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                        };
+                                        get: {
+                                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                            nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                        };
+                                        remove: {
+                                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                        };
+                                        strip: {
+                                            after: (element: HTMLElement, splitter: string) => void;
+                                            before: (element: HTMLElement, splitter: string) => void;
+                                        };
+                                        surround: {
+                                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                        };
+                                    };
+                                };
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+                onFailure: {
+                    plugin: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+            } & {
+                plugin: () => {
+                    register: {
+                        plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                        plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                        context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                    };
+                };
+                content: () => {
+                    sync: () => import("../models/EditorModels").FlowContent;
+                    set: {
+                        byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                        byString: (content: string) => void;
+                    };
+                };
+                set: () => {
+                    mode: (editMode: boolean) => void;
+                    container: (el: HTMLDivElement) => void;
+                    focus: () => void;
+                    placeHolderVisibility: () => void;
+                };
+                toolbarAction: () => {
+                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                };
+                formatting: () => {
+                    add: (element: HTMLElement) => void;
+                    toggle: (element: HTMLElement) => void;
+                    remove: (dataType: string) => void;
+                };
+                element: () => {
+                    createForComponent: (componentName: string) => HTMLDivElement;
+                    createText: () => HTMLParagraphElement;
+                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                    createTextNode: (data: any) => Text;
+                    add: (element: HTMLElement) => void;
+                };
+                commands: () => {
+                    exec: (command: string, data: object) => void;
+                    builtIn: {
+                        content: {
+                            convert: (element: HTMLElement) => void;
+                        };
+                        ensure: {
+                            lastElement: () => void;
+                            unique: {
+                                ids: (element: HTMLElement) => void;
+                            };
+                        };
+                        selection: {
+                            get: {
+                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                        cursor: {
+                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                        };
+                        actions: {
+                            setSelection: () => void;
+                        };
+                        formatting: {
+                            add: (element: HTMLElement) => void;
+                            remove: (dataType: string | HTMLElement) => void;
+                            has: (dataType: string | HTMLElement) => boolean;
+                        };
+                        element: {
+                            clean: (element: HTMLElement) => void;
+                            add: (element: HTMLElement) => void;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createText: () => HTMLParagraphElement;
+                            createTextNode: (data: any) => Text;
+                            createComponent: (componentName: string) => HTMLDivElement;
+                            insert: {
+                                text: (element: Node, text: string, offset: any) => void;
+                            };
+                            ids: {
+                                unique: (element: HTMLElement) => void;
+                            };
+                        };
+                        helpers: {
+                            editor: {
+                                ensure: {
+                                    uniqueIds: (element: HTMLElement, state: {
+                                        maxNodeId: number;
+                                    }) => HTMLElement;
+                                    selectionIsInEditor: (range: Range) => void;
+                                };
+                                cursor: {
+                                    storePosition: (state: {
+                                        selectedRange: Range;
+                                    }) => void;
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                            };
+                            editorNode: {
+                                get: {
+                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                };
+                            };
+                            htmlNode: {
+                                copy: {
+                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                };
+                                insert: {
+                                    text: (element: Node, text: string, offset: any) => void;
+                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                };
+                                get: {
+                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                    nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                };
+                                remove: {
+                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                };
+                                strip: {
+                                    after: (element: HTMLElement, splitter: string) => void;
+                                    before: (element: HTMLElement, splitter: string) => void;
+                                };
+                                surround: {
+                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            get: {
+                plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                content: {
+                    isEmpty: () => boolean;
+                    asJSON: () => import("../models/EditorModels").FlowContent;
+                    asString: () => string;
+                };
+                selection: {
+                    has: {
+                        type: (pluginType: string) => boolean;
+                    };
+                    get: {
+                        byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                    };
+                };
+            };
+        } & {
+            dispose?: () => void;
+        };
+        show: boolean;
+        actions: FlowEditorActionRegistration[];
+        customActionRenderer: () => JSX.Element;
+    };
+    events: {
+        onMutatedActiveEditorStore: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            state: {
+                editorContent: import("../models/EditorModels").FlowContent;
+                plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                hideToolbar: boolean;
+                editMode: boolean;
+                maxNodeId: number;
+                toolbarActions: FlowEditorActionRegistration[];
+                editor: HTMLDivElement;
+                nodeSelection: import("../models/EditorModels").NodeSelection;
+                telePorts: JSX.Element[];
+                id: string;
+                pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
+                selectedRange: Range;
+                showPlaceHolder: boolean;
+            };
+            events: {
+                onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").FlowContent>;
+                onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPlugin[]>;
+                onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+                onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+                onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+                onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").NodeSelection>;
+                onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+                onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+                onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPluginContext>;
+                onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+                onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+            } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+            actions: {
+                onDispatching: {
+                    plugin: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+                onDispatched: {
+                    plugin: {
+                        subscribe(fn: (result: {
+                            register: {
+                                plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: (result: {
+                            sync: () => import("../models/EditorModels").FlowContent;
+                            set: {
+                                byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                byString: (content: string) => void;
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: (result: {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: (result: {
+                            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: (result: {
+                            add: (element: HTMLElement) => void;
+                            toggle: (element: HTMLElement) => void;
+                            remove: (dataType: string) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: (result: {
+                            createForComponent: (componentName: string) => HTMLDivElement;
+                            createText: () => HTMLParagraphElement;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createTextNode: (data: any) => Text;
+                            add: (element: HTMLElement) => void;
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: (result: {
+                            exec: (command: string, data: object) => void;
+                            builtIn: {
+                                content: {
+                                    convert: (element: HTMLElement) => void;
+                                };
+                                ensure: {
+                                    lastElement: () => void;
+                                    unique: {
+                                        ids: (element: HTMLElement) => void;
+                                    };
+                                };
+                                selection: {
+                                    get: {
+                                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                    };
+                                };
+                                cursor: {
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                                actions: {
+                                    setSelection: () => void;
+                                };
+                                formatting: {
+                                    add: (element: HTMLElement) => void;
+                                    remove: (dataType: string | HTMLElement) => void;
+                                    has: (dataType: string | HTMLElement) => boolean;
+                                };
+                                element: {
+                                    clean: (element: HTMLElement) => void;
+                                    add: (element: HTMLElement) => void;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createText: () => HTMLParagraphElement;
+                                    createTextNode: (data: any) => Text;
+                                    createComponent: (componentName: string) => HTMLDivElement;
+                                    insert: {
+                                        text: (element: Node, text: string, offset: any) => void;
+                                    };
+                                    ids: {
+                                        unique: (element: HTMLElement) => void;
+                                    };
+                                };
+                                helpers: {
+                                    editor: {
+                                        ensure: {
+                                            uniqueIds: (element: HTMLElement, state: {
+                                                maxNodeId: number;
+                                            }) => HTMLElement;
+                                            selectionIsInEditor: (range: Range) => void;
+                                        };
+                                        cursor: {
+                                            storePosition: (state: {
+                                                selectedRange: Range;
+                                            }) => void;
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                    };
+                                    editorNode: {
+                                        get: {
+                                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                        };
+                                    };
+                                    htmlNode: {
+                                        copy: {
+                                            children: (from: HTMLElement, to: HTMLElement) => void;
+                                        };
+                                        insert: {
+                                            text: (element: Node, text: string, offset: any) => void;
+                                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                        };
+                                        get: {
+                                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                            nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                        };
+                                        remove: {
+                                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                        };
+                                        strip: {
+                                            after: (element: HTMLElement, splitter: string) => void;
+                                            before: (element: HTMLElement, splitter: string) => void;
+                                        };
+                                        surround: {
+                                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                        };
+                                    };
+                                };
+                            };
+                        }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+                onFailure: {
+                    plugin: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    content: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    set: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    toolbarAction: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    formatting: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    element: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                    commands: {
+                        subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                    };
+                };
+            } & {
+                plugin: () => {
+                    register: {
+                        plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                        plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                        context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                    };
+                };
+                content: () => {
+                    sync: () => import("../models/EditorModels").FlowContent;
+                    set: {
+                        byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                        byString: (content: string) => void;
+                    };
+                };
+                set: () => {
+                    mode: (editMode: boolean) => void;
+                    container: (el: HTMLDivElement) => void;
+                    focus: () => void;
+                    placeHolderVisibility: () => void;
+                };
+                toolbarAction: () => {
+                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                };
+                formatting: () => {
+                    add: (element: HTMLElement) => void;
+                    toggle: (element: HTMLElement) => void;
+                    remove: (dataType: string) => void;
+                };
+                element: () => {
+                    createForComponent: (componentName: string) => HTMLDivElement;
+                    createText: () => HTMLParagraphElement;
+                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                    createTextNode: (data: any) => Text;
+                    add: (element: HTMLElement) => void;
+                };
+                commands: () => {
+                    exec: (command: string, data: object) => void;
+                    builtIn: {
+                        content: {
+                            convert: (element: HTMLElement) => void;
+                        };
+                        ensure: {
+                            lastElement: () => void;
+                            unique: {
+                                ids: (element: HTMLElement) => void;
+                            };
+                        };
+                        selection: {
+                            get: {
+                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                        cursor: {
+                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                        };
+                        actions: {
+                            setSelection: () => void;
+                        };
+                        formatting: {
+                            add: (element: HTMLElement) => void;
+                            remove: (dataType: string | HTMLElement) => void;
+                            has: (dataType: string | HTMLElement) => boolean;
+                        };
+                        element: {
+                            clean: (element: HTMLElement) => void;
+                            add: (element: HTMLElement) => void;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createText: () => HTMLParagraphElement;
+                            createTextNode: (data: any) => Text;
+                            createComponent: (componentName: string) => HTMLDivElement;
+                            insert: {
+                                text: (element: Node, text: string, offset: any) => void;
+                            };
+                            ids: {
+                                unique: (element: HTMLElement) => void;
+                            };
+                        };
+                        helpers: {
+                            editor: {
+                                ensure: {
+                                    uniqueIds: (element: HTMLElement, state: {
+                                        maxNodeId: number;
+                                    }) => HTMLElement;
+                                    selectionIsInEditor: (range: Range) => void;
+                                };
+                                cursor: {
+                                    storePosition: (state: {
+                                        selectedRange: Range;
+                                    }) => void;
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                            };
+                            editorNode: {
+                                get: {
+                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                };
+                            };
+                            htmlNode: {
+                                copy: {
+                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                };
+                                insert: {
+                                    text: (element: Node, text: string, offset: any) => void;
+                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                };
+                                get: {
+                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                    nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                };
+                                remove: {
+                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                };
+                                strip: {
+                                    after: (element: HTMLElement, splitter: string) => void;
+                                    before: (element: HTMLElement, splitter: string) => void;
+                                };
+                                surround: {
+                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            get: {
+                plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                content: {
+                    isEmpty: () => boolean;
+                    asJSON: () => import("../models/EditorModels").FlowContent;
+                    asString: () => string;
+                };
+                selection: {
+                    has: {
+                        type: (pluginType: string) => boolean;
+                    };
+                    get: {
+                        byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                    };
+                };
+            };
+        } & {
+            dispose?: () => void;
+        }>;
+        onMutatedShow: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+        onMutatedCustomActionRenderer: import("@omnia/fx").MessageBusExposeOnlySubscription<() => JSX.Element>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching: {
+            setCustomRenderer: {
+                subscribe(fn: (renderer: () => JSX.Element) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeAllActions: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setActiveEditorStore: {
+                subscribe(fn: (store: {
+                    state: {
+                        editorContent: import("../models/EditorModels").FlowContent;
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        hideToolbar: boolean;
+                        editMode: boolean;
+                        maxNodeId: number;
+                        toolbarActions: FlowEditorActionRegistration[];
+                        editor: HTMLDivElement;
+                        nodeSelection: import("../models/EditorModels").NodeSelection;
+                        telePorts: JSX.Element[];
+                        id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
+                        selectedRange: Range;
+                        showPlaceHolder: boolean;
+                    };
+                    events: {
+                        onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").FlowContent>;
+                        onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPlugin[]>;
+                        onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+                        onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+                        onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+                        onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").NodeSelection>;
+                        onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+                        onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+                        onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPluginContext>;
+                        onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+                        onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+                    actions: {
+                        onDispatching: {
+                            plugin: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onDispatched: {
+                            plugin: {
+                                subscribe(fn: (result: {
+                                    register: {
+                                        plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                        plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                        context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (result: {
+                                    sync: () => import("../models/EditorModels").FlowContent;
+                                    set: {
+                                        byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                        byString: (content: string) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (result: {
+                                    mode: (editMode: boolean) => void;
+                                    container: (el: HTMLDivElement) => void;
+                                    focus: () => void;
+                                    placeHolderVisibility: () => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (result: {
+                                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (result: {
+                                    add: (element: HTMLElement) => void;
+                                    toggle: (element: HTMLElement) => void;
+                                    remove: (dataType: string) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (result: {
+                                    createForComponent: (componentName: string) => HTMLDivElement;
+                                    createText: () => HTMLParagraphElement;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createTextNode: (data: any) => Text;
+                                    add: (element: HTMLElement) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (result: {
+                                    exec: (command: string, data: object) => void;
+                                    builtIn: {
+                                        content: {
+                                            convert: (element: HTMLElement) => void;
+                                        };
+                                        ensure: {
+                                            lastElement: () => void;
+                                            unique: {
+                                                ids: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        selection: {
+                                            get: {
+                                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                            };
+                                        };
+                                        cursor: {
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                        actions: {
+                                            setSelection: () => void;
+                                        };
+                                        formatting: {
+                                            add: (element: HTMLElement) => void;
+                                            remove: (dataType: string | HTMLElement) => void;
+                                            has: (dataType: string | HTMLElement) => boolean;
+                                        };
+                                        element: {
+                                            clean: (element: HTMLElement) => void;
+                                            add: (element: HTMLElement) => void;
+                                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                            createText: () => HTMLParagraphElement;
+                                            createTextNode: (data: any) => Text;
+                                            createComponent: (componentName: string) => HTMLDivElement;
+                                            insert: {
+                                                text: (element: Node, text: string, offset: any) => void;
+                                            };
+                                            ids: {
+                                                unique: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        helpers: {
+                                            editor: {
+                                                ensure: {
+                                                    uniqueIds: (element: HTMLElement, state: {
+                                                        maxNodeId: number;
+                                                    }) => HTMLElement;
+                                                    selectionIsInEditor: (range: Range) => void;
+                                                };
+                                                cursor: {
+                                                    storePosition: (state: {
+                                                        selectedRange: Range;
+                                                    }) => void;
+                                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                                };
+                                            };
+                                            editorNode: {
+                                                get: {
+                                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                                };
+                                            };
+                                            htmlNode: {
+                                                copy: {
+                                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                                };
+                                                insert: {
+                                                    text: (element: Node, text: string, offset: any) => void;
+                                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                                };
+                                                get: {
+                                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                                    nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                                };
+                                                remove: {
+                                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                                };
+                                                strip: {
+                                                    after: (element: HTMLElement, splitter: string) => void;
+                                                    before: (element: HTMLElement, splitter: string) => void;
+                                                };
+                                                surround: {
+                                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                                };
+                                            };
+                                        };
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onFailure: {
+                            plugin: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                    } & {
+                        plugin: () => {
+                            register: {
+                                plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                            };
+                        };
+                        content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
+                            set: {
+                                byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                byString: (content: string) => void;
+                            };
+                        };
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
+                        toolbarAction: () => {
+                            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                        };
+                        formatting: () => {
+                            add: (element: HTMLElement) => void;
+                            toggle: (element: HTMLElement) => void;
+                            remove: (dataType: string) => void;
+                        };
+                        element: () => {
+                            createForComponent: (componentName: string) => HTMLDivElement;
+                            createText: () => HTMLParagraphElement;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createTextNode: (data: any) => Text;
+                            add: (element: HTMLElement) => void;
+                        };
+                        commands: () => {
+                            exec: (command: string, data: object) => void;
+                            builtIn: {
+                                content: {
+                                    convert: (element: HTMLElement) => void;
+                                };
+                                ensure: {
+                                    lastElement: () => void;
+                                    unique: {
+                                        ids: (element: HTMLElement) => void;
+                                    };
+                                };
+                                selection: {
+                                    get: {
+                                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                    };
+                                };
+                                cursor: {
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                                actions: {
+                                    setSelection: () => void;
+                                };
+                                formatting: {
+                                    add: (element: HTMLElement) => void;
+                                    remove: (dataType: string | HTMLElement) => void;
+                                    has: (dataType: string | HTMLElement) => boolean;
+                                };
+                                element: {
+                                    clean: (element: HTMLElement) => void;
+                                    add: (element: HTMLElement) => void;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createText: () => HTMLParagraphElement;
+                                    createTextNode: (data: any) => Text;
+                                    createComponent: (componentName: string) => HTMLDivElement;
+                                    insert: {
+                                        text: (element: Node, text: string, offset: any) => void;
+                                    };
+                                    ids: {
+                                        unique: (element: HTMLElement) => void;
+                                    };
+                                };
+                                helpers: {
+                                    editor: {
+                                        ensure: {
+                                            uniqueIds: (element: HTMLElement, state: {
+                                                maxNodeId: number;
+                                            }) => HTMLElement;
+                                            selectionIsInEditor: (range: Range) => void;
+                                        };
+                                        cursor: {
+                                            storePosition: (state: {
+                                                selectedRange: Range;
+                                            }) => void;
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                    };
+                                    editorNode: {
+                                        get: {
+                                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                        };
+                                    };
+                                    htmlNode: {
+                                        copy: {
+                                            children: (from: HTMLElement, to: HTMLElement) => void;
+                                        };
+                                        insert: {
+                                            text: (element: Node, text: string, offset: any) => void;
+                                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                        };
+                                        get: {
+                                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                            nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                        };
+                                        remove: {
+                                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                        };
+                                        strip: {
+                                            after: (element: HTMLElement, splitter: string) => void;
+                                            before: (element: HTMLElement, splitter: string) => void;
+                                        };
+                                        surround: {
+                                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    get: {
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        content: {
+                            isEmpty: () => boolean;
+                            asJSON: () => import("../models/EditorModels").FlowContent;
+                            asString: () => string;
+                        };
+                        selection: {
+                            has: {
+                                type: (pluginType: string) => boolean;
+                            };
+                            get: {
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                    };
+                } & {
+                    dispose?: () => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setVisibility: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            setCustomRenderer: {
+                subscribe(fn: (result: void, renderer: () => JSX.Element) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeAllActions: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setActiveEditorStore: {
+                subscribe(fn: (result: void, store: {
+                    state: {
+                        editorContent: import("../models/EditorModels").FlowContent;
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        hideToolbar: boolean;
+                        editMode: boolean;
+                        maxNodeId: number;
+                        toolbarActions: FlowEditorActionRegistration[];
+                        editor: HTMLDivElement;
+                        nodeSelection: import("../models/EditorModels").NodeSelection;
+                        telePorts: JSX.Element[];
+                        id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
+                        selectedRange: Range;
+                        showPlaceHolder: boolean;
+                    };
+                    events: {
+                        onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").FlowContent>;
+                        onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPlugin[]>;
+                        onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+                        onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+                        onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+                        onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").NodeSelection>;
+                        onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+                        onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+                        onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPluginContext>;
+                        onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+                        onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+                    actions: {
+                        onDispatching: {
+                            plugin: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onDispatched: {
+                            plugin: {
+                                subscribe(fn: (result: {
+                                    register: {
+                                        plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                        plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                        context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (result: {
+                                    sync: () => import("../models/EditorModels").FlowContent;
+                                    set: {
+                                        byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                        byString: (content: string) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (result: {
+                                    mode: (editMode: boolean) => void;
+                                    container: (el: HTMLDivElement) => void;
+                                    focus: () => void;
+                                    placeHolderVisibility: () => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (result: {
+                                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (result: {
+                                    add: (element: HTMLElement) => void;
+                                    toggle: (element: HTMLElement) => void;
+                                    remove: (dataType: string) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (result: {
+                                    createForComponent: (componentName: string) => HTMLDivElement;
+                                    createText: () => HTMLParagraphElement;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createTextNode: (data: any) => Text;
+                                    add: (element: HTMLElement) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (result: {
+                                    exec: (command: string, data: object) => void;
+                                    builtIn: {
+                                        content: {
+                                            convert: (element: HTMLElement) => void;
+                                        };
+                                        ensure: {
+                                            lastElement: () => void;
+                                            unique: {
+                                                ids: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        selection: {
+                                            get: {
+                                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                            };
+                                        };
+                                        cursor: {
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                        actions: {
+                                            setSelection: () => void;
+                                        };
+                                        formatting: {
+                                            add: (element: HTMLElement) => void;
+                                            remove: (dataType: string | HTMLElement) => void;
+                                            has: (dataType: string | HTMLElement) => boolean;
+                                        };
+                                        element: {
+                                            clean: (element: HTMLElement) => void;
+                                            add: (element: HTMLElement) => void;
+                                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                            createText: () => HTMLParagraphElement;
+                                            createTextNode: (data: any) => Text;
+                                            createComponent: (componentName: string) => HTMLDivElement;
+                                            insert: {
+                                                text: (element: Node, text: string, offset: any) => void;
+                                            };
+                                            ids: {
+                                                unique: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        helpers: {
+                                            editor: {
+                                                ensure: {
+                                                    uniqueIds: (element: HTMLElement, state: {
+                                                        maxNodeId: number;
+                                                    }) => HTMLElement;
+                                                    selectionIsInEditor: (range: Range) => void;
+                                                };
+                                                cursor: {
+                                                    storePosition: (state: {
+                                                        selectedRange: Range;
+                                                    }) => void;
+                                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                                };
+                                            };
+                                            editorNode: {
+                                                get: {
+                                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                                };
+                                            };
+                                            htmlNode: {
+                                                copy: {
+                                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                                };
+                                                insert: {
+                                                    text: (element: Node, text: string, offset: any) => void;
+                                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                                };
+                                                get: {
+                                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                                    nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                                };
+                                                remove: {
+                                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                                };
+                                                strip: {
+                                                    after: (element: HTMLElement, splitter: string) => void;
+                                                    before: (element: HTMLElement, splitter: string) => void;
+                                                };
+                                                surround: {
+                                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                                };
+                                            };
+                                        };
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onFailure: {
+                            plugin: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                    } & {
+                        plugin: () => {
+                            register: {
+                                plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                            };
+                        };
+                        content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
+                            set: {
+                                byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                byString: (content: string) => void;
+                            };
+                        };
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
+                        toolbarAction: () => {
+                            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                        };
+                        formatting: () => {
+                            add: (element: HTMLElement) => void;
+                            toggle: (element: HTMLElement) => void;
+                            remove: (dataType: string) => void;
+                        };
+                        element: () => {
+                            createForComponent: (componentName: string) => HTMLDivElement;
+                            createText: () => HTMLParagraphElement;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createTextNode: (data: any) => Text;
+                            add: (element: HTMLElement) => void;
+                        };
+                        commands: () => {
+                            exec: (command: string, data: object) => void;
+                            builtIn: {
+                                content: {
+                                    convert: (element: HTMLElement) => void;
+                                };
+                                ensure: {
+                                    lastElement: () => void;
+                                    unique: {
+                                        ids: (element: HTMLElement) => void;
+                                    };
+                                };
+                                selection: {
+                                    get: {
+                                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                    };
+                                };
+                                cursor: {
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                                actions: {
+                                    setSelection: () => void;
+                                };
+                                formatting: {
+                                    add: (element: HTMLElement) => void;
+                                    remove: (dataType: string | HTMLElement) => void;
+                                    has: (dataType: string | HTMLElement) => boolean;
+                                };
+                                element: {
+                                    clean: (element: HTMLElement) => void;
+                                    add: (element: HTMLElement) => void;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createText: () => HTMLParagraphElement;
+                                    createTextNode: (data: any) => Text;
+                                    createComponent: (componentName: string) => HTMLDivElement;
+                                    insert: {
+                                        text: (element: Node, text: string, offset: any) => void;
+                                    };
+                                    ids: {
+                                        unique: (element: HTMLElement) => void;
+                                    };
+                                };
+                                helpers: {
+                                    editor: {
+                                        ensure: {
+                                            uniqueIds: (element: HTMLElement, state: {
+                                                maxNodeId: number;
+                                            }) => HTMLElement;
+                                            selectionIsInEditor: (range: Range) => void;
+                                        };
+                                        cursor: {
+                                            storePosition: (state: {
+                                                selectedRange: Range;
+                                            }) => void;
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                    };
+                                    editorNode: {
+                                        get: {
+                                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                        };
+                                    };
+                                    htmlNode: {
+                                        copy: {
+                                            children: (from: HTMLElement, to: HTMLElement) => void;
+                                        };
+                                        insert: {
+                                            text: (element: Node, text: string, offset: any) => void;
+                                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                        };
+                                        get: {
+                                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                            nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                        };
+                                        remove: {
+                                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                        };
+                                        strip: {
+                                            after: (element: HTMLElement, splitter: string) => void;
+                                            before: (element: HTMLElement, splitter: string) => void;
+                                        };
+                                        surround: {
+                                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    get: {
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        content: {
+                            isEmpty: () => boolean;
+                            asJSON: () => import("../models/EditorModels").FlowContent;
+                            asString: () => string;
+                        };
+                        selection: {
+                            has: {
+                                type: (pluginType: string) => boolean;
+                            };
+                            get: {
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                    };
+                } & {
+                    dispose?: () => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setVisibility: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            setCustomRenderer: {
+                subscribe(fn: (failureReason: any, renderer: () => JSX.Element) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeAllActions: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setActiveEditorStore: {
+                subscribe(fn: (failureReason: any, store: {
+                    state: {
+                        editorContent: import("../models/EditorModels").FlowContent;
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        hideToolbar: boolean;
+                        editMode: boolean;
+                        maxNodeId: number;
+                        toolbarActions: FlowEditorActionRegistration[];
+                        editor: HTMLDivElement;
+                        nodeSelection: import("../models/EditorModels").NodeSelection;
+                        telePorts: JSX.Element[];
+                        id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
+                        selectedRange: Range;
+                        showPlaceHolder: boolean;
+                    };
+                    events: {
+                        onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").FlowContent>;
+                        onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPlugin[]>;
+                        onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                        onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+                        onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+                        onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+                        onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorModels").NodeSelection>;
+                        onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+                        onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+                        onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<import("../models/EditorPlugin").FlowEditorPluginContext>;
+                        onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+                        onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+                    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+                    actions: {
+                        onDispatching: {
+                            plugin: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onDispatched: {
+                            plugin: {
+                                subscribe(fn: (result: {
+                                    register: {
+                                        plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                        plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                        context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (result: {
+                                    sync: () => import("../models/EditorModels").FlowContent;
+                                    set: {
+                                        byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                        byString: (content: string) => void;
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (result: {
+                                    mode: (editMode: boolean) => void;
+                                    container: (el: HTMLDivElement) => void;
+                                    focus: () => void;
+                                    placeHolderVisibility: () => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (result: {
+                                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (result: {
+                                    add: (element: HTMLElement) => void;
+                                    toggle: (element: HTMLElement) => void;
+                                    remove: (dataType: string) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (result: {
+                                    createForComponent: (componentName: string) => HTMLDivElement;
+                                    createText: () => HTMLParagraphElement;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createTextNode: (data: any) => Text;
+                                    add: (element: HTMLElement) => void;
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (result: {
+                                    exec: (command: string, data: object) => void;
+                                    builtIn: {
+                                        content: {
+                                            convert: (element: HTMLElement) => void;
+                                        };
+                                        ensure: {
+                                            lastElement: () => void;
+                                            unique: {
+                                                ids: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        selection: {
+                                            get: {
+                                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                            };
+                                        };
+                                        cursor: {
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                        actions: {
+                                            setSelection: () => void;
+                                        };
+                                        formatting: {
+                                            add: (element: HTMLElement) => void;
+                                            remove: (dataType: string | HTMLElement) => void;
+                                            has: (dataType: string | HTMLElement) => boolean;
+                                        };
+                                        element: {
+                                            clean: (element: HTMLElement) => void;
+                                            add: (element: HTMLElement) => void;
+                                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                            createText: () => HTMLParagraphElement;
+                                            createTextNode: (data: any) => Text;
+                                            createComponent: (componentName: string) => HTMLDivElement;
+                                            insert: {
+                                                text: (element: Node, text: string, offset: any) => void;
+                                            };
+                                            ids: {
+                                                unique: (element: HTMLElement) => void;
+                                            };
+                                        };
+                                        helpers: {
+                                            editor: {
+                                                ensure: {
+                                                    uniqueIds: (element: HTMLElement, state: {
+                                                        maxNodeId: number;
+                                                    }) => HTMLElement;
+                                                    selectionIsInEditor: (range: Range) => void;
+                                                };
+                                                cursor: {
+                                                    storePosition: (state: {
+                                                        selectedRange: Range;
+                                                    }) => void;
+                                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                                };
+                                            };
+                                            editorNode: {
+                                                get: {
+                                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                                };
+                                            };
+                                            htmlNode: {
+                                                copy: {
+                                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                                };
+                                                insert: {
+                                                    text: (element: Node, text: string, offset: any) => void;
+                                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                                };
+                                                get: {
+                                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                                    nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                                };
+                                                remove: {
+                                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                                };
+                                                strip: {
+                                                    after: (element: HTMLElement, splitter: string) => void;
+                                                    before: (element: HTMLElement, splitter: string) => void;
+                                                };
+                                                surround: {
+                                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                                };
+                                            };
+                                        };
+                                    };
+                                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                        onFailure: {
+                            plugin: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            content: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            set: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            toolbarAction: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            formatting: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            element: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                            commands: {
+                                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                            };
+                        };
+                    } & {
+                        plugin: () => {
+                            register: {
+                                plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                                plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                                context: (ctx: import("../models/EditorPlugin").FlowEditorPluginContext) => void;
+                            };
+                        };
+                        content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
+                            set: {
+                                byJSON: (content: import("../models/EditorModels").FlowContent) => void;
+                                byString: (content: string) => void;
+                            };
+                        };
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
+                        toolbarAction: () => {
+                            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                        };
+                        formatting: () => {
+                            add: (element: HTMLElement) => void;
+                            toggle: (element: HTMLElement) => void;
+                            remove: (dataType: string) => void;
+                        };
+                        element: () => {
+                            createForComponent: (componentName: string) => HTMLDivElement;
+                            createText: () => HTMLParagraphElement;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createTextNode: (data: any) => Text;
+                            add: (element: HTMLElement) => void;
+                        };
+                        commands: () => {
+                            exec: (command: string, data: object) => void;
+                            builtIn: {
+                                content: {
+                                    convert: (element: HTMLElement) => void;
+                                };
+                                ensure: {
+                                    lastElement: () => void;
+                                    unique: {
+                                        ids: (element: HTMLElement) => void;
+                                    };
+                                };
+                                selection: {
+                                    get: {
+                                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                    };
+                                };
+                                cursor: {
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                                actions: {
+                                    setSelection: () => void;
+                                };
+                                formatting: {
+                                    add: (element: HTMLElement) => void;
+                                    remove: (dataType: string | HTMLElement) => void;
+                                    has: (dataType: string | HTMLElement) => boolean;
+                                };
+                                element: {
+                                    clean: (element: HTMLElement) => void;
+                                    add: (element: HTMLElement) => void;
+                                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                                    createText: () => HTMLParagraphElement;
+                                    createTextNode: (data: any) => Text;
+                                    createComponent: (componentName: string) => HTMLDivElement;
+                                    insert: {
+                                        text: (element: Node, text: string, offset: any) => void;
+                                    };
+                                    ids: {
+                                        unique: (element: HTMLElement) => void;
+                                    };
+                                };
+                                helpers: {
+                                    editor: {
+                                        ensure: {
+                                            uniqueIds: (element: HTMLElement, state: {
+                                                maxNodeId: number;
+                                            }) => HTMLElement;
+                                            selectionIsInEditor: (range: Range) => void;
+                                        };
+                                        cursor: {
+                                            storePosition: (state: {
+                                                selectedRange: Range;
+                                            }) => void;
+                                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                        };
+                                    };
+                                    editorNode: {
+                                        get: {
+                                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                        };
+                                    };
+                                    htmlNode: {
+                                        copy: {
+                                            children: (from: HTMLElement, to: HTMLElement) => void;
+                                        };
+                                        insert: {
+                                            text: (element: Node, text: string, offset: any) => void;
+                                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                        };
+                                        get: {
+                                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                            nodeSelectionForRange: (range: Range) => import("../models/EditorModels").NodeSelection;
+                                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                        };
+                                        remove: {
+                                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                        };
+                                        strip: {
+                                            after: (element: HTMLElement, splitter: string) => void;
+                                            before: (element: HTMLElement, splitter: string) => void;
+                                        };
+                                        surround: {
+                                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    get: {
+                        plugins: import("../models/EditorPlugin").FlowEditorPlugin[];
+                        content: {
+                            isEmpty: () => boolean;
+                            asJSON: () => import("../models/EditorModels").FlowContent;
+                            asString: () => string;
+                        };
+                        selection: {
+                            has: {
+                                type: (pluginType: string) => boolean;
+                            };
+                            get: {
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                    };
+                } & {
+                    dispose?: () => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setVisibility: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        setCustomRenderer: (renderer: () => JSX.Element) => void;
+        removeAllActions: () => void;
+        setActiveEditorStore: (store: ReturnType<typeof useFlowEditorStore>) => void;
+        setVisibility: (show: boolean) => void;
+    };
+    get: {
+        isActiveStore(): boolean;
+        actionsGroupedAndSorted(): FlowEditorActionRegistration[][];
+    };
+} & {
+    dispose?: () => void;
+};