@omnia/fx 8.0.526-dev → 8.0.528-dev

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/DefineDefaultView.d.ts

@@ -2,13 +2,23 @@ import { EditorChromeConfiguration, guid } from "@omnia/fx/models";
 export declare const defineDefaultEditorView: (param1: EditorChromeConfiguration, param2: {
     state: {
         id: guid;
-        settings: import("../..").VersionedLayoutEditorSettings<import("@omnia/fx-models").VersionedLayoutDefinition>;
+        settings: import("@omnia/fx/ux").VersionedLayoutEditorSettings<import("@omnia/fx-models").VersionedLayoutDefinition>;
+        versioning: {
+            originalVersion: import("@omnia/fx-models").IVersionedData<import("@omnia/fx-models").VersionedLayoutDefinition>;
+            selectedVersion: import("@omnia/fx-models").IVersionInformation;
+        };
+        permissions: {
+            currentIdentity: string;
+            canEdit: boolean;
+            canDelete: boolean;
+        };
         active: {
+            parentVersionedLayout: import("@omnia/fx-models").VersionedLayout;
             versionedLayout: import("@omnia/fx-models").VersionedLayout;
             layout: import("@omnia/fx-models").Layout;
             versionedData: import("@omnia/fx-models").IVersionedData<import("@omnia/fx-models").VersionedLayoutDefinition>;
         };
-        views: import("../../stores/VersionedLayoutEditorStoreV2").EditorViews;
+        views: import("@omnia/fx/ux").EditorViews;
         chrome: {
             title: string;
             subTitle: string;
@@ -17,13 +27,23 @@ export declare const defineDefaultEditorView: (param1: EditorChromeConfiguration
     };
     events: import("../../../mobile").StoreEvents<{
         id: guid;
-        settings: import("../..").VersionedLayoutEditorSettings<import("@omnia/fx-models").VersionedLayoutDefinition>;
+        settings: import("@omnia/fx/ux").VersionedLayoutEditorSettings<import("@omnia/fx-models").VersionedLayoutDefinition>;
+        versioning: {
+            originalVersion: import("@omnia/fx-models").IVersionedData<import("@omnia/fx-models").VersionedLayoutDefinition>;
+            selectedVersion: import("@omnia/fx-models").IVersionInformation;
+        };
+        permissions: {
+            currentIdentity: string;
+            canEdit: boolean;
+            canDelete: boolean;
+        };
         active: {
+            parentVersionedLayout: import("@omnia/fx-models").VersionedLayout;
             versionedLayout: import("@omnia/fx-models").VersionedLayout;
             layout: import("@omnia/fx-models").Layout;
             versionedData: import("@omnia/fx-models").IVersionedData<import("@omnia/fx-models").VersionedLayoutDefinition>;
         };
-        views: import("../../stores/VersionedLayoutEditorStoreV2").EditorViews;
+        views: import("@omnia/fx/ux").EditorViews;
         chrome: {
             title: string;
             subTitle: string;
@@ -31,8 +51,29 @@ export declare const defineDefaultEditorView: (param1: EditorChromeConfiguration
         panels: {};
     }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
     actions: import("../../../mobile").StoreReturnDefineAction<{
+        canvas: () => {
+            configuration: {
+                extend: (configuration: EditorChromeConfiguration) => void;
+            };
+        };
+        versioning: () => {
+            init: () => void;
+            select: (version: import("@omnia/fx-models").IVersionInformation) => Promise<void>;
+            reset: () => void;
+        };
+        panel: () => {
+            show: (panel: import("@omnia/fx-models").EditorChromePanel) => void;
+        };
         layout: () => {
+            takeControlAndCheckOut: () => Promise<void>;
+            delete: () => Promise<void>;
+            publish: () => Promise<void>;
+            saveAsDraft: () => Promise<void>;
+            discardChanges: () => Promise<void>;
+            checkOut: () => Promise<void>;
+            revert: (version: import("@omnia/fx-models").IVersionReference) => Promise<void>;
             set: (layout: import("@omnia/fx-models").VersionedLayout) => Promise<void>;
+            setVersion: (versionedData: import("@omnia/fx-models").IVersionedData<import("@omnia/fx-models").VersionedLayoutDefinition>, mergeWithoutCache: boolean) => Promise<import("@omnia/fx-models").Layout>;
             setDefault: () => Promise<void>;
         };
         editor: () => {
@@ -41,13 +82,278 @@ export declare const defineDefaultEditorView: (param1: EditorChromeConfiguration
                 toReadMode: () => void;
             };
         };
-        init: (editorChromeStore: ReturnType<typeof import("../../..").useEditorChromeStore>, views: import("../../stores/VersionedLayoutEditorStoreV2").EditorViews) => void;
+        init: (editorChromeStore: ReturnType<typeof import("@omnia/fx/ux").useEditorChromeStore>, views: import("@omnia/fx/ux").EditorViews) => void;
     }>;
     get: {
         editorMode: () => import("@omnia/fx-models").LayoutCanvasEditorMode;
         canvasMode: () => import("@omnia/fx-models").LayoutCanvasMode;
+        chromeStore: () => {
+            state: {
+                id: guid;
+                finishedLoading: boolean;
+                compactMode: boolean;
+                navigation: {
+                    configuration: import("@omnia/fx-models").EditorChromeNavigationConfiguration;
+                    enabled: boolean;
+                    show: boolean;
+                };
+                drawers: {
+                    right: {
+                        panel: {
+                            settings: import("@omnia/fx-models").EditorChromePanel;
+                            show: boolean;
+                            actions: import("@omnia/fx-models").ChromeActionItem[];
+                            footerToolbar: {
+                                actionsLeft: import("@omnia/fx-models").ChromeActionItem[];
+                                actionsCenter: import("@omnia/fx-models").ChromeActionItem[];
+                                actionsRight: import("@omnia/fx-models").ChromeActionItem[];
+                                ExtendActionsRight: import("@omnia/fx-models").ChromeActionItem[];
+                            };
+                        };
+                        canvas: {
+                            enabled: boolean;
+                            show: boolean;
+                            customScroll: boolean;
+                            header: {
+                                enabled: boolean;
+                                icon: import("@omnia/fx-models").IIcon;
+                                title: string;
+                            };
+                        };
+                    };
+                };
+                views: {
+                    active: import("@omnia/fx/ux").EditorChromeViewRegistration;
+                    registrations: import("@omnia/fx/ux").EditorChromeViewRegistration[];
+                    history: {
+                        items: {
+                            id: guid;
+                            timestamp: number;
+                        }[];
+                        currentIndex: number;
+                        maxSize: number;
+                    };
+                };
+                canvasSettings: {
+                    scroll: {
+                        store: {
+                            state: {
+                                elementRef: HTMLElement;
+                                elementId: string;
+                                disableScrolling: boolean;
+                                height: string;
+                                width: string;
+                                scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                                coordinates: {
+                                    readonly left: number;
+                                    readonly right: number;
+                                    readonly bottom: number;
+                                    readonly top: number;
+                                };
+                            };
+                            events: import("../../../mobile").StoreEvents<{
+                                elementRef: HTMLElement;
+                                elementId: string;
+                                disableScrolling: boolean;
+                                height: string;
+                                width: string;
+                                scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                                coordinates: {
+                                    readonly left: number;
+                                    readonly right: number;
+                                    readonly bottom: number;
+                                    readonly top: number;
+                                };
+                            }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                            actions: import("../../../mobile").StoreReturnDefineAction<{
+                                scroll: () => void;
+                                setDisableScrolling: (disable: boolean) => void;
+                                calculateDynamicHeight: () => void;
+                                setHeight: (height: string) => void;
+                                setWidth: (width: string) => void;
+                                setScrolling: (scrolling: import("@omnia/fx-models").OScrollTypesCombination) => void;
+                                calculateScrollHeight: (referenceElementIds: string[]) => void;
+                                isElementNameStillInView: (elementName: string) => boolean;
+                                isElementIdStillInView: (elementId: string) => boolean;
+                                scrollToStart: () => void;
+                                scrollToElementId: (elementId: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                                scrollToElementName: (elementName: string, anchor?: import("@omnia/fx/ux").AnchorPosition) => void;
+                                scrollToElement: (element: HTMLElement, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void) => void;
+                                scrollToSelector: (selector: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                            }>;
+                            get: {
+                                readonly coordinates: {
+                                    readonly left: number;
+                                    readonly right: number;
+                                    readonly bottom: number;
+                                    readonly top: number;
+                                };
+                                readonly scrollPosition: number;
+                            };
+                        } & {
+                            dispose?: () => void;
+                        };
+                    };
+                    zoom: {
+                        enabled: boolean;
+                        level: number;
+                    };
+                    displaySize: {
+                        enabled: boolean;
+                        value: "l" | "s" | "m";
+                        store: {
+                            state: {
+                                width: string;
+                                zoomLevel: number;
+                            };
+                            events: import("../../../mobile").StoreEvents<{
+                                width: string;
+                                zoomLevel: number;
+                            }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                            actions: import("../../../mobile").StoreReturnDefineAction<{
+                                setWidth: (width: string) => void;
+                                resetWidth: () => void;
+                                setBreakPoint: (breakPoint: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+                                resetZoomLevel: () => void;
+                                setZoomLevel: (zoomLevel: number) => void;
+                            }>;
+                            get: {};
+                        } & {
+                            dispose?: () => void;
+                        };
+                    };
+                };
+                notificationMessage: {
+                    key: guid;
+                    message: string;
+                    show: boolean;
+                    timeout: number;
+                    customRenderer: string;
+                };
+                operations: {
+                    id: guid;
+                    loading: boolean;
+                }[];
+            };
+            actions: import("../../../mobile").StoreReturnDefineAction<{
+                canvas: () => {
+                    syncDisplaySettings: () => void;
+                    setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+                    zoomIn: (step?: number) => void;
+                    zoomOut: (step?: number) => void;
+                    setZoom: (level: number) => void;
+                    resetZoom: () => void;
+                };
+                editor: () => {
+                    resetForNewActiveConfiguration: () => void;
+                };
+                views: () => {
+                    register: (editorView: import("@omnia/fx-models").EditorChromeView | import("@omnia/fx-models").EditorChromeView[]) => void;
+                    active: {
+                        set: (view: import("@omnia/fx-models").EditorChromeView, addToHistory?: boolean) => void;
+                        clear: () => void;
+                        configuration: {
+                            set: (configuration: EditorChromeConfiguration) => void;
+                        };
+                    };
+                    remove: (view: import("@omnia/fx-models").EditorChromeView) => void;
+                    history: {
+                        goBack: () => boolean;
+                        goForward: () => boolean;
+                        addToHistory: (view: import("@omnia/fx-models").EditorChromeView) => void;
+                        clear: () => void;
+                    };
+                };
+                showNotification: (message: import("@omnia/fx-models").NotificationMessage) => void;
+                operations: () => {
+                    create: (showLoading?: boolean) => import("@omnia/fx-models").Future<null>;
+                    setLoading: () => import("@omnia/fx-models").Future<null>;
+                    register: (showLoading?: boolean) => guid;
+                    unregister: (operationId: guid) => boolean;
+                    clear: () => void;
+                    waitForCompletion: () => Promise<void>;
+                };
+                navigation: () => {
+                    register: (navigationItem: import("@omnia/fx-models").EditorChromeNavigationConfiguration) => void;
+                    show: (value: boolean) => void;
+                    toggle: () => void;
+                };
+                drawers: () => {
+                    right: {
+                        panel: {
+                            show: (panel: import("@omnia/fx-models").EditorChromePanel) => void;
+                            footerToolbar: {
+                                add: {
+                                    action: (action: import("@omnia/fx-models").ChromeActionItem | import("@omnia/fx-models").ChromeActionItem[], position?: "left" | "center" | "right" | "extended-right") => void;
+                                };
+                            };
+                            close: () => void;
+                        };
+                        canvas: {
+                            configure: (header: {
+                                icon?: import("@omnia/fx-models").IIcon;
+                                title?: string;
+                                enabled?: boolean;
+                            }, customScroll?: boolean) => void;
+                            toolbar: {
+                                enable: (value: boolean) => void;
+                            };
+                            syncButtons: (currentId: guid) => void;
+                            toggle: () => void;
+                            show: (value: boolean) => void;
+                        };
+                    };
+                };
+                init: () => void;
+                dispose: () => void;
+            }>;
+            get: {
+                views: {
+                    active: () => import("@omnia/fx-models").EditorChromeView;
+                    all: () => import("@omnia/fx-models").EditorChromeView[];
+                    byId: (id: guid) => import("@omnia/fx-models").EditorChromeView;
+                };
+                operations: {
+                    all: () => guid[];
+                    has: (operationId: guid) => boolean;
+                    count: () => number;
+                };
+                history: () => {
+                    view: import("@omnia/fx-models").EditorChromeView;
+                    id: guid;
+                    timestamp: number;
+                }[];
+            };
+            rules: {
+                showLoading: () => boolean;
+                history: {
+                    canGoBack: () => boolean;
+                    canGoForward: () => boolean;
+                };
+                views: {
+                    hasActive: () => boolean;
+                };
+            };
+        } & {
+            dispose?: () => void;
+        };
+    };
+    rules: {
+        versioning: {
+            hasReverted: () => boolean;
+        };
+        isCheckedOutToMe: () => boolean;
+        isCheckedOut: () => boolean;
+        isDefaultLayout: () => boolean;
+        actions: {
+            hide: {
+                takeControl: () => boolean;
+                whenNotCheckedOut: () => boolean;
+                whenCheckedOut: () => boolean;
+                whenNotDeletable: () => boolean;
+            };
+        };
     };
-    rules: {};
 } & {
     dispose?: () => void;
 }) => {

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/actions/CanvasActions.d.ts

@@ -1,5 +1,5 @@
 import { ChromeActionItem } from "@omnia/fx-models";
-import { useVersionedLayoutEditorStore } from "../../../stores/VersionedLayoutEditorStoreV2";
+import { useVersionedLayoutEditorStore } from "@omnia/fx/ux";
 export declare function useCanvasActions(editorStore: ReturnType<typeof useVersionedLayoutEditorStore>): {
     preview: ChromeActionItem;
     design: ChromeActionItem;

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/actions/CheckedOutActions.d.ts

@@ -1,5 +1,5 @@
 import { ChromeActionItem } from "@omnia/fx-models";
-import { useVersionedLayoutEditorStore } from "../../../stores/VersionedLayoutEditorStoreV2";
+import { useVersionedLayoutEditorStore } from "@omnia/fx/ux";
 export declare function useCheckedOutActions(editorStore: ReturnType<typeof useVersionedLayoutEditorStore>): {
     discardChanges: ChromeActionItem;
     saveAsDraft: ChromeActionItem;

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/actions/NotCheckedOutActions.d.ts

@@ -1,5 +1,5 @@
 import { ChromeActionItem } from "@omnia/fx-models";
-import { useVersionedLayoutEditorStore } from "../../../stores/VersionedLayoutEditorStoreV2";
+import { useVersionedLayoutEditorStore } from "@omnia/fx/ux";
 export declare function useNotCheckedOutActions(editorStore: ReturnType<typeof useVersionedLayoutEditorStore>): {
     takeControl: ChromeActionItem;
     edit: ChromeActionItem;

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/actions/PanelActions.d.ts

@@ -1,6 +1,5 @@
 import { ChromeActionItem } from "@omnia/fx-models";
-import { useVersionedLayoutEditorStore } from "../../../stores/VersionedLayoutEditorStoreV2";
+import { useVersionedLayoutEditorStore } from "@omnia/fx/ux";
 export declare function usePanelActions(editorStore: ReturnType<typeof useVersionedLayoutEditorStore>): {
     versionHistory: ChromeActionItem;
-    statistics: ChromeActionItem;
 };

package/internal-do-not-import-from-here/ux/versionedlayout/renderer/v2/VersionedLayoutRenderer.d.ts

@@ -0,0 +1,14 @@
+import { VersionedLayoutId, guid, IVersionReference } from "@omnia/fx-models";
+import { DefineEmit, DefineProp } from "@omnia/fx/ux";
+import { type LayoutRendererCanvasApis } from "internal/fx/ux/layoutcanvas/renderer/LayoutRendererCanvasV2";
+import { ServiceContainerContext } from "@omnia/fx";
+type Props = DefineProp<"layoutBackgroundImageElementId", String> & DefineEmit<"ready", (apis: LayoutRendererCanvasApis) => void> & DefineProp<"height", string> & DefineProp<"appInstanceId", guid, true> & DefineProp<"versionedLayoutId", VersionedLayoutId> & DefineProp<"enableAlternateLayout", boolean> & DefineProp<"noScroll", boolean> & DefineProp<"layoutProvider", string> & DefineProp<"serviceContainerContext", ServiceContainerContext> & DefineProp<"publishedVersionReference", IVersionReference>;
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<Props> & {
+    onReady?: (apis: LayoutRendererCanvasApis) => any;
+} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+        $stable?: boolean;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "height" | "appInstanceId" | "serviceContainerContext" | "versionedLayoutId" | "layoutProvider" | "noScroll" | "publishedVersionReference" | "layoutBackgroundImageElementId" | "enableAlternateLayout" | "emit:ready"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;