@omnia/fx 8.0.479-dev → 8.0.481-dev

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/LayoutSectionSliderRenderer.d.ts

@@ -0,0 +1,31 @@
+import { Section, LayoutEngineRenderContext, SectionSettings } from "../../../../models";
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        renderContext: {
+            type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
+        };
+    }>>, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        renderContext: {
+            type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
+        };
+    }>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    renderContext: {
+        type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
+    };
+}>>, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        renderContext?: LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>;
+    }>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/LayoutSectionStepperRenderer.d.ts

@@ -0,0 +1,21 @@
+import { Section, StepperSectionSettings } from "../../../../models";
+export interface LayoutSectionStepperRendererProps {
+    section: Section;
+    layoutId: string;
+    useScrollMargingFix: boolean;
+    themeTargetId?: string;
+}
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    section?: Section<StepperSectionSettings>;
+} & {
+    layoutId?: string;
+} & {
+    useScrollMargingFix?: boolean;
+} & {
+    themeTargetId?: string;
+}> & {} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "section" | "themeTargetId" | "layoutId" | "useScrollMargingFix"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/LayoutSectionTabRenderer.css.d.ts

@@ -0,0 +1,7 @@
+import { AccordionedSectionSettings, Spacing, TabbedSectionSettings } from "@omnia/fx-models";
+import { useColorSchemaStore } from "@omnia/fx/ux";
+export declare const LayoutSectionTabRendererStyles: {
+    tabsContentWrapper: (editMode: boolean) => string;
+    tabsWrapper: (settings: TabbedSectionSettings) => string;
+    accordionWrapper: (settings: AccordionedSectionSettings, spacing: Spacing, colors: ReturnType<typeof useColorSchemaStore>) => string;
+};

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/LayoutSectionTabRenderer.d.ts

@@ -0,0 +1,9 @@
+import { Section, LayoutEngineRenderContext, SectionSettings } from "../../../../models";
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    renderContext?: LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>;
+}> & {} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "renderContext"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/LayoutStepRenderer.d.ts

@@ -0,0 +1,81 @@
+import { SectionSettings, SectionItem, SteppedSectionItemSettings } from "../../../../models";
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        useScrollMargingFix: {
+            type: import("vue").PropType<boolean>;
+        };
+        layoutId: {
+            type: import("vue").PropType<string>;
+        };
+        settings: {
+            type: import("vue").PropType<SectionSettings>;
+        };
+        step: {
+            type: import("vue").PropType<SectionItem<SteppedSectionItemSettings>>;
+        };
+        designRender: {
+            type: import("vue").PropType<boolean>;
+        };
+        themeTargetId: {
+            type: import("vue").PropType<string>;
+        };
+    }>>, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        useScrollMargingFix: {
+            type: import("vue").PropType<boolean>;
+        };
+        layoutId: {
+            type: import("vue").PropType<string>;
+        };
+        settings: {
+            type: import("vue").PropType<SectionSettings>;
+        };
+        step: {
+            type: import("vue").PropType<SectionItem<SteppedSectionItemSettings>>;
+        };
+        designRender: {
+            type: import("vue").PropType<boolean>;
+        };
+        themeTargetId: {
+            type: import("vue").PropType<string>;
+        };
+    }>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    useScrollMargingFix: {
+        type: import("vue").PropType<boolean>;
+    };
+    layoutId: {
+        type: import("vue").PropType<string>;
+    };
+    settings: {
+        type: import("vue").PropType<SectionSettings>;
+    };
+    step: {
+        type: import("vue").PropType<SectionItem<SteppedSectionItemSettings>>;
+    };
+    designRender: {
+        type: import("vue").PropType<boolean>;
+    };
+    themeTargetId: {
+        type: import("vue").PropType<string>;
+    };
+}>>, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        settings?: SectionSettings;
+        themeTargetId?: string;
+        step?: SectionItem<SteppedSectionItemSettings>;
+        designRender?: boolean;
+        layoutId?: string;
+        useScrollMargingFix?: boolean;
+    }>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/layoutitemsrenderer/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ColumnResizer";
+export * from "./LayoutBlockRenderer";
+export * from "./LayoutSectionRenderer";

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/styles/LayerIndex.d.ts

@@ -0,0 +1,7 @@
+export declare const LayerIndex: {
+    blade: number;
+    contentNavigation: number;
+    itemselector: number;
+    actionToolbar: number;
+    informationIcon: number;
+};

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/styles/LayoutSectionContainerHelper.d.ts

