@omnia/fx 7.11.0-preview.x → 7.11.2

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/BlockSettingsProvider.d.ts

@@ -1,12 +1,12 @@
-import { LayoutCanvasStore } from "../stores";
+import { IReactiveLayoutItemsSettingsStore } from "../../../models";
 import { ISettingsKeyProvider, SettingsService } from "../../../services";
 export interface BlockSettingsProviderConstructor {
-    layoutCanvasStore: LayoutCanvasStore;
+    blockSettingsStore: IReactiveLayoutItemsSettingsStore;
 }
 export declare class BlockSettingsProvider implements ISettingsKeyProvider {
-    private layoutCanvasStore;
+    blockSettingsStore: IReactiveLayoutItemsSettingsStore;
     settingsService: SettingsService<any>;
-    constructor(layoutCanvasStore: LayoutCanvasStore);
+    constructor(blockSettingsStore: IReactiveLayoutItemsSettingsStore);
     protectKeyWithSecurityRole: (securityRoleId: string) => void;
     getValue: (key: string) => Promise<any>;
     canSetValue: (key: string) => Promise<boolean>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/BreakPointManager.d.ts

@@ -1,8 +1,11 @@
 import { LayoutItemSettings, DisplayBreakPoint, DisplayBreakPointSetting } from "../../../models";
 export declare class BreakPointManager {
     private static breakPointArray;
+    private static printBreakPointArray;
     private static omniaUxLoc;
     static createSettingsForDeviceBreakPoint(settings: LayoutItemSettings, breakPoint: DisplayBreakPoint): LayoutItemSettings;
     static createSettingsFromBreakPointSettings(settings: LayoutItemSettings, breakPointSettings: Array<DisplayBreakPointSetting>): LayoutItemSettings;
     static breakPoints(): Array<DisplayBreakPoint>;
+    static printBreakPoints(): Array<DisplayBreakPoint>;
+    static isHiddenInPrint(settings: LayoutItemSettings): boolean;
 }

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/LayoutItemDelegator.d.ts

@@ -0,0 +1,16 @@
+import { ILayoutItemDelegator, IMessageBusTopicSubscription, LayoutItem, Section } from "@omnia/fx-models";
+import { BlockSettingsProvider } from "./BlockSettingsProvider";
+export interface SectionOverride {
+    originalSection: Section;
+    delegatedSection: Section;
+    blockSettingsProvider: BlockSettingsProvider;
+}
+export declare abstract class LayoutItemDelegator implements ILayoutItemDelegator {
+    abstract onStateChanged: IMessageBusTopicSubscription<void>;
+    abstract isConfigured(layout: LayoutItem): boolean;
+    abstract isDelegated(layout: LayoutItem): boolean;
+    abstract isOverridable(layout: LayoutItem): boolean;
+    abstract set(originalLayout: LayoutItem, delegatedLayout: LayoutItem): boolean;
+    abstract get(originalLayout: LayoutItem, createDefault: () => LayoutItem): LayoutItem;
+    abstract allowToViewSettings(): boolean;
+}

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/LayoutManager.d.ts

@@ -1,4 +1,4 @@
-import { ImportLayoutResult, Block } from "../../../models";
+import { ImportLayoutResult, Block, Section } from "../../../models";
 import { Layout, LayoutItem } from "@omnia/fx-models";
 import { LayoutCanvasStore } from "..";
 /**
@@ -37,4 +37,6 @@ export declare class LayoutManager {
      * @param blockName the name of the block
      */
     static getBlockByName(container: LayoutItem, elementName: string): LayoutItem;
+    static ensureDelegatedSections(layoutStore: LayoutCanvasStore, delegatedSections: Record<string, Section>, items: LayoutItem[]): void;
+    static ensureDelegatedSectionsForSelectedLayoutItem(layoutStore: LayoutCanvasStore, delegatedSections: Record<string, Section>, items: LayoutItem[]): void;
 }

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

@@ -8,3 +8,4 @@ export * from "./ThemingRenditionManager";
 export * from "./BreakPointManager";
 export * from "./LayoutManager";
 export * from "./styles";
+export * from "./LayoutItemDelegator";

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutdefinitionsettings/LayoutItemSettingsDefinitions.d.ts

