npm - @omnia/fx - Versions diffs - 8.0.265-dev → 8.0.266-dev - Mend

@omnia/fx 8.0.265-dev → 8.0.266-dev

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

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

@@ -14,6 +14,7 @@ export declare const useFlowEditorToolbarStore: () => {
                 nodeSelection: import("../models/EditorModels").NodeSelection;
                 telePorts: JSX.Element[];
                 id: string;
+                pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
                 selectedRange: Range;
                 showPlaceHolder: boolean;
             };
@@ -28,6 +29,7 @@ export declare const useFlowEditorToolbarStore: () => {
                 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>>;
@@ -39,13 +41,7 @@ export declare const useFlowEditorToolbarStore: () => {
                     content: {
                         subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
+                    set: {
                         subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
                     toolbarAction: {
@@ -73,20 +69,20 @@ export declare const useFlowEditorToolbarStore: () => {
                     };
                     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;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
-                        subscribe(fn: (result: 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: {
@@ -112,6 +108,94 @@ export declare const useFlowEditorToolbarStore: () => {
                     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;
                     };
                 };
@@ -122,13 +206,7 @@ export declare const useFlowEditorToolbarStore: () => {
                     content: {
                         subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
+                    set: {
                         subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
                     toolbarAction: {
@@ -153,14 +231,18 @@ export declare const useFlowEditorToolbarStore: () => {
                     };
                 };
                 content: () => {
+                    sync: () => import("../models/EditorModels").FlowContent;
                     set: {
                         byJSON: (content: import("../models/EditorModels").FlowContent) => void;
                         byString: (content: string) => void;
                     };
                 };
-                setEditorMode: (editMode: boolean) => void;
-                setEditorContainer: (el: HTMLDivElement) => void;
-                focusEditor: () => void;
+                set: () => {
+                    mode: (editMode: boolean) => void;
+                    container: (el: HTMLDivElement) => void;
+                    focus: () => void;
+                    placeHolderVisibility: () => void;
+                };
                 toolbarAction: () => {
                     add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
                 };
@@ -178,6 +260,94 @@ export declare const useFlowEditorToolbarStore: () => {
                 };
                 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: {
@@ -189,10 +359,10 @@ export declare const useFlowEditorToolbarStore: () => {
                 };
                 selection: {
                     has: {
-                        dataType: (dataType: string) => boolean;
+                        type: (pluginType: string) => boolean;
                     };
                     get: {
-                        byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                        byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
                     };
                 };
             };
@@ -216,6 +386,7 @@ export declare const useFlowEditorToolbarStore: () => {
                 nodeSelection: import("../models/EditorModels").NodeSelection;
                 telePorts: JSX.Element[];
                 id: string;
+                pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
                 selectedRange: Range;
                 showPlaceHolder: boolean;
             };
@@ -230,6 +401,7 @@ export declare const useFlowEditorToolbarStore: () => {
                 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>>;
@@ -241,13 +413,7 @@ export declare const useFlowEditorToolbarStore: () => {
                     content: {
                         subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
+                    set: {
                         subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
                     toolbarAction: {
@@ -275,20 +441,20 @@ export declare const useFlowEditorToolbarStore: () => {
                     };
                     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;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
-                        subscribe(fn: (result: 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: {
@@ -314,6 +480,94 @@ export declare const useFlowEditorToolbarStore: () => {
                     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;
                     };
                 };
@@ -324,13 +578,7 @@ export declare const useFlowEditorToolbarStore: () => {
                     content: {
                         subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
-                    setEditorMode: {
-                        subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    setEditorContainer: {
-                        subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                    };
-                    focusEditor: {
+                    set: {
                         subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                     };
                     toolbarAction: {
@@ -355,14 +603,18 @@ export declare const useFlowEditorToolbarStore: () => {
                     };
                 };
                 content: () => {
+                    sync: () => import("../models/EditorModels").FlowContent;
                     set: {
                         byJSON: (content: import("../models/EditorModels").FlowContent) => void;
                         byString: (content: string) => void;
                     };
                 };
-                setEditorMode: (editMode: boolean) => void;
-                setEditorContainer: (el: HTMLDivElement) => void;
-                focusEditor: () => void;
+                set: () => {
+                    mode: (editMode: boolean) => void;
+                    container: (el: HTMLDivElement) => void;
+                    focus: () => void;
+                    placeHolderVisibility: () => void;
+                };
                 toolbarAction: () => {
                     add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
                 };
@@ -380,6 +632,94 @@ export declare const useFlowEditorToolbarStore: () => {
                 };
                 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: {
@@ -391,10 +731,10 @@ export declare const useFlowEditorToolbarStore: () => {
                 };
                 selection: {
                     has: {
-                        dataType: (dataType: string) => boolean;
+                        type: (pluginType: string) => boolean;
                     };
                     get: {
-                        byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                        byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
                     };
                 };
             };
@@ -426,6 +766,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         nodeSelection: import("../models/EditorModels").NodeSelection;
                         telePorts: JSX.Element[];
                         id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
                         selectedRange: Range;
                         showPlaceHolder: boolean;
                     };
@@ -440,6 +781,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         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>>;
@@ -451,13 +793,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -485,20 +821,20 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                             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;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
-                                subscribe(fn: (result: 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: {
@@ -524,6 +860,94 @@ export declare const useFlowEditorToolbarStore: () => {
                             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;
                             };
                         };
@@ -534,13 +958,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -565,14 +983,18 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                         };
                         content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
                             set: {
                                 byJSON: (content: import("../models/EditorModels").FlowContent) => void;
                                 byString: (content: string) => void;
                             };
                         };
-                        setEditorMode: (editMode: boolean) => void;
-                        setEditorContainer: (el: HTMLDivElement) => void;
-                        focusEditor: () => void;
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
                         toolbarAction: () => {
                             add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
                         };
@@ -590,6 +1012,94 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         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: {
@@ -601,10 +1111,10 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         selection: {
                             has: {
-                                dataType: (dataType: string) => boolean;
+                                type: (pluginType: string) => boolean;
                             };
                             get: {
-                                byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
                             };
                         };
                     };
@@ -636,6 +1146,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         nodeSelection: import("../models/EditorModels").NodeSelection;
                         telePorts: JSX.Element[];
                         id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
                         selectedRange: Range;
                         showPlaceHolder: boolean;
                     };
@@ -650,6 +1161,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         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>>;
@@ -661,13 +1173,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -695,20 +1201,20 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                             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;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
-                                subscribe(fn: (result: 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: {
@@ -734,6 +1240,94 @@ export declare const useFlowEditorToolbarStore: () => {
                             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;
                             };
                         };
@@ -744,13 +1338,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -775,14 +1363,18 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                         };
                         content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
                             set: {
                                 byJSON: (content: import("../models/EditorModels").FlowContent) => void;
                                 byString: (content: string) => void;
                             };
                         };
-                        setEditorMode: (editMode: boolean) => void;
-                        setEditorContainer: (el: HTMLDivElement) => void;
-                        focusEditor: () => void;
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
                         toolbarAction: () => {
                             add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
                         };
@@ -800,6 +1392,94 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         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: {
@@ -811,10 +1491,10 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         selection: {
                             has: {
-                                dataType: (dataType: string) => boolean;
+                                type: (pluginType: string) => boolean;
                             };
                             get: {
-                                byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
                             };
                         };
                     };
@@ -846,6 +1526,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         nodeSelection: import("../models/EditorModels").NodeSelection;
                         telePorts: JSX.Element[];
                         id: string;
+                        pluginContext: import("../models/EditorPlugin").FlowEditorPluginContext;
                         selectedRange: Range;
                         showPlaceHolder: boolean;
                     };
@@ -860,6 +1541,7 @@ export declare const useFlowEditorToolbarStore: () => {
                         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>>;
@@ -871,13 +1553,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -905,20 +1581,20 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                             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;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
-                                subscribe(fn: (result: 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: {
@@ -944,6 +1620,94 @@ export declare const useFlowEditorToolbarStore: () => {
                             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;
                             };
                         };
@@ -954,13 +1718,7 @@ export declare const useFlowEditorToolbarStore: () => {
                             content: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
-                            setEditorMode: {
-                                subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            setEditorContainer: {
-                                subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-                            };
-                            focusEditor: {
+                            set: {
                                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
                             };
                             toolbarAction: {
@@ -985,14 +1743,18 @@ export declare const useFlowEditorToolbarStore: () => {
                             };
                         };
                         content: () => {
+                            sync: () => import("../models/EditorModels").FlowContent;
                             set: {
                                 byJSON: (content: import("../models/EditorModels").FlowContent) => void;
                                 byString: (content: string) => void;
                             };
                         };
-                        setEditorMode: (editMode: boolean) => void;
-                        setEditorContainer: (el: HTMLDivElement) => void;
-                        focusEditor: () => void;
+                        set: () => {
+                            mode: (editMode: boolean) => void;
+                            container: (el: HTMLDivElement) => void;
+                            focus: () => void;
+                            placeHolderVisibility: () => void;
+                        };
                         toolbarAction: () => {
                             add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
                         };
@@ -1010,6 +1772,94 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         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: {
@@ -1021,10 +1871,10 @@ export declare const useFlowEditorToolbarStore: () => {
                         };
                         selection: {
                             has: {
-                                dataType: (dataType: string) => boolean;
+                                type: (pluginType: string) => boolean;
                             };
                             get: {
-                                byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
                             };
                         };
                     };