@@ -0,0 +1,9 @@
+import { NestedCSSProperties } from "typestyle/lib/types";
+import { ColumnedSectionItemSettings, LayoutItem, SectionItem } from "../../../../models/Layout";
+export declare class LayoutSectionContainerHelper {
+    static getFirstBlockMediaQueryInfo(item: LayoutItem): Array<NestedCSSProperties>;
+    private static isAllBlocksHidden;
+    private static hideBlockInBreakpoint;
+    static getMediaQueryAllBlocksInSection(items: Array<LayoutItem>): Array<NestedCSSProperties>;
+    static isAllBlockHidden(column: SectionItem<ColumnedSectionItemSettings>): boolean;
+}

package/internal-do-not-import-from-here/ux/layoutcanvas/shared_old/styles/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LayoutSectionContainerHelper";
+export * from "./LayerIndex";

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/LayoutCanvasEditorStore.d.ts

@@ -0,0 +1,59 @@
+import { AddItemToLayoutPayLoad, Block, BlockRenderingModes, ClipboardLayoutItem, guid, Layout, LayoutCanvasMode, LayoutItem } from "@omnia/fx-models";
+import { useLayoutCanvasStore } from "..";
+import { useEditorChromeStore } from "../..";
+export declare const useLayoutCanvasEditorStore: () => {
+    state: {
+        editorMode: LayoutCanvasMode;
+        id: guid;
+        settings: {
+            showGrid: boolean;
+        };
+    };
+    actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+        block: () => {
+            ensureRemoveDeletedBlocks: (layout: Layout) => void;
+        };
+        layout: () => {
+            addItem: (itemreference: AddItemToLayoutPayLoad) => void;
+        };
+        toggleGrid: () => void;
+        setEditorMode: (mode: LayoutCanvasMode) => void;
+        init: (canvasStore: ReturnType<typeof useLayoutCanvasStore>, editorChromeStore: ReturnType<typeof useEditorChromeStore>) => void;
+        dispose: () => void;
+    }>;
+    get: {
+        layout: {
+            active: () => Layout;
+        };
+        block: {
+            renderMode: () => BlockRenderingModes;
+        };
+    };
+    rules: {
+        hideGridSettings: () => boolean;
+        isLayoutItemLocked: (item: LayoutItem) => boolean;
+        isTemplateEnabledLayout: () => boolean;
+        isAdvancedModeActivated: () => boolean;
+    };
+    hooks: {
+        blockRemoved: {
+            trigger: (block: Block) => void;
+            subscribe: (callback: (block: Block) => void) => () => void;
+        };
+        blockCopied: {
+            trigger: (originalBlock: Block, newBlock: Block) => void;
+            subscribe: (callback: (originalBlock: Block, newBlock: Block) => void) => () => void;
+        };
+        layoutItemMoved: {
+            trigger: (layoutItem: LayoutItem) => void;
+            subscribe: (callback: (layoutItem: LayoutItem) => void) => () => void;
+        };
+        layoutPasted: {
+            trigger: (layoutItem: ClipboardLayoutItem) => void;
+            subscribe: (callback: (layoutItem: ClipboardLayoutItem) => void) => () => void;
+        };
+    };
+    dispose: () => void;
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/LayoutCanvasStore.d.ts

@@ -1,10 +1,12 @@
+import { EditorLayoutItemFactory } from "..";
 import { MessageBusExposeOnlySubscription } from "../../..";
 import { ServiceContainerContext } from "../../../core";
-import { AddItemToLayoutPayLoad, Block, BlockRenderingModes, ClipboardLayoutItem, ColorSchemaTypes, DeleteItemFromLayoutPayLoad, DisplayBreakPoint, DisplayBreakPointSetting, IBlockInstance, ILayoutCanvasStore, ILayoutSectionRenderer, IMessageBusTopicPublishSubscriber, Layout, LayoutCanvasModes, LayoutDrawerState, LayoutDrawerTabs, LayoutEditorModes, LayoutInheritanceBehaviors, LayoutItem, LayoutItemActionState, LayoutItemRegistration, LoadedLayout, Section, SectionSettings, SectionTypes, SettingsPanelState, LegacyThemeDefinition, guid } from "../../../models";
+import { AddItemToLayoutPayLoad, Block, BlockRenderingModes, ClipboardLayoutItem, ColorSchemaTypes, DeleteItemFromLayoutPayLoad, DisplayBreakPoint, DisplayBreakPointSetting, IBlockInstance, ILayoutCanvasStore, ILayoutSectionRenderer, IMessageBusTopicPublishSubscriber, Layout, LayoutCanvasModes, LayoutDefinition, LayoutDrawerState, LayoutDrawerTabs, LayoutEditorModes, LayoutInheritanceBehaviors, LayoutItem, LayoutItemActionState, LayoutItemRegistration, LoadedLayout, Section, SectionSettings, SectionTypes, SettingsPanelState, LegacyThemeDefinition, guid } from "../../../models";
 import { Store, StoreState } from "../../../stores";
 import { useScrollContainerStore } from "../../oxide";
