@omnia/fx 8.0.288-dev → 8.0.290-dev

package/internal-do-not-import-from-here/ux/flow/editor/components/EditorSelector.d.ts

@@ -1,4 +1,4 @@
-import { FlowEditorPluginContext } from "../models";
+import { FlowEditorPluginContext } from "@omnia/fx/ux";
 import { guid } from "@omnia/fx-models";
 declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
     preSelector?: boolean;

package/internal-do-not-import-from-here/ux/flow/editor/models/index.d.ts

@@ -1,3 +1 @@
 export * from "./Constants";
-export * from "./EditorPlugin";
-export * from "./EditorModels";

package/internal-do-not-import-from-here/ux/flow/editor/parsers/HtmlParser.d.ts

@@ -1,5 +1,4 @@
-import { FlowEditorPlugin } from "../models";
-import { FlowContent } from "@omnia/fx/ux";
+import { FlowContent, FlowEditorPlugin } from "@omnia/fx/ux";
 export declare function useHtmlParser(state: {
     editor: HTMLDivElement;
     plugins: Array<FlowEditorPlugin>;

package/internal-do-not-import-from-here/ux/flow/editor/parsers/JSONParser.d.ts

@@ -1,5 +1,4 @@
-import { FlowContent } from "@omnia/fx/ux";
-import { FlowEditorPlugin, FlowEditorPluginContext } from "../models";
+import { FlowContent, FlowEditorPlugin, FlowEditorPluginContext } from "@omnia/fx/ux";
 export declare function useJSONParser(state: {
     editor: HTMLDivElement;
     plugins: Array<FlowEditorPlugin>;

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

@@ -1,8 +1,8 @@
 import { SetupFactoryContext } from "@omnia/fx";
-import { FlowEditorContentPlugin, FlowEditorPlugin } from "../models";
+import { FlowEditorContentPlugin, FlowEditorPlugin } from "@omnia/fx/ux";
 interface SetupEditorPluginContext extends SetupFactoryContext {
 }
-export declare function defineEditorPlugin<TArgs extends any[]>(setup: (ctx: SetupEditorPluginContext) => FlowEditorPlugin | FlowEditorContentPlugin): () => FlowEditorPlugin & {
+export declare function defineEditorPlugin<TPluginType extends FlowEditorPlugin | FlowEditorContentPlugin>(setup: (ctx: SetupEditorPluginContext) => TPluginType): () => TPluginType & {
     dispose?: () => void;
 };
 export {};

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

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

package/internal-do-not-import-from-here/ux/flow/editor/plugins/colorstyle/ColorButton.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/colorstyle/ColorConverter.d.ts

@@ -1,3 +1,3 @@
 import { ColorValue } from "@omnia/fx-models";
-import { ElementConverter, FlowEditorPluginContext } from "../../models";
+import { ElementConverter, FlowEditorPluginContext } from "@omnia/fx/ux";
 export declare function useColorConverter(elementCreator: (value: ColorValue, ctx: FlowEditorPluginContext) => HTMLElement): ElementConverter;

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

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

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

@@ -1,5 +1,4 @@
-import { FlowNode } from "@omnia/fx/ux";
-import { ElementConverter } from "../../models";
+import { ElementConverter, FlowNode } from "@omnia/fx/ux";
 export interface ElementNode extends FlowNode {
     name: "br";
 }

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

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

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

@@ -1,4 +1,19 @@
-import { FlowEditorPlugin } from "../../models";
-export declare const editorEventsPlugin: () => FlowEditorPlugin & {
+import { FlowEditorPluginContext } from "@omnia/fx/ux";
+export declare const editorEventsPlugin: () => {
+    name: string;
+    eventListeners: ({
+        event: ("click" | "focus" | "input")[];
+        action: (event: Event, context: FlowEditorPluginContext) => void;
+    } | {
+        event: "focusout"[];
+        action: (event: Event, context: FlowEditorPluginContext) => void;
+    } | {
+        event: "copy";
+        action: (event: ClipboardEvent, context: FlowEditorPluginContext) => void;
+    } | {
+        event: "paste"[];
+        action: (event: ClipboardEvent, context: FlowEditorPluginContext) => void;
+    })[];
+} & {
     dispose?: () => void;
 };

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

@@ -1,4 +1,10 @@
-import { FlowEditorPlugin } from "../../models";
-export declare const keyboardEventsPlugin: () => FlowEditorPlugin & {
+import { FlowEditorPluginContext } from "@omnia/fx/ux";
+export declare const keyboardEventsPlugin: () => {
+    name: string;
+    eventListeners: {
+        event: "keydown";
+        action: (event: KeyboardEvent, context: FlowEditorPluginContext) => void;
+    }[];
+} & {
     dispose?: () => void;
 };

package/internal-do-not-import-from-here/ux/flow/editor/plugins/eventhandlers/handlers/ClipboardHandler.d.ts

@@ -1,4 +1,4 @@
-import { FlowEditorPluginContext } from "../../../models";
+import { FlowEditorPluginContext } from "@omnia/fx/ux";
 import { useFlowEditorStore } from "../../../stores";
 export declare function useClipboardHandler(): {
     paste: (ev: ClipboardEvent, editorStore: ReturnType<typeof useFlowEditorStore>) => void;

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

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