@@ -1,4 +1,4 @@
-import { ILayoutCanvasTabDefinition, Guid, ILayoutCanvasExpansionItemDefinition, ILayoutCanvasTabInstance, ILayoutCanvasExpansionItemInstance, Block, LoadedLayout, ILayoutCanvasExpansionItemDefinitionSlots } from "@omnia/fx/models";
+import { ILayoutCanvasTabDefinition, Guid, ILayoutCanvasExpansionItemDefinition, ILayoutCanvasTabInstance, ILayoutCanvasExpansionItemInstance, Block, LoadedLayout, ILayoutCanvasExpansionItemDefinitionSlots, IReactiveLayoutItemsSettingsStore } from "@omnia/fx/models";
 import { MessageBusExposeOnlySubscription } from "@omnia/fx";
 export declare class TabsLayoutSettings implements ILayoutCanvasTabDefinition {
     static tabId: Guid;
@@ -121,7 +121,7 @@ export declare class TabBlockSettings implements ILayoutCanvasTabDefinition {
         beforeCreate: MessageBusExposeOnlySubscription<ILayoutCanvasTabDefinition>;
         created: MessageBusExposeOnlySubscription<ILayoutCanvasTabInstance>;
     };
-    createInstance(layout: LoadedLayout, block?: Block): Promise<ILayoutCanvasTabInstance>;
+    createInstance(layout: LoadedLayout, block?: Block, blockSettingsStore?: IReactiveLayoutItemsSettingsStore): Promise<ILayoutCanvasTabInstance>;
 }
 export declare class TabBlockLayoutSettings implements ILayoutCanvasTabDefinition {
     static tabId: Guid;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutBlockRenderer.d.ts

@@ -42,13 +42,17 @@ export declare class LayoutBlockRenderer extends VueComponentBase<BlockRendererP
     multilingualStore: MultilingualStore;
     blockInstance: BlockInstance;
     anchorLink: AnchorLink;
+    private subscriptionPrintHandler;
     private isHideBlock;
     private targetCurrentUser;
     private isEditMode;
     private isLazyLoad;
+    private isHideBlockInPrint;
+    private isRenderInViewPort;
     onBlockChanged(): void;
     beforeCreate(): void;
     created(): void;
+    private subcribeOnPrint;
     beforeDestroy(): void;
     private scrollIntoViewDisabled;
     private handleAnchorLink;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutColumnRenderer.d.ts

@@ -1,6 +1,7 @@
 import { ColumnedSectionItemSettings, SectionSettings, SectionItem } from "../../../../models";
 import { LayoutCanvasStore, BlockCatalogStore } from "../../";
 import { VueComponentBaseProps, VueComponentBase } from "../../../VueComponentBase";
+import { SubscriptionHandler } from "../../../..";
 import { MediaPickerService } from "../../../../services";
 export interface ColumnRendererProps extends VueComponentBaseProps {
     column: SectionItem<ColumnedSectionItemSettings>;
@@ -12,6 +13,7 @@ export declare class LayoutColumnRenderer extends VueComponentBase<ColumnRendere
     layoutEditorStore: LayoutCanvasStore;
     mediaPickerService: MediaPickerService;
     blockCatalogStore: BlockCatalogStore;
+    subscriptionHandler: SubscriptionHandler;
     column: SectionItem<ColumnedSectionItemSettings>;
     settings: SectionSettings;
     layoutId: string;
@@ -20,7 +22,11 @@ export declare class LayoutColumnRenderer extends VueComponentBase<ColumnRendere
     private blockInstances;
     private cacheKeys;
     private blockSettings;
+    private isHiddenOnPrint;
+    private delegatedSections;
+    private layoutItemDelegator;
     created(): void;
+    beforeDestroy(): void;
     private destroyed;
     private get backgroundImage();
     private onBlockInstanceCreated;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutSectionRenderer.d.ts

@@ -10,12 +10,14 @@ export interface LayoutSectionRendererProps extends VueComponentBaseProps {
     section: Section;
     layoutId: string;
     useScrollMargingFix: boolean;
+    overridable?: boolean;
 }
 export declare class LayoutSectionRenderer extends VueComponentBase<LayoutSectionRendererProps> implements ILayoutSectionRenderer {
     section: Section;
     parentContainer: LayoutItem;
     layoutId: string;
     useScrollMargingFix: boolean;
+    overridable?: boolean;
     targetingStore: UserTargetingStore;
     blockTitleSettingsStore: BlockTitleSettingsStore;
     layoutEditorStore: LayoutCanvasStore;
@@ -23,10 +25,12 @@ export declare class LayoutSectionRenderer extends VueComponentBase<LayoutSectio
     themeStore: ThemeStore;
     themingRenditionManager: ThemingRenditionManager;
     directionRuleStore: DirectionRuleStore;
+    private omniaUxLoc;
     ensureBackgroundImageHandler: (section: Section) => void;
     slots: LayoutSectionRendererSlots;
     private targetCurrentUser;
     private isEditMode;
+    private isHideBlockInPrint;
     beforeCreate(): void;
     created(): void;
     private get backgroundImage();

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

@@ -5,5 +5,15 @@ export declare class LayoutSectionContainerHelper {
     private static isAllBlocksHidden;
     private static hideBlockInBreakpoint;
     static getMediaQueryAllBlocksInSection(items: Array<LayoutItem>): Array<NestedCSSProperties>;
+    /**
+     * Check if all blocks in the column is hidden
+     * @param column
+     * @returns
+     */
     static isAllBlockHidden(column: SectionItem<ColumnedSectionItemSettings>): boolean;
+    /**
+     * Check if all blocks in the column is hidden on print settings
+     * @param column
+     */
+    static IsAllBlockHiddenOnPrint(column: SectionItem<ColumnedSectionItemSettings>): boolean;
 }

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/styles/SharedRendererStyles.css.d.ts

@@ -32,6 +32,7 @@ export declare const SharedRendererStyles: {
         columnWrapper: string;
         backgroundWrapperImage: string;
         getStyleStringForTitle: (settings: SectionSettings) => string;
+        getTitleContentClass: (settings: SectionSettings) => string;
         adjustScrollCompensation: (extra: number) => void;
         getStylesFromSettings: (settings: SectionSettings, useScrollMargingFix: boolean) => string;
         getStylesForSpacingInContainer(sectionSettings: SectionSettings, fullHeight: boolean): string;
@@ -39,6 +40,7 @@ export declare const SharedRendererStyles: {
         getStylesForMarginCollapsAndSpacing(sectionSettings: SectionSettings): string;
         sectionDisplayFlexDesignMode: string;
         sectionDisplayBlockDesignMode: string;
+        reusingContentMsg: string;
     };
     tabs: {
         tabWrapper: string;

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

@@ -1,6 +1,6 @@
-import { Layout, LayoutEditorModes, LayoutItem, DisplayBreakPoint, LayoutItemActionState, SettingsPanelState, DisplayBreakPointSetting, DeleteItemFromLayoutPayLoad, AddItemToLayoutPayLoad, LayoutItemRegistration, LoadedLayout, ILayoutCanvasStore, LayoutCanvasModes, BlockRenderingModes, IBlockInstance, ILayoutSectionRenderer, GuidValue, Block, LayoutDrawerState, LayoutDrawerTabs, SectionSettings, SectionTypes, Section, LayoutInheritanceBehaviors, ThemeDefinition, ClipboardLayoutItem, BlockTemplate } from "../../../models";
+import { Layout, LayoutEditorModes, LayoutItem, DisplayBreakPoint, LayoutItemActionState, SettingsPanelState, DisplayBreakPointSetting, DeleteItemFromLayoutPayLoad, AddItemToLayoutPayLoad, LayoutItemRegistration, LoadedLayout, ILayoutCanvasStore, LayoutCanvasModes, BlockRenderingModes, IBlockInstance, ILayoutSectionRenderer, GuidValue, Block, LayoutDrawerState, LayoutDrawerTabs, SectionSettings, SectionTypes, Section, LayoutInheritanceBehaviors, ThemeDefinition, ClipboardLayoutItem, BlockTemplate, ILayoutItemDelegator, IMessageBusSubscriptionHandler } from "../../../models";
 import { EditorLayoutItemFactory } from "../factories";
-import { LayoutEditorThemingManager } from "../shared";
+import { LayoutEditorThemingManager, SectionOverride } from "../shared";
 import { BlockSettingsProvider, LayoutDefinitionBuilder } from "../shared";
 import { MessageBusExposeOnlySubscription } from "../../..";
 import { ThemeStore } from "../../theming";
@@ -15,7 +15,6 @@ type BlockInstancesByManifestResult<TSettings = void> = {
 };
 export declare class LayoutCanvasStore extends Store implements ILayoutCanvasStore {
     themeStore: ThemeStore;
-    private subscriptionHandler;
     private serviceContainerContext;
     layout: StoreState<LoadedLayout>;
     previewUrl: StoreState<string>;
@@ -38,6 +37,12 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
     suggestedBlocks: StoreState<string[]>;
     layoutInheritanceBehaviors: StoreState<LayoutInheritanceBehaviors>;
     enableDisplayBreakpointSettings: StoreState<boolean>;
+    sectionOverrides: StoreState<{
+        [layoutId: string]: SectionOverride;
+    }>;
+    sectionOverrideRefs: StoreState<{
+        [layoutItemId: string]: string;
+    }>;
     blockThemeDefinition: StoreState<ThemeDefinition>;
     layoutThemeDefinition: StoreState<ThemeDefinition>;
     isDesignRender: StoreState<boolean>;
@@ -50,6 +55,8 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
     private onLayoutSectionRendererCreatedHook;
     private blockSettingsProvider;
     private onLayoutPastedHook;
+    private layoutItemDelegatorSubHandler;
+    private layoutItemDelegator;
     settingsPanel: StoreState<SettingsPanelState>;
     layoutDrawer: StoreState<LayoutDrawerState>;
     constructor(provider?: string);
@@ -67,6 +74,9 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
         getSuggestedBlocks: () => string[];
         getDefinitionBuilder: () => LayoutDefinitionBuilder;
         getLayoutBackgroundImageElementId: () => string;
+        getLayoutItemDelegator: () => ILayoutItemDelegator;
+        getSectionOverride: (id: string) => SectionOverride;
+        getInheritedSectionOverride: (id: string) => SectionOverride;
         blockRenderMode: () => BlockRenderingModes;
         isLayoutItemLocked: (item: LayoutItem) => boolean;
         isTemplateEnabledLayout: () => boolean;
@@ -80,7 +90,7 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
      * Implementation of mutations
      */
     mutations: {
-        setLayout: (layout: Layout) => void;
+        setLayout: (layout: Layout, delegator?: ILayoutItemDelegator) => void;
         createNewLayout: () => void;
         setTheme: (layoutThemeDefinition: ThemeDefinition, blockThemeDefinition: ThemeDefinition) => void;
         setCanvasMode: (mode: LayoutCanvasModes) => void;
@@ -95,19 +105,22 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
         enableDisplayBreakpointSettings: (enable: boolean) => void;
         disableAnchorLink: () => void;
         disableAuth: () => void;
-        unlockBlock: import("../../../stores").StoreMutation<(layoutItem: LayoutItem) => void, (layoutItem: LayoutItem) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        lockBlock: import("../../../stores").StoreMutation<(layoutItem: LayoutItem) => void, (layoutItem: LayoutItem) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        setSelectedLayoutItem: import("../../../stores").StoreMutation<(item: LayoutItem, toggleSettings: boolean) => void, (item: LayoutItem, toggleSettings: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        toggleActionForLayoutItem: import("../../../stores").StoreMutation<(item: LayoutItem | ClipboardLayoutItem, action: LayoutItemActionState) => void, (item: ClipboardLayoutItem | LayoutItem, action: LayoutItemActionState) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        addDeviceBreakPointSetting: import("../../../stores").StoreMutation<(breakPointSetting: DisplayBreakPointSetting) => void, (breakPointSetting: DisplayBreakPointSetting) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        removeDeviceBreakPointSetting: import("../../../stores").StoreMutation<(propertyName: string, displayBreakPoint: DisplayBreakPoint) => void, (propertyName: string, displayBreakPoint: DisplayBreakPoint) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        moveItemInLayout: import("../../../stores").StoreMutation<(item2Move: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (item2Move: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        changeSectionType: import("../../../stores").StoreMutation<(section: Section, type: SectionTypes) => void, (section: Section<SectionSettings>, type: SectionTypes) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        copyItemInLayout: import("../../../stores").StoreMutation<(item2Copy: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (item2Copy: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        insertClipboardItemIntoLayout: import("../../../stores").StoreMutation<(clipboard: ClipboardLayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (clipboard: ClipboardLayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        insertBlockTemplateToLayout: import("../../../stores").StoreMutation<(blockTemplate: BlockTemplate, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (blockTemplate: BlockTemplate, container: LayoutItem, siblingId?: string, postInsert?: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        addItem2Layout: import("../../../stores").StoreMutation<(itemreference: AddItemToLayoutPayLoad) => void, (itemreference: AddItemToLayoutPayLoad) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
-        deleteItemFromLayout: import("../../../stores").StoreMutation<(itemreference: DeleteItemFromLayoutPayLoad) => void, (itemreference: DeleteItemFromLayoutPayLoad) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        saveDelegatedLayouts: () => void;
+        unlockBlock: import("../../../stores").StoreMutation<(layoutItem: LayoutItem) => void, (layoutItem: LayoutItem) => IMessageBusSubscriptionHandler>;
+        lockBlock: import("../../../stores").StoreMutation<(layoutItem: LayoutItem) => void, (layoutItem: LayoutItem) => IMessageBusSubscriptionHandler>;
+        setSelectedLayoutItem: import("../../../stores").StoreMutation<(item: LayoutItem, toggleSettings: boolean) => void, (item: LayoutItem, toggleSettings: boolean) => IMessageBusSubscriptionHandler>;
+        toggleActionForLayoutItem: import("../../../stores").StoreMutation<(item: LayoutItem | ClipboardLayoutItem, action: LayoutItemActionState) => void, (item: ClipboardLayoutItem | LayoutItem, action: LayoutItemActionState) => IMessageBusSubscriptionHandler>;
+        addDeviceBreakPointSetting: import("../../../stores").StoreMutation<(breakPointSetting: DisplayBreakPointSetting) => void, (breakPointSetting: DisplayBreakPointSetting) => IMessageBusSubscriptionHandler>;
+        removeDeviceBreakPointSetting: import("../../../stores").StoreMutation<(propertyName: string, displayBreakPoint: DisplayBreakPoint) => void, (propertyName: string, displayBreakPoint: DisplayBreakPoint) => IMessageBusSubscriptionHandler>;
+        moveItemInLayout: import("../../../stores").StoreMutation<(item2Move: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (item2Move: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => IMessageBusSubscriptionHandler>;
+        changeSectionType: import("../../../stores").StoreMutation<(section: Section, type: SectionTypes) => void, (section: Section<SectionSettings>, type: SectionTypes) => IMessageBusSubscriptionHandler>;
+        copyItemInLayout: import("../../../stores").StoreMutation<(item2Copy: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (item2Copy: LayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => IMessageBusSubscriptionHandler>;
+        insertClipboardItemIntoLayout: import("../../../stores").StoreMutation<(clipboard: ClipboardLayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (clipboard: ClipboardLayoutItem, container: LayoutItem, siblingId?: string, postInsert?: boolean) => IMessageBusSubscriptionHandler>;
+        insertBlockTemplateToLayout: import("../../../stores").StoreMutation<(blockTemplate: BlockTemplate, container: LayoutItem, siblingId?: string, postInsert?: boolean) => void, (blockTemplate: BlockTemplate, container: LayoutItem, siblingId?: string, postInsert?: boolean) => IMessageBusSubscriptionHandler>;
+        addItem2Layout: import("../../../stores").StoreMutation<(itemreference: AddItemToLayoutPayLoad) => void, (itemreference: AddItemToLayoutPayLoad) => IMessageBusSubscriptionHandler>;
+        deleteItemFromLayout: import("../../../stores").StoreMutation<(itemreference: DeleteItemFromLayoutPayLoad) => void, (itemreference: DeleteItemFromLayoutPayLoad) => IMessageBusSubscriptionHandler>;
+        addSectionOverride: (section: Section) => SectionOverride;
+        removeSectionOverride: (section: Section) => void;
     };
     /**
     * Implementation of events
@@ -125,9 +138,14 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
     private onBlockRemoved;
     onBlockInstanceCreated(blockInstance: IBlockInstance): IBlockInstance<void>;
     onLayoutSectionRendererCreated(layoutSectionRenderer: ILayoutSectionRenderer): void;
+    private createSectionOverride;
+    private addSectionOverrideRef;
+    private removeSectionOverrideRef;
     private ensureRemoveDeletedBlocks;
     private ensureRealLayoutId;
+    private recursiveEnsureRealLayoutId;
     private ensureUniqueLayoutId;
+    private recursiveEnsureOwnerLayoutId;
     private getOwnerLayoutItemsOverride;
     private recursiveEnsureProperties;
     private deleteItem;

package/internal-do-not-import-from-here/ux/mediapickerproviders/Youtube/YouTubeProvider.d.ts

@@ -46,6 +46,7 @@ export declare class YouTubeProviderComponent extends MultiSelectMediaProviderCo
     private getStartTimeAsSeconds;
     private processResponsiveIframe;
     private updateVideoState;
+    private waitForIframeLoad;
     private saveYoutubeResult;
     private renderVideoIframe;
     private renderResponsiveVideoIframe;

package/internal-do-not-import-from-here/ux/mediapickerproviders/gptimageprovider/GptImageProvider.css.d.ts

@@ -0,0 +1,41 @@
+import { types } from "typestyle";
+import { ITheming } from "@omnia/fx/ux";
+export declare const imageSize = 357.25;
+export declare const GptImageProviderStyles: {
+    wrapper: string;
+    text: string;
+    notify: string;
+    label: string;
+    inputText: string;
+    selectInputStyle: string;
+    imageCol: string;
+    imageHeight: string;
+    image: string;
+    shadowCard: string;
+    skeletonWrapper: string;
+    GptImageFilterContentErrorWrapper: string;
+    ErrorIcon: string;
+    promptTip: string;
+    FullHeight: string;
+};
+export declare const gptImageImageGridStyles: {
+    row?: types.NestedCSSProperties;
+    column?: types.NestedCSSProperties;
+    imageWrapper?: types.NestedCSSProperties;
+    image?: types.NestedCSSProperties;
+    noResultsWrapper: types.NestedCSSProperties;
+    noResultsPositioner: types.NestedCSSProperties;
+    noResultsText: (theme: ITheming) => types.NestedCSSProperties;
+    overlay?: types.NestedCSSProperties;
+    backgroundColor?: types.NestedCSSProperties;
+    defaultOverlay?: types.NestedCSSProperties;
+};
+export declare const MediaProviderComponentBaseStyles: {
+    baseWrapper: string;
+    providerWrapper: string;
+    loadingProviderWrapper: string;
+    providerContent: string;
+    loadingOverlayWrapper: string;
+    loadingWrapper: string;
+    gridWrapper: string;
+};

package/internal-do-not-import-from-here/ux/mediapickerproviders/gptimageprovider/GptImageProvider.d.ts

@@ -0,0 +1,53 @@
+import { OmniaTheming } from "@omnia/fx/ux";
+import { IWebComponentInstance, OmniaContext } from "@omnia/fx";
+import { type OmniaUxLocalization } from "@omnia/fx/ux";
+import { GridViewMediaProviderComponent } from "../mediaproviderbase/GridViewMediaProviderComponent";
+import { ImageInformation, VideoItem, ImageItem, MediaPickerVideo, VideoInformation, MediaPickerImageTransformationResult, IBusinessProfile } from "../../../models";
+import { AzureOpenAIService } from "../../../services";
+import { GptImageProviderLocalization } from "./loc/localize";
+import { TextToImagesRequest, GeneratedImage, TextToImagesResponse } from "@omnia/fx-models";
+import "./GptImageProvider.css";
+import { MultilingualStore } from "@omnia/fx/stores";
+export default class GptImageProvider extends GridViewMediaProviderComponent implements IWebComponentInstance {
+    beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
+    getMediaItems(searchKeyword: string): Promise<GeneratedImage[]>;
+    getMoreMediaItems(lastLoadedIndex: number): Promise<GeneratedImage[]>;
+    getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
+    setEmptyResultHandler(): void;
+    azureOpenAiService: AzureOpenAIService;
+    omniaTheming: OmniaTheming;
+    private aiSettingsService;
+    omniaCtx: OmniaContext;
+    multilingualStore: MultilingualStore;
+    gptImageLoc: GptImageProviderLocalization.locInterface;
+    omniaUxLoc: OmniaUxLocalization;
+    private searchKeyword;
+    private GptImageSupportImageResolution;
+    private generatedImages;
+    private textToImagesRequests;
+    private resultStyles;
+    private selectedImageResolution;
+    private textToImagesResponseMap;
+    private gptImagePredefinedPromptList;
+    private preDefinedPrompt;
+    private preDefaultPrompt;
+    private gptImageConstant;
+    private displayPrompts;
+    private getTextToImagesRequest;
+    constructor();
+    created(): void;
+    mounted(): void;
+    initGptImagePromptSettingsListing(businessProfileId: IBusinessProfile): Promise<void>;
+    onGenerateImage(): void;
+    onPressEnter: (event: KeyboardEvent) => void;
+    getPredefinedPrompts(predefinedPrompt: string): void;
+    selectGridItemPublic(item: GeneratedImage): void;
+    addGeneratedImage(item: GeneratedImage, textToImagesRequest: TextToImagesRequest): void;
+    addTextToImagesResponse(item: TextToImagesResponse, textToImagesRequest: TextToImagesRequest): void;
+    onRegenerateImage(textToImagesRequest: TextToImagesRequest): void;
+    private renderCustomSlot;
+    private getPredefinedPromptsItem;
+    private renderPredefinedPrompts;
+    private renderPromptInput;
+    render(): VueTsxSupport.JSX.Element;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/gptimageprovider/PollingImageComponent.d.ts

@@ -0,0 +1,47 @@
+import { GeneratedImage, TextToImagesRequest, TextToImagesResponse } from "@omnia/fx-models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    textToImageRequest: TextToImagesRequest;
+    selectGridItem: (mediaItem: GeneratedImage) => void;
+    generatedImage: GeneratedImage;
+    addGeneratedImage: (generatedImage: GeneratedImage, textToImageRequest: TextToImagesRequest) => void;
+    onRegenerateImage: (textToImageRequest: TextToImagesRequest) => void;
+    textToImageResponse: TextToImagesResponse;
+    addTextToImageResponse: (textToImageResponse: TextToImagesResponse, textToImageRequest: TextToImagesRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        textToImageRequest: TextToImagesRequest;
+        selectGridItem: (mediaItem: GeneratedImage) => void;
+        generatedImage: GeneratedImage;
+        addGeneratedImage: (generatedImage: GeneratedImage, textToImageRequest: TextToImagesRequest) => void;
+        onRegenerateImage: (textToImageRequest: TextToImagesRequest) => void;
+        textToImageResponse: TextToImagesResponse;
+        addTextToImageResponse: (textToImageResponse: TextToImagesResponse, textToImageRequest: TextToImagesRequest) => void;
+        imageRef: HTMLImageElement;
+        setImageRef: (imageRef: HTMLImageElement) => void;
+    }, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    textToImageRequest: TextToImagesRequest;
+    selectGridItem: (mediaItem: GeneratedImage) => void;
+    generatedImage: GeneratedImage;
+    addGeneratedImage: (generatedImage: GeneratedImage, textToImageRequest: TextToImagesRequest) => void;
+    onRegenerateImage: (textToImageRequest: TextToImagesRequest) => void;
+    textToImageResponse: TextToImagesResponse;
+    addTextToImageResponse: (textToImageResponse: TextToImagesResponse, textToImageRequest: TextToImagesRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        textToImageRequest: TextToImagesRequest;
+        selectGridItem: (mediaItem: GeneratedImage) => void;
+        generatedImage: GeneratedImage;
+        addGeneratedImage: (generatedImage: GeneratedImage, textToImageRequest: TextToImagesRequest) => void;
+        onRegenerateImage: (textToImageRequest: TextToImagesRequest) => void;
+        textToImageResponse: TextToImagesResponse;
+        addTextToImageResponse: (textToImageResponse: TextToImagesResponse, textToImageRequest: TextToImagesRequest) => void;
+        imageRef: HTMLImageElement;
+        setImageRef: (imageRef: HTMLImageElement) => void;
+    }, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/mediapickerproviders/gptimageprovider/loc/localize.d.ts

@@ -0,0 +1,23 @@
+export declare module GptImageProviderLocalization {
+    const namespace = "Omnia.Ux.GptImageProvider";
+    interface locInterface {
+        Title: string;
+        FeatureTitle: string;
+        FeatureDescription: string;
+        DowloadImageFailed: string;
+        PhotoBy: string;
+        PhotosProviderBy: string;
+        MaxInputLength: number;
+        Generate: string;
+        SelectSizePicture: string;
+        Download: string;
+        GenerateNewImage: string;
+        ErrorMessage: string;
+        ImageName: string;
+        PromptHeader: string;
+        PromptContent: string;
+        PromptExample: string;
+        Label: string;
+        ImageStyle: string;
+    }
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowMedia.d.ts

@@ -16,6 +16,7 @@ export interface MediaFlowImage extends MediaflowInformation {
     photographer: string;
     url: string;
     width: number;
+    altText: string;
 }
 export interface MediaFlowVideo extends MediaflowInformation {
     autoPlay: boolean;

package/internal-do-not-import-from-here/ux/print/api/PrintHandlerApi.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/ux/profilecard/ProfileCard.d.ts

@@ -33,6 +33,8 @@ export declare class ProfileCardComponent extends VueComponentBase<IProfileCard>
     private isOmniaUser;
     private resolvedUser;
     private accessibilityEnabled;
+    private get enablePeopleInformation();
+    private get renderedHref();
     created(): void;
     beforeDestroy(): void;
     hasSlot(): boolean;

package/internal-do-not-import-from-here/ux/richtexteditor/IRichTextEditor.d.ts

@@ -65,6 +65,11 @@ export interface IRichTextEditor {
      * @return {RichTextEditorExtension[]} List of extension after configured
      */
     onConfigureExtensions?: (currentExtensions: Array<RichTextEditorExtension>, registrationResolver?: (registration: RichTextEditorExtensionRegistration) => RichTextEditorExtension, extensionHelper?: IRichTextEditorExtensionHelper) => Array<RichTextEditorExtension>;
+    /**
+     * Configure the automatic format cleaning status before passing into RTE
+     * @return {boolean} the status of automatic format cleaning after configured
+     */
+    onConfigureAutomaticFormatCleaning?: () => boolean;
     styles?: typeof RichTextEditorStyles;
     placeholder?: RichTextEditorPlaceHolder;
     disabled?: boolean;

package/internal-do-not-import-from-here/ux/richtexteditor/RichTextEditor.d.ts

@@ -25,6 +25,7 @@ export default class RichTextEditor extends VueComponentBase implements IWebComp
     autoFocus?: boolean;
     disableAutofocus?: boolean;
     mode: RichTextModes;
+    onConfigureAutomaticFormatCleaning?: () => boolean;
     onConfigureExtensions?: (currentExtensions: Array<RichTextEditorExtension>, registrationResolver?: (registration: RichTextEditorExtensionRegistration) => RichTextEditorExtension, extensionHelper?: IRichTextEditorExtensionHelper) => Array<RichTextEditorExtension>;
     onConfiguredExtensions?: (currentExtensions: Array<RichTextEditorExtension>, registrationResolver?: (registration: RichTextEditorExtensionRegistration) => RichTextEditorExtension) => Promise<Array<RichTextEditorExtension>>;
     ariaDescribedby?: string;
@@ -59,6 +60,7 @@ export default class RichTextEditor extends VueComponentBase implements IWebComp
     private extensions;
     private allExtensions;
     private isRightToLeft;
+    private enableAutoCleanTextFormatAfterPaste;
     private extensionOnBlurFuncs;
     private hasLanguagePicker;
     onTopicIdChange(newValue: boolean, oldValue: boolean): void;
@@ -74,7 +76,7 @@ export default class RichTextEditor extends VueComponentBase implements IWebComp
     buildExtensionList(extensionListFromTenantSettings: RichTextEditorExtensionRegistration[]): RichTextEditorExtension[];
     initExtensions(): void;
     private ensureHeadingNode;
-    handleCursorPosition(formatedText: any, formatedHtml: any, view: any, from: any, to: any): void;
+    handleCursorPosition(formatedText: any, formatedHtml: any, view: any, from: any, to: any, onCompleted?: (transaction: any) => void): void;
     setupEditor(): void;
     private currentEmitedContent;
     private onEditorUpdated;

package/internal-do-not-import-from-here/ux/richtexteditor/RichTextEditorSettings.d.ts

@@ -4,7 +4,7 @@ import { VueComponentBase } from "..";
 import { OmniaContext } from "../..";
 import { RichTextEditorExtensionRegistration } from "../../models/RichTextEditorExtension";
 import { IRichTextEditorSettings } from "./IRichTextEditorSettings";
-import { MultilingualStore } from "internal/fx/stores";
+import { MediaPickerStore, MultilingualStore } from "internal/fx/stores";
 export interface RTFExtensionViewModel extends RichTextEditorExtensionRegistration {
     instance: any;
     isChecked?: boolean;
@@ -13,7 +13,9 @@ export interface RTFExtensionViewModel extends RichTextEditorExtensionRegistrati
 export default class RichTextEditorSettings extends VueComponentBase implements IWebComponentInstance, IRichTextEditorSettings {
     showEditorPreview: boolean;
     extensions: Array<RTFExtensionViewModel>;
+    enableAutomaticFormatCleaning: boolean;
     onExtensionChange: (model: Array<RTFExtensionViewModel>) => void;
+    onAutomaticFormatCleaningChange?: (enable: boolean) => void;
     private omniaTheming;
     private omniaUxLoc;
     private loc;
@@ -21,6 +23,7 @@ export default class RichTextEditorSettings extends VueComponentBase implements
     private localizationService;
     private settingsService;
     multilingualStore: MultilingualStore;
+    mediaPickerStore: MediaPickerStore;
     private guid;
     private richTextEditorExtensionSubscriptionHandler;
     private isSaving;
@@ -31,10 +34,18 @@ export default class RichTextEditorSettings extends VueComponentBase implements
     private formValidator;
     private textStylesSettingKey;
     private headings;
+    private extensionIdsHaveSettings;
+    private selectableCropRatioUniqueIds;
+    private selectedCropRatioUniqueId;
     created(): void;
     init(): void;
     mounted(): void;
     beforeDestroy(): void;
+    private initSelectableCropRatios;
+    private getRatioDefinitionItems;
+    private onEditCropRatio;
+    private onAddCropRatio;
+    private onRemoveCropRatio;
     private migratenewHeading;
     private getHeadingSettings;
     private onExtensionCheckedChanged;
@@ -49,5 +60,6 @@ export default class RichTextEditorSettings extends VueComponentBase implements
     renderPreviewEditor(): VueTsxSupport.JSX.Element;
     renderExtensions(): VueTsxSupport.JSX.Element;
     renderListTileContent(extension: RTFExtensionViewModel, extensions: RTFExtensionViewModel[]): VueTsxSupport.JSX.Element[];
+    renderMediaPickerSettings(extension: RTFExtensionViewModel): VueTsxSupport.JSX.Element;
     renderHeadingSettings(extension: RTFExtensionViewModel): VueTsxSupport.JSX.Element;
 }

package/internal-do-not-import-from-here/ux/richtexteditor/extensions/Alignment/AlignmentNode.d.ts

@@ -1,5 +1,5 @@
-import { NodeExtension } from "../../NodeExtension";
-export default class Alignment extends NodeExtension {
+import { MarkExtension } from "../../MarkExtension";
+export default class Alignment extends MarkExtension {
     constructor();
     get name(): string;
     get schema(): any;

package/internal-do-not-import-from-here/ux/richtexteditor/extensions/MediaPicker/MediaPickerEditorExtension.d.ts

@@ -1,14 +1,19 @@
 import { IMediaPicker } from "../../..";
-import { Guid } from "../../../../models";
+import { Guid, MediaPickerExtensionSettings } from "../../../../models";
+import { MediaPickerStore } from "../../../../stores";
 import { RichTextEditorExtension, RichTextEditorExtensionDefinition } from "../../IRichTextEditor";
 export declare class MediaPickerEditorExtension implements RichTextEditorExtension {
     private mediaPickerSettings;
+    protected mediaPickerStore: MediaPickerStore;
     static get id(): Guid;
+    settings: MediaPickerExtensionSettings;
     private editingMedia;
     /**
      * Configure the mediapicker wich should be used
      * @param mediaPickerSettings
      */
-    constructor(mediaPickerSettings: IMediaPicker);
+    constructor(config: MediaPickerExtensionSettings, mediaPickerSettings: IMediaPicker);
     getDefition(): Promise<RichTextEditorExtensionDefinition>;
+    ensureImageCropRatios(): Promise<void>;
+    static defaultMediaPickerSettings(): MediaPickerExtensionSettings;
 }