@omnia/fx 8.0.288-dev → 8.0.290-dev

package/internal-do-not-import-from-here/ux/flow/editor/plugins/typography/TypographyButton.d.ts

@@ -1,2 +1,451 @@
-declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{}>) => any;
+import { FlowNodeReference } from "@omnia/fx/ux";
+import { guid } from "@omnia/fx-models";
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
+    store?: {
+        state: {
+            editorContent: import("@omnia/fx/ux").FlowContent;
+            plugins: import("@omnia/fx/ux").FlowEditorPlugin[];
+            pluginsLoadedPromise: import("@omnia/fx-models").Future<void>;
+            hideToolbar: boolean;
+            toolbarActions: import("@omnia/fx-models").FlowEditorActionRegistration[];
+            editor: HTMLDivElement;
+            nodeSelection: import("@omnia/fx/ux").NodeSelection;
+            telePorts: JSX.Element[];
+            id: string;
+            pluginContext: import("@omnia/fx/ux").FlowEditorPluginContext;
+            selectedRange: Range;
+            storedRange: Range;
+            showPlaceHolder: boolean;
+            definitionSelector: {
+                show: boolean;
+                categoryFilters: guid[];
+                rendererTypeFilters: guid[];
+            };
+            settings: {
+                gridWidth: number;
+            };
+        };
+        events: {
+            onMutatedEditorContent: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx/ux").FlowContent>;
+            onMutatedPlugins: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx/ux").FlowEditorPlugin[]>;
+            onMutatedPluginsLoadedPromise: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx-models").Future<void>>;
+            onMutatedHideToolbar: import("../../../../..").MessageBusExposeOnlySubscription<boolean>;
+            onMutatedToolbarActions: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx-models").FlowEditorActionRegistration[]>;
+            onMutatedEditor: import("../../../../..").MessageBusExposeOnlySubscription<HTMLDivElement>;
+            onMutatedNodeSelection: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx/ux").NodeSelection>;
+            onMutatedTelePorts: import("../../../../..").MessageBusExposeOnlySubscription<JSX.Element[]>;
+            onMutatedId: import("../../../../..").MessageBusExposeOnlySubscription<string>;
+            onMutatedPluginContext: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx/ux").FlowEditorPluginContext>;
+            onMutatedSelectedRange: import("../../../../..").MessageBusExposeOnlySubscription<Range>;
+            onMutatedStoredRange: import("../../../../..").MessageBusExposeOnlySubscription<Range>;
+            onMutatedShowPlaceHolder: import("../../../../..").MessageBusExposeOnlySubscription<boolean>;
+            onMutatedDefinitionSelector: import("../../../../..").MessageBusExposeOnlySubscription<{
+                show: boolean;
+                categoryFilters: guid[];
+                rendererTypeFilters: guid[];
+            }>;
+            onMutatedSettings: import("../../../../..").MessageBusExposeOnlySubscription<{
+                gridWidth: number;
+            }>;
+        } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+        actions: {
+            onDispatching: {
+                confirm: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                plugin: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                content: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                set: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                toolbarAction: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                formatting: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                element: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                commands: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+            };
+            onDispatched: {
+                confirm: {
+                    subscribe(fn: (result: {
+                        delete: {
+                            container: (element: HTMLElement) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: (result: {
+                        set: (elements: Node | Array<Node>) => void;
+                        capture: () => void;
+                        store: () => void;
+                        revertToStored: () => void;
+                        ensure: () => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                plugin: {
+                    subscribe(fn: (result: {
+                        register: {
+                            plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                            plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                            context: (ctx: import("@omnia/fx/ux").FlowEditorPluginContext) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                content: {
+                    subscribe(fn: (result: {
+                        sync: () => void;
+                        set: {
+                            byObject: (content: import("@omnia/fx/ux").FlowContent) => void;
+                            byString: (content: string) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                set: {
+                    subscribe(fn: (result: {
+                        container: (el: HTMLDivElement) => void;
+                        focus: () => void;
+                        placeHolderVisibility: () => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                toolbarAction: {
+                    subscribe(fn: (result: {
+                        add: (action: import("@omnia/fx-models").FlowEditorActionRegistration | import("@omnia/fx-models").FlowEditorActionRegistration[]) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                formatting: {
+                    subscribe(fn: (result: {
+                        wrapLine: (element: HTMLElement) => void;
+                        add: (element: HTMLElement) => void;
+                        addWithText: (element: HTMLElement, text: any) => void;
+                        toggle: (element: HTMLElement) => void;
+                        remove: (dataType: string) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                element: {
+                    subscribe(fn: (result: {
+                        createForComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                        createText: () => HTMLParagraphElement;
+                        create: (tagName: string, dataType: string) => HTMLElement;
+                        createTextNode: (data: any) => Text;
+                        add: (element: HTMLElement) => void;
+                        insert: (element: HTMLElement, ref: HTMLElement, preInsert: boolean) => void;
+                        delete: (element: HTMLElement) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                commands: {
+                    subscribe(fn: (result: {
+                        exec: (command: string, data: object | string) => void;
+                        builtIn: {
+                            content: {
+                                convert: (element: HTMLElement) => void;
+                            };
+                            ensure: {
+                                lastElement: {
+                                    isText: () => void;
+                                };
+                                unique: {
+                                    ids: (element: HTMLElement) => void;
+                                };
+                            };
+                            selection: {
+                                get: {
+                                    byPluginType: (pluginType: string) => FlowNodeReference[];
+                                };
+                                ensure: {
+                                    storedRange: () => void;
+                                };
+                            };
+                            cursor: {
+                                isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                            };
+                            actions: {
+                                captureSelection: () => void;
+                            };
+                            formatting: {
+                                add: (element: HTMLElement) => void;
+                                addWithTxt: (element: HTMLElement, text?: string) => void;
+                                wrapLine: (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: string) => HTMLElement;
+                                createText: () => HTMLParagraphElement;
+                                createTextNode: (data: any) => Text;
+                                createComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                                insert: {
+                                    text: (element: Node, text: string, offset: any) => void;
+                                };
+                                ids: {
+                                    unique: (element: HTMLElement) => void;
+                                };
+                            };
+                            helpers: {
+                                editor: {
+                                    ensure: {
+                                        uniqueIds: (element: HTMLElement) => 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<FlowNodeReference>, dataType: string) => Array<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;
+                                        topContainerForComponent: (element: HTMLElement) => HTMLElement;
+                                        nodeSelectionForRange: (range: Range) => import("@omnia/fx/ux").NodeSelection;
+                                        htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
+                                    };
+                                    remove: {
+                                        nodes: (nodes2Remove: Array<FlowNodeReference>, editor: HTMLElement) => void;
+                                    };
+                                    strip: {
+                                        after: (element: HTMLElement, splitter: string) => void;
+                                        before: (element: HTMLElement, splitter: string) => void;
+                                    };
+                                    surround: {
+                                        selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                    };
+                                };
+                            };
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+            };
+            onFailure: {
+                confirm: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                plugin: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                content: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                set: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                toolbarAction: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                formatting: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                element: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                commands: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+            };
+        } & {
+            confirm: () => {
+                delete: {
+                    container: (element: HTMLElement) => void;
+                };
+            };
+            selection: () => {
+                set: (elements: Node | Array<Node>) => void;
+                capture: () => void;
+                store: () => void;
+                revertToStored: () => void;
+                ensure: () => void;
+            };
+            plugin: () => {
+                register: {
+                    plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                    plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                    context: (ctx: import("@omnia/fx/ux").FlowEditorPluginContext) => void;
+                };
+            };
+            content: () => {
+                sync: () => void;
+                set: {
+                    byObject: (content: import("@omnia/fx/ux").FlowContent) => void;
+                    byString: (content: string) => void;
+                };
+            };
+            set: () => {
+                container: (el: HTMLDivElement) => void;
+                focus: () => void;
+                placeHolderVisibility: () => void;
+            };
+            toolbarAction: () => {
+                add: (action: import("@omnia/fx-models").FlowEditorActionRegistration | import("@omnia/fx-models").FlowEditorActionRegistration[]) => void;
+            };
+            formatting: () => {
+                wrapLine: (element: HTMLElement) => void;
+                add: (element: HTMLElement) => void;
+                addWithText: (element: HTMLElement, text: any) => void;
+                toggle: (element: HTMLElement) => void;
+                remove: (dataType: string) => void;
+            };
+            element: () => {
+                createForComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                createText: () => HTMLParagraphElement;
+                create: (tagName: string, dataType: string) => HTMLElement;
+                createTextNode: (data: any) => Text;
+                add: (element: HTMLElement) => void;
+                insert: (element: HTMLElement, ref: HTMLElement, preInsert: boolean) => void;
+                delete: (element: HTMLElement) => void;
+            };
+            commands: () => {
+                exec: (command: string, data: object | string) => void;
+                builtIn: {
+                    content: {
+                        convert: (element: HTMLElement) => void;
+                    };
+                    ensure: {
+                        lastElement: {
+                            isText: () => void;
+                        };
+                        unique: {
+                            ids: (element: HTMLElement) => void;
+                        };
+                    };
+                    selection: {
+                        get: {
+                            byPluginType: (pluginType: string) => FlowNodeReference[];
+                        };
+                        ensure: {
+                            storedRange: () => void;
+                        };
+                    };
+                    cursor: {
+                        isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                        isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                    };
+                    actions: {
+                        captureSelection: () => void;
+                    };
+                    formatting: {
+                        add: (element: HTMLElement) => void;
+                        addWithTxt: (element: HTMLElement, text?: string) => void;
+                        wrapLine: (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: string) => HTMLElement;
+                        createText: () => HTMLParagraphElement;
+                        createTextNode: (data: any) => Text;
+                        createComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                        insert: {
+                            text: (element: Node, text: string, offset: any) => void;
+                        };
+                        ids: {
+                            unique: (element: HTMLElement) => void;
+                        };
+                    };
+                    helpers: {
+                        editor: {
+                            ensure: {
+                                uniqueIds: (element: HTMLElement) => 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<FlowNodeReference>, dataType: string) => Array<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;
+                                topContainerForComponent: (element: HTMLElement) => HTMLElement;
+                                nodeSelectionForRange: (range: Range) => import("@omnia/fx/ux").NodeSelection;
+                                htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
+                            };
+                            remove: {
+                                nodes: (nodes2Remove: Array<FlowNodeReference>, editor: HTMLElement) => void;
+                            };
+                            strip: {
+                                after: (element: HTMLElement, splitter: string) => void;
+                                before: (element: HTMLElement, splitter: string) => void;
+                            };
+                            surround: {
+                                selectionWithElement: (element: HTMLElement, range: Range) => void;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        get: {
+            plugins: import("@omnia/fx/ux").FlowEditorPlugin[];
+            content: {
+                isEmpty: () => boolean;
+                asObject: () => import("@omnia/fx/ux").FlowContent;
+                asString: () => string;
+            };
+            selection: {
+                has: {
+                    type: (pluginType: string) => boolean;
+                };
+                get: {
+                    byType: (pluginType: string) => FlowNodeReference[];
+                    all: () => import("@omnia/fx/ux").NodeSelection;
+                };
+            };
+            element: {
+                byId: (id: string) => HTMLElement;
+                byRef: (ref: HTMLElement) => HTMLElement;
+            };
+        };
+    } & {
+        dispose?: () => void;
+    };
+}>) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/flow/editor/plugins/typography/TypographyPlugin.d.ts

@@ -1,3 +1,4 @@
-export declare const typographyPlugin: () => import("../../models").FlowEditorPlugin & {
+import { FlowEditorContentPlugin } from "@omnia/fx/ux";
+export declare const typographyPlugin: () => FlowEditorContentPlugin & {
     dispose?: () => void;
 };

package/internal-do-not-import-from-here/ux/flow/editor/plugins/velcron/VelcronPlugin.d.ts

@@ -1,9 +1,4 @@
-import { DynamicState, VelcronAppDefinition, VelcronDefinitionRegistrationWithoutApp } from "@omnia/fx-models";
-export type VelcronHtmlDivElement = HTMLDivElement & {
-    velcron: VelcronAppDefinition;
-    velcronRegistration: VelcronDefinitionRegistrationWithoutApp;
-    state: DynamicState;
-};
-export declare const velcronRendererPlugin: () => import("../../models").FlowEditorPlugin & {
+import { FlowEditorContentPlugin } from "@omnia/fx/ux";
+export declare const velcronRendererPlugin: () => FlowEditorContentPlugin & {
     dispose?: () => void;
 };

package/internal-do-not-import-from-here/ux/flow/editor/stores/FlowEditorStore.d.ts

@@ -1,5 +1,5 @@
 import { FlowEditorActionRegistration, FlowEditorPluginSettings, guid, Future } from "@omnia/fx-models";
-import { FlowEditorPlugin, FlowEditorPluginContext, NodeSelection } from "../models";
+import { FlowEditorPlugin, FlowEditorPluginContext, NodeSelection } from "@omnia/fx/ux";
 import { FlowContent } from "@omnia/fx/ux";
 export declare const useFlowEditorStore: () => {
     state: {
@@ -7,7 +7,6 @@ export declare const useFlowEditorStore: () => {
         plugins: FlowEditorPlugin[];
         pluginsLoadedPromise: Future<void>;
         hideToolbar: boolean;
-        maxNodeId: number;
         toolbarActions: FlowEditorActionRegistration[];
         editor: HTMLDivElement;
         nodeSelection: NodeSelection;
@@ -22,13 +21,15 @@ export declare const useFlowEditorStore: () => {
             categoryFilters: guid[];
             rendererTypeFilters: guid[];
         };
+        settings: {
+            gridWidth: number;
+        };
     };
     events: {
         onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowContent>;
         onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorPlugin[]>;
         onMutatedPluginsLoadedPromise: import("@omnia/fx").MessageBusExposeOnlySubscription<Future<void>>;
         onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
-        onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
         onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
         onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
         onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<NodeSelection>;
@@ -43,6 +44,9 @@ export declare const useFlowEditorStore: () => {
             categoryFilters: guid[];
             rendererTypeFilters: guid[];
         }>;
+        onMutatedSettings: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            gridWidth: number;
+        }>;
     } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
     actions: {
         onDispatching: {
@@ -84,6 +88,7 @@ export declare const useFlowEditorStore: () => {
             };
             selection: {
                 subscribe(fn: (result: {
+                    set: (elements: Node | Array<Node>) => void;
                     capture: () => void;
                     store: () => void;
                     revertToStored: () => void;
@@ -124,6 +129,7 @@ export declare const useFlowEditorStore: () => {
                 subscribe(fn: (result: {
                     wrapLine: (element: HTMLElement) => void;
                     add: (element: HTMLElement) => void;
+                    addWithText: (element: HTMLElement, text: any) => void;
                     toggle: (element: HTMLElement) => void;
                     remove: (dataType: string) => void;
                 }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -156,7 +162,7 @@ export declare const useFlowEditorStore: () => {
                         };
                         selection: {
                             get: {
-                                byPluginType: (pluginType: string) => import("../models").FlowNodeReference[];
+                                byPluginType: (pluginType: string) => import("@omnia/fx/ux").FlowNodeReference[];
                             };
                             ensure: {
                                 storedRange: () => void;
@@ -171,6 +177,7 @@ export declare const useFlowEditorStore: () => {
                         };
                         formatting: {
                             add: (element: HTMLElement) => void;
+                            addWithTxt: (element: HTMLElement, text?: string) => void;
                             wrapLine: (element: HTMLElement) => void;
                             remove: (dataType: string | HTMLElement) => void;
                             has: (dataType: string | HTMLElement) => boolean;
@@ -192,9 +199,7 @@ export declare const useFlowEditorStore: () => {
                         helpers: {
                             editor: {
                                 ensure: {
-                                    uniqueIds: (element: HTMLElement, state: {
-                                        maxNodeId: number;
-                                    }) => HTMLElement;
+                                    uniqueIds: (element: HTMLElement) => HTMLElement;
                                     selectionIsInEditor: (range: Range) => void;
                                 };
                                 cursor: {
@@ -207,7 +212,7 @@ export declare const useFlowEditorStore: () => {
                             };
                             editorNode: {
                                 get: {
-                                    nodesInArrayByPluginType: (nodes: Array<import("../models").FlowNodeReference>, dataType: string) => Array<import("../models").FlowNodeReference>;
+                                    nodesInArrayByPluginType: (nodes: Array<import("@omnia/fx/ux").FlowNodeReference>, dataType: string) => Array<import("@omnia/fx/ux").FlowNodeReference>;
                                 };
                             };
                             htmlNode: {
@@ -222,10 +227,10 @@ export declare const useFlowEditorStore: () => {
                                     topContainerForContent: (element: HTMLElement) => HTMLElement;
                                     topContainerForComponent: (element: HTMLElement) => HTMLElement;
                                     nodeSelectionForRange: (range: Range) => NodeSelection;
-                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                    htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
                                 };
                                 remove: {
-                                    nodes: (nodes2Remove: Array<import("../models").FlowNodeReference>, editor: HTMLElement) => void;
+                                    nodes: (nodes2Remove: Array<import("@omnia/fx/ux").FlowNodeReference>, editor: HTMLElement) => void;
                                 };
                                 strip: {
                                     after: (element: HTMLElement, splitter: string) => void;
@@ -276,6 +281,7 @@ export declare const useFlowEditorStore: () => {
             };
         };
         selection: () => {
+            set: (elements: Node | Array<Node>) => void;
             capture: () => void;
             store: () => void;
             revertToStored: () => void;
@@ -306,6 +312,7 @@ export declare const useFlowEditorStore: () => {
         formatting: () => {
             wrapLine: (element: HTMLElement) => void;
             add: (element: HTMLElement) => void;
+            addWithText: (element: HTMLElement, text: any) => void;
             toggle: (element: HTMLElement) => void;
             remove: (dataType: string) => void;
         };
@@ -334,7 +341,7 @@ export declare const useFlowEditorStore: () => {
                 };
                 selection: {
                     get: {
-                        byPluginType: (pluginType: string) => import("../models").FlowNodeReference[];
+                        byPluginType: (pluginType: string) => import("@omnia/fx/ux").FlowNodeReference[];
                     };
                     ensure: {
                         storedRange: () => void;
@@ -349,6 +356,7 @@ export declare const useFlowEditorStore: () => {
                 };
                 formatting: {
                     add: (element: HTMLElement) => void;
+                    addWithTxt: (element: HTMLElement, text?: string) => void;
                     wrapLine: (element: HTMLElement) => void;
                     remove: (dataType: string | HTMLElement) => void;
                     has: (dataType: string | HTMLElement) => boolean;
@@ -370,9 +378,7 @@ export declare const useFlowEditorStore: () => {
                 helpers: {
                     editor: {
                         ensure: {
-                            uniqueIds: (element: HTMLElement, state: {
-                                maxNodeId: number;
-                            }) => HTMLElement;
+                            uniqueIds: (element: HTMLElement) => HTMLElement;
                             selectionIsInEditor: (range: Range) => void;
                         };
                         cursor: {
@@ -385,7 +391,7 @@ export declare const useFlowEditorStore: () => {
                     };
                     editorNode: {
                         get: {
-                            nodesInArrayByPluginType: (nodes: Array<import("../models").FlowNodeReference>, dataType: string) => Array<import("../models").FlowNodeReference>;
+                            nodesInArrayByPluginType: (nodes: Array<import("@omnia/fx/ux").FlowNodeReference>, dataType: string) => Array<import("@omnia/fx/ux").FlowNodeReference>;
                         };
                     };
                     htmlNode: {
@@ -400,10 +406,10 @@ export declare const useFlowEditorStore: () => {
                             topContainerForContent: (element: HTMLElement) => HTMLElement;
                             topContainerForComponent: (element: HTMLElement) => HTMLElement;
                             nodeSelectionForRange: (range: Range) => NodeSelection;
-                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                            htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
                         };
                         remove: {
-                            nodes: (nodes2Remove: Array<import("../models").FlowNodeReference>, editor: HTMLElement) => void;
+                            nodes: (nodes2Remove: Array<import("@omnia/fx/ux").FlowNodeReference>, editor: HTMLElement) => void;
                         };
                         strip: {
                             after: (element: HTMLElement, splitter: string) => void;
@@ -429,12 +435,13 @@ export declare const useFlowEditorStore: () => {
                 type: (pluginType: string) => boolean;
             };
             get: {
-                byType: (pluginType: string) => import("../models").FlowNodeReference[];
+                byType: (pluginType: string) => import("@omnia/fx/ux").FlowNodeReference[];
                 all: () => NodeSelection;
             };
         };
         element: {
-            byId: (id: number) => HTMLElement;
+            byId: (id: string) => HTMLElement;
+            byRef: (ref: HTMLElement) => HTMLElement;
         };
     };
 } & {