-import { EditorLayoutItemFactory } from "../factories";
-import { BlockSettingsProvider, LayoutDefinitionBuilder, LayoutEditorThemingManager } from "../shared";
+import { BlockSettingsProvider, LayoutDefinitionBuilder, LayoutEditorThemingManager } from "../shared_old";
+import { useLayoutCanvasStore } from "./LayoutCanvasStoreV2";
+import { ReactiveLayoutItemsSettingsStore } from "./ReactiveLayoutItemsSettingsStore";
 export interface IBlockInstanceExtends<TSettings = void> extends IBlockInstance<TSettings> {
     settings: TSettings;
     serviceContainerContext: ServiceContainerContext;
@@ -17,6 +19,130 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
     private serviceContainerContext;
     readonly ColorSchemaBlock = ColorSchemaTypes.secondary;
     readonly ColorSchemaSection = ColorSchemaTypes.primary;
+    newStore: {
+        state: {
+            layout: {
+                definition: LayoutDefinition;
+                ownerLayoutItemsOverride: LayoutItem[];
+                originalId: guid;
+            };
+            id: guid;
+            settings: {
+                authDisabled: boolean;
+                providers: {
+                    block: string;
+                    mediaContext: import("@omnia/fx-models").ILayoutMediaContext;
+                    fileContext: import("@omnia/fx-models").ILayoutFileContext;
+                };
+            };
+        };
+        actions: import("../../../stores").StoreReturnDefineAction<{
+            layout: () => {
+                set: (layout: Layout) => void;
+                addItem: (itemreference: AddItemToLayoutPayLoad) => void;
+            };
+            providers: () => {
+                set: {
+                    block: (blockProvider: string) => void;
+                    mediaContext: (mediaContext: import("@omnia/fx-models").ILayoutMediaContext) => void;
+                    fileContext: (fileContext: import("@omnia/fx-models").ILayoutFileContext) => void;
+                };
+            };
+            setLayout: (layout: Layout) => void;
+            init: () => {
+                readOnlyCanvas: (blockProvider: string, mediaContext: import("@omnia/fx-models").ILayoutMediaContext, fileContext: import("@omnia/fx-models").ILayoutFileContext) => void;
+                editableCanvas: (editorChromeStore: ReturnType<typeof import("../..").useEditorChromeStore>, blockProvider: string, mediaContext: import("@omnia/fx-models").ILayoutMediaContext, fileContext: import("@omnia/fx-models").ILayoutFileContext) => void;
+            };
+            dispose: () => void;
+        }>;
+        get: {
+            layout: {
+                loaded: () => LoadedLayout;
+            };
+            block: {
+                readonly settings: ReactiveLayoutItemsSettingsStore;
+                settingsProvider: () => import("..").BlockSettingsProvider;
+                renderMode: () => BlockRenderingModes;
+            };
+            providers: {
+                block: string;
+                mediaContext: import("@omnia/fx-models").ILayoutMediaContext;
+                fileContext: import("@omnia/fx-models").ILayoutFileContext;
+            };
+        };
+        rules: {
+            isEditMode: () => boolean;
+        };
+        hooks: {
+            blockInstanceCreated: {
+                trigger: (blockInstance: IBlockInstance) => void;
+                subscribe: (callback: (blockInstance: IBlockInstance) => void) => () => void;
+            };
+            layoutSectionRendererCreated: {
+                trigger: (layoutSectionRenderer: ILayoutSectionRenderer) => void;
+                subscribe: (callback: (layoutSectionRenderer: ILayoutSectionRenderer) => void) => () => void;
+            };
+        };
+        readonly editor: {
+            state: {
+                editorMode: import("@omnia/fx-models").LayoutCanvasMode;
+                id: guid;
+                settings: {
+                    showGrid: boolean;
+                };
+            };
+            actions: import("../../../stores").StoreReturnDefineAction<{
+                block: () => {
+                    ensureRemoveDeletedBlocks: (layout: Layout) => void;
+                };
+                layout: () => {
+                    addItem: (itemreference: AddItemToLayoutPayLoad) => void;
+                };
+                toggleGrid: () => void;
+                setEditorMode: (mode: import("@omnia/fx-models").LayoutCanvasMode) => void;
+                init: (canvasStore: ReturnType<typeof useLayoutCanvasStore>, editorChromeStore: ReturnType<typeof import("../..").useEditorChromeStore>) => void;
+                dispose: () => void;
+            }>;
+            get: {
+                layout: {
+                    active: () => Layout;
+                };
+                block: {
+                    renderMode: () => BlockRenderingModes;
+                };
+            };
+            rules: {
+                hideGridSettings: () => boolean;
+                isLayoutItemLocked: (item: LayoutItem) => boolean;
+                isTemplateEnabledLayout: () => boolean;
+                isAdvancedModeActivated: () => boolean;
+            };
+            hooks: {
+                blockRemoved: {
+                    trigger: (block: Block) => void;
+                    subscribe: (callback: (block: Block) => void) => () => void;
+                };
+                blockCopied: {
+                    trigger: (originalBlock: Block, newBlock: Block) => void;
+                    subscribe: (callback: (originalBlock: Block, newBlock: Block) => void) => () => void;
+                };
+                layoutItemMoved: {
+                    trigger: (layoutItem: LayoutItem) => void;
+                    subscribe: (callback: (layoutItem: LayoutItem) => void) => () => void;
+                };
+                layoutPasted: {
+                    trigger: (layoutItem: ClipboardLayoutItem) => void;
+                    subscribe: (callback: (layoutItem: ClipboardLayoutItem) => void) => () => void;
+                };
+            };
+            dispose: () => void;
+        } & {
+            dispose?: () => void;
+        };
+        dispose: () => void;
+    } & {
+        dispose?: () => void;
+    };
     scrollContainer: StoreState<{
         state: {
             elementRef: HTMLElement;

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/LayoutCanvasStoreV2.d.ts

@@ -0,0 +1,134 @@
+import { ServiceContainerContext } from "@omnia/fx";
+import { AddItemToLayoutPayLoad, Block, BlockRenderingModes, guid, IBlockInstance, ILayoutFileContext, ILayoutMediaContext, ILayoutSectionRenderer, Layout, LayoutDefinition, LayoutItem, LoadedLayout } from "@omnia/fx-models";
+import { ReactiveLayoutItemsSettingsStore } from "./ReactiveLayoutItemsSettingsStore";
+import { useEditorChromeStore } from "../../editorchrome";
+import { BlockSettingsProvider } from "..";
+export interface IBlockInstanceExtendsInternal<TSettings = void> extends IBlockInstance<TSettings> {
+    settings: TSettings;
+    serviceContainerContext: ServiceContainerContext;
+}
+export declare const useLayoutCanvasStore: () => {
+    state: {
+        layout: {
+            definition: LayoutDefinition;
+            ownerLayoutItemsOverride: LayoutItem[];
+            originalId: guid;
+        };
+        id: guid;
+        settings: {
+            authDisabled: boolean;
+            providers: {
+                block: string;
+                mediaContext: ILayoutMediaContext;
+                fileContext: ILayoutFileContext;
+            };
+        };
+    };
+    actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+        layout: () => {
+            set: (layout: Layout) => void;
+            addItem: (itemreference: AddItemToLayoutPayLoad) => void;
+        };
+        providers: () => {
+            set: {
+                block: (blockProvider: string) => void;
+                mediaContext: (mediaContext: ILayoutMediaContext) => void;
+                fileContext: (fileContext: ILayoutFileContext) => void;
+            };
+        };
+        /**Should be removed when new package is deployed */
+        setLayout: (layout: Layout) => void;
+        init: () => {
+            readOnlyCanvas: (blockProvider: string, mediaContext: ILayoutMediaContext, fileContext: ILayoutFileContext) => void;
+            editableCanvas: (editorChromeStore: ReturnType<typeof useEditorChromeStore>, blockProvider: string, mediaContext: ILayoutMediaContext, fileContext: ILayoutFileContext) => void;
+        };
+        dispose: () => void;
+    }>;
+    get: {
+        layout: {
+            loaded: () => LoadedLayout;
+        };
+        block: {
+            readonly settings: ReactiveLayoutItemsSettingsStore;
+            settingsProvider: () => BlockSettingsProvider;
+            renderMode: () => BlockRenderingModes;
+        };
+        providers: {
+            block: string;
+            mediaContext: ILayoutMediaContext;
+            fileContext: ILayoutFileContext;
+        };
+    };
+    rules: {
+        isEditMode: () => boolean;
+    };
+    hooks: {
+        blockInstanceCreated: {
+            trigger: (blockInstance: IBlockInstance) => void;
+            subscribe: (callback: (blockInstance: IBlockInstance) => void) => () => void;
+        };
+        layoutSectionRendererCreated: {
+            trigger: (layoutSectionRenderer: ILayoutSectionRenderer) => void;
+            subscribe: (callback: (layoutSectionRenderer: ILayoutSectionRenderer) => void) => () => void;
+        };
+    };
+    readonly editor: {
+        state: {
+            editorMode: import("@omnia/fx-models").LayoutCanvasMode;
+            id: guid;
+            settings: {
+                showGrid: boolean;
+            };
+        };
+        actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+            block: () => {
+                ensureRemoveDeletedBlocks: (layout: Layout) => void;
+            };
+            layout: () => {
+                addItem: (itemreference: AddItemToLayoutPayLoad) => void;
+            };
+            toggleGrid: () => void;
+            setEditorMode: (mode: import("@omnia/fx-models").LayoutCanvasMode) => void;
+            init: (canvasStore: ReturnType<typeof useLayoutCanvasStore>, editorChromeStore: ReturnType<typeof useEditorChromeStore>) => void;
+            dispose: () => void;
+        }>;
+        get: {
+            layout: {
+                active: () => Layout;
+            };
+            block: {
+                renderMode: () => BlockRenderingModes;
+            };
+        };
+        rules: {
+            hideGridSettings: () => boolean;
+            isLayoutItemLocked: (item: LayoutItem) => boolean;
+            isTemplateEnabledLayout: () => boolean;
+            isAdvancedModeActivated: () => boolean;
+        };
+        hooks: {
+            blockRemoved: {
+                trigger: (block: Block) => void;
+                subscribe: (callback: (block: Block) => void) => () => void;
+            };
+            blockCopied: {
+                trigger: (originalBlock: Block, newBlock: Block) => void;
+                subscribe: (callback: (originalBlock: Block, newBlock: Block) => void) => () => void;
+            };
+            layoutItemMoved: {
+                trigger: (layoutItem: LayoutItem) => void;
+                subscribe: (callback: (layoutItem: LayoutItem) => void) => () => void;
+            };
+            layoutPasted: {
+                trigger: (layoutItem: import("@omnia/fx-models").ClipboardLayoutItem) => void;
+                subscribe: (callback: (layoutItem: import("@omnia/fx-models").ClipboardLayoutItem) => void) => () => void;
+            };
+        };
+        dispose: () => void;
+    } & {
+        dispose?: () => void;
+    };
+    dispose: () => void;
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/index.d.ts

@@ -4,3 +4,4 @@ export * from "./BlockCatalogStore";
 export * from "./LayoutTemplateStore";
 export * from "./DynamicStateStore";
 export * from "./SettingsMenuStore";
+export * from "./LayoutCanvasStoreV2";

package/internal-do-not-import-from-here/ux/oxide/motion/Motion.d.ts

@@ -24,5 +24,5 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     "v-slots"?: {} & Omit<{
         default?: import("vue").Slot;
     }, never>;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "transition" | "variants" | "animate" | "initial" | "hover" | "exit" | "inView" | "press" | "inViewOptions" | "emit:click:someThing"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "transition" | "variants" | "animate" | "initial" | "hover" | "exit" | "press" | "inView" | "inViewOptions" | "emit:click:someThing"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/oxide/stickycontainer/StickyContainer.d.ts

@@ -8,5 +8,5 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<StickyContai
     } & Omit<{
         default?: import("vue").Slot;
     }, "customRenderer">;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "class" | "editor" | "getApi" | "viewportElementTrackingId" | "disable" | "slot:customRenderer"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "class" | "editor" | "getApi" | "disable" | "viewportElementTrackingId" | "slot:customRenderer"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/signin/omnia/Renderer.d.ts

@@ -60,9 +60,9 @@ declare const _default: {
         onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
         onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
         onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        back?: () => void;
         uniqueName?: string;
         authFlows?: AuthenticationOption[][];
-        back?: () => void;
         onProviderSelected?: (authOption: AuthenticationMetaData) => void;
         memorizedProvider?: AuthenticationMetaData;
     }>, never>;