@omnia/fx 8.0.111-vnext → 8.0.112-vnext

package/internal-do-not-import-from-here/ux/mediapickerV2/stores/MediaPickerEditorStore.d.ts

@@ -0,0 +1,166 @@
+import { ImageTransformerOptions, MediaPickerCropTransformation, MediaPickerImageInformation, MediaPickerImageRatio, MediaPickerImageTransformationResult, MediaPickerProvider, MediaPickerRenditionData, MediaPickerRollupImageRatio, MediaPickerTransformedBase64Image } from "@omnia/fx-models";
+export declare const useMediaPickerEditorStore: (newInstanceWithName?: string) => {
+    state: {
+        /**Providers */
+        selectedProvider: MediaPickerProvider;
+        providerElement: string;
+        /**Editor visibility */
+        showImageTransformer: boolean;
+        showWarningDialog: boolean;
+        showProviderSelector: boolean;
+        renderProviderElement: boolean;
+        /**Selected media */
+        imageSrc: string;
+        defaultRendition: MediaPickerTransformedBase64Image;
+        imageInformation: MediaPickerImageInformation;
+        mediaGalleryItems: MediaPickerImageTransformationResult[];
+        /**Settings */
+        selectedCropTransformation: MediaPickerCropTransformation;
+        renditions: MediaPickerRenditionData[];
+        defaultRenditionRatios: MediaPickerImageRatio[];
+        rollupRenditionRatios: MediaPickerRollupImageRatio[];
+        options: ImageTransformerOptions;
+        galleryItemLimit: number;
+        enableGallery: boolean;
+    };
+    events: {
+        onMutatingSelectedProvider: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerProvider>;
+        onMutatedSelectedProvider: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerProvider>;
+        onMutatingProviderElement: import("internal/fx/core").MessageBusExposeOnlySubscription<string>;
+        onMutatedProviderElement: import("internal/fx/core").MessageBusExposeOnlySubscription<string>;
+        onMutatingShowImageTransformer: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowImageTransformer: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowWarningDialog: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowWarningDialog: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowProviderSelector: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowProviderSelector: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingRenderProviderElement: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedRenderProviderElement: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingImageSrc: import("internal/fx/core").MessageBusExposeOnlySubscription<string>;
+        onMutatedImageSrc: import("internal/fx/core").MessageBusExposeOnlySubscription<string>;
+        onMutatingDefaultRendition: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerTransformedBase64Image>;
+        onMutatedDefaultRendition: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerTransformedBase64Image>;
+        onMutatingImageInformation: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageInformation>;
+        onMutatedImageInformation: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageInformation>;
+        onMutatingMediaGalleryItems: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageTransformationResult[]>;
+        onMutatedMediaGalleryItems: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageTransformationResult[]>;
+        onMutatingSelectedCropTransformation: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerCropTransformation>;
+        onMutatedSelectedCropTransformation: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerCropTransformation>;
+        onMutatingRenditions: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerRenditionData[]>;
+        onMutatedRenditions: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerRenditionData[]>;
+        onMutatingDefaultRenditionRatios: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageRatio[]>;
+        onMutatedDefaultRenditionRatios: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerImageRatio[]>;
+        onMutatingRollupRenditionRatios: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerRollupImageRatio[]>;
+        onMutatedRollupRenditionRatios: import("internal/fx/core").MessageBusExposeOnlySubscription<MediaPickerRollupImageRatio[]>;
+        onMutatingOptions: import("internal/fx/core").MessageBusExposeOnlySubscription<ImageTransformerOptions>;
+        onMutatedOptions: import("internal/fx/core").MessageBusExposeOnlySubscription<ImageTransformerOptions>;
+        onMutatingGalleryItemLimit: import("internal/fx/core").MessageBusExposeOnlySubscription<number>;
+        onMutatedGalleryItemLimit: import("internal/fx/core").MessageBusExposeOnlySubscription<number>;
+        onMutatingEnableGallery: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedEnableGallery: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching<T extends (...args: any) => any>(action: (actions: {
+            provider: () => {
+                setSelected(provider: MediaPickerProvider): void;
+            };
+            media: () => {
+                addGallery(mediaPickerImage: MediaPickerImageTransformationResult): void;
+                setSelected(mediaPickerImage: MediaPickerImageTransformationResult): void;
+            };
+            ratio: () => {
+                addDefault(ratio: MediaPickerImageRatio): void;
+                add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+            };
+            editor: () => {
+                setOptions(options: ImageTransformerOptions): void;
+                toggleWarningDialog: (show: boolean) => void;
+                toggleProvider(show: boolean): void;
+            };
+            cropping: () => {
+                set4SelectedRendition: (newValue: MediaPickerImageRatio | MediaPickerCropTransformation) => void;
+                updateSelectedRendition: (newValue: MediaPickerCropTransformation) => void;
+                updateSelectedRenditionWithRatio: (ratio: MediaPickerImageRatio) => void;
+                updateRenditionFromCrop(newValue: MediaPickerCropTransformation): void;
+            };
+        }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
+            provider: () => {
+                setSelected(provider: MediaPickerProvider): void;
+            };
+            media: () => {
+                addGallery(mediaPickerImage: MediaPickerImageTransformationResult): void;
+                setSelected(mediaPickerImage: MediaPickerImageTransformationResult): void;
+            };
+            ratio: () => {
+                addDefault(ratio: MediaPickerImageRatio): void;
+                add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+            };
+            editor: () => {
+                setOptions(options: ImageTransformerOptions): void;
+                toggleWarningDialog: (show: boolean) => void;
+                toggleProvider(show: boolean): void;
+            };
+            cropping: () => {
+                set4SelectedRendition: (newValue: MediaPickerImageRatio | MediaPickerCropTransformation) => void;
+                updateSelectedRendition: (newValue: MediaPickerCropTransformation) => void;
+                updateSelectedRenditionWithRatio: (ratio: MediaPickerImageRatio) => void;
+                updateRenditionFromCrop(newValue: MediaPickerCropTransformation): void;
+            };
+        }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onFailure<T_2 extends (...args: any) => any>(action: (actions: {
+            provider: () => {
+                setSelected(provider: MediaPickerProvider): void;
+            };
+            media: () => {
+                addGallery(mediaPickerImage: MediaPickerImageTransformationResult): void;
+                setSelected(mediaPickerImage: MediaPickerImageTransformationResult): void;
+            };
+            ratio: () => {
+                addDefault(ratio: MediaPickerImageRatio): void;
+                add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+            };
+            editor: () => {
+                setOptions(options: ImageTransformerOptions): void;
+                toggleWarningDialog: (show: boolean) => void;
+                toggleProvider(show: boolean): void;
+            };
+            cropping: () => {
+                set4SelectedRendition: (newValue: MediaPickerImageRatio | MediaPickerCropTransformation) => void;
+                updateSelectedRendition: (newValue: MediaPickerCropTransformation) => void;
+                updateSelectedRenditionWithRatio: (ratio: MediaPickerImageRatio) => void;
+                updateRenditionFromCrop(newValue: MediaPickerCropTransformation): void;
+            };
+        }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    } & {
+        provider: () => {
+            setSelected(provider: MediaPickerProvider): void;
+        };
+        media: () => {
+            addGallery(mediaPickerImage: MediaPickerImageTransformationResult): void;
+            setSelected(mediaPickerImage: MediaPickerImageTransformationResult): void;
+        };
+        ratio: () => {
+            addDefault(ratio: MediaPickerImageRatio): void;
+            add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+        };
+        editor: () => {
+            setOptions(options: ImageTransformerOptions): void;
+            toggleWarningDialog: (show: boolean) => void;
+            toggleProvider(show: boolean): void;
+        };
+        cropping: () => {
+            set4SelectedRendition: (newValue: MediaPickerImageRatio | MediaPickerCropTransformation) => void;
+            updateSelectedRendition: (newValue: MediaPickerCropTransformation) => void;
+            updateSelectedRenditionWithRatio: (ratio: MediaPickerImageRatio) => void;
+            updateRenditionFromCrop(newValue: MediaPickerCropTransformation): void;
+        };
+    };
+    get: {
+        showMenuBar: () => boolean;
+        ratioById: (id: number) => MediaPickerImageRatio;
+        defaultCropTransformation: () => MediaPickerCropTransformation;
+        cropTransformationByRatioId: (ratioId: number) => MediaPickerCropTransformation;
+        renditionByRatioId: (ratioId: number) => MediaPickerRenditionData;
+    };
+};

package/internal-do-not-import-from-here/{stores → ux/mediapickerV2/stores}/MediaPickerProviderStore.d.ts

@@ -1,16 +1,10 @@
-import { GuidValue, IIcon, IMediaFileProcessor, IMediaPickerSerchProvider, ImageInformation, MediaItem, MediaPickerImageScaling, MediaPickerLimitedSizeSettings, MediaPickerProvider } from "@omnia/fx-models";
-interface ProviderRegistration {
-    id: GuidValue;
-    active: boolean;
-    provider: MediaPickerProvider;
-}
+import { IIcon, IMediaFileProcessor, IMediaPickerSerchProvider, ImageInformation, MediaItem, MediaPickerImageScaling, MediaPickerImageTransformationResult, MediaPickerLimitedSizeSettings } from "@omnia/fx-models";
 interface StateMessage {
     message: string;
     icon?: IIcon;
 }
 export declare const useMediaPickerProviderStore: (newInstanceWithName?: string) => {
     state: {
-        providers: ProviderRegistration[];
         searchQueryText: string;
         isSearching: boolean;
         showLoadingOverlay: boolean;
@@ -20,7 +14,9 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         showErrorDownloadingImage: boolean;
         showFileTypeNotSupported: boolean;
         selectedMediaItem: MediaItem;
-        selectedMediaItemInfo: ImageInformation;
+        mediaItemInProcessing: ImageInformation;
+        processedMediaItemResult: MediaPickerImageTransformationResult;
+        scaleProcessingImage: boolean;
         searchResult: MediaItem[];
         searchProvider: IMediaPickerSerchProvider;
         statusMessage: StateMessage;
@@ -29,8 +25,6 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         fileProcessor: IMediaFileProcessor;
     };
     events: {
-        onMutatingProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<ProviderRegistration[]>;
-        onMutatedProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<ProviderRegistration[]>;
         onMutatingSearchQueryText: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
         onMutatedSearchQueryText: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
         onMutatingIsSearching: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
@@ -49,8 +43,12 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         onMutatedShowFileTypeNotSupported: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatingSelectedMediaItem: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem>;
         onMutatedSelectedMediaItem: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem>;
-        onMutatingSelectedMediaItemInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
-        onMutatedSelectedMediaItemInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
+        onMutatingMediaItemInProcessing: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
+        onMutatedMediaItemInProcessing: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
+        onMutatingProcessedMediaItemResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageTransformationResult>;
+        onMutatedProcessedMediaItemResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageTransformationResult>;
+        onMutatingScaleProcessingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedScaleProcessingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatingSearchResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem[]>;
         onMutatedSearchResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem[]>;
         onMutatingSearchProvider: import("@omnia/fx").MessageBusExposeOnlySubscription<IMediaPickerSerchProvider>;
@@ -67,7 +65,6 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
     actions: {
         onDispatching<T extends (...args: any) => any>(action: (actions: {
             media: () => {
-                setSelectedProvider(id: GuidValue): void;
                 setFileProcessor(processor: IMediaFileProcessor): void;
                 onItemSelected(item: MediaItem): void;
                 onProcessMediaItem(): void;
@@ -87,7 +84,6 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
             media: () => {
-                setSelectedProvider(id: GuidValue): void;
                 setFileProcessor(processor: IMediaFileProcessor): void;
                 onItemSelected(item: MediaItem): void;
                 onProcessMediaItem(): void;
@@ -107,7 +103,6 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         onFailure<T_2 extends (...args: any) => any>(action: (actions: {
             media: () => {
-                setSelectedProvider(id: GuidValue): void;
                 setFileProcessor(processor: IMediaFileProcessor): void;
                 onItemSelected(item: MediaItem): void;
                 onProcessMediaItem(): void;
@@ -127,7 +122,6 @@ export declare const useMediaPickerProviderStore: (newInstanceWithName?: string)
         }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
     } & {
         media: () => {
-            setSelectedProvider(id: GuidValue): void;
             setFileProcessor(processor: IMediaFileProcessor): void;
             onItemSelected(item: MediaItem): void;
             onProcessMediaItem(): void;

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

@@ -0,0 +1,2 @@
+export * from "./MediaPickerEditorStore";
+export * from "./MediaPickerProviderStore";

package/internal-do-not-import-from-here/ux/mediapickerimage/IMediaPickerImage.d.ts

@@ -17,9 +17,16 @@ export interface IMediaPickerImage {
     * The scaling to use for the image
     * */
     scalingId?: number;
+    /**
+     * Specify if image is contain or cover
+     */
+    contain?: boolean;
     avatar?: {
         size: number;
     };
+    displayVSlot?: boolean;
+    containerClass?: string;
+    showCaption?: boolean;
 }
 declare global {
     namespace JSX {

package/internal-do-not-import-from-here/ux/mediapickerimage/MediaPickerImage.d.ts

@@ -13,7 +13,14 @@ export declare class MediaPickerImageComponent extends VueComponentBase<IMediaPi
     avatar?: {
         size: number;
     };
+    displayVSlot?: boolean;
+    contain: boolean;
+    containerClass?: string;
+    showCaption?: boolean;
+    imgClass: string;
     mediaPickerService: MediaPickerService;
+    private omniaUrl;
+    private isLoading;
     created(): void;
     mounted(): void;
     onImagedataChanged(imagejson: string): void;

package/internal-do-not-import-from-here/ux/mediapickerproviders/MicrosoftStream/MicrosoftStreamProvider.d.ts

@@ -5,9 +5,9 @@ import { MicrosoftStreamModel } from "../../../models";
 import { MicrosoftStreamProviderLocalization } from "./loc/localize";
 import { OmniaTheming } from "../..";
 import { IMicrosoftStreamProviderComponent } from "./IMicrosoftStreamProvider";
-import { MediaProviderComponentBase } from "../mediaproviderbase/MediaProviderComponentBase";
+import { MultiSelectMediaProviderComponentBase } from "../mediaproviderbase/MultiSelectMediaProviderComponentBase";
 import { SharePointContext } from "../../../sp";
-export declare class MicrosoftStreamProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, IMicrosoftStreamProviderComponent {
+export declare class MicrosoftStreamProviderComponent extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance, IMicrosoftStreamProviderComponent {
     loc: MicrosoftStreamProviderLocalization.locInterface;
     microsoftStreamService: MicrosoftStreamService;
     omniaTheming: OmniaTheming;
@@ -37,6 +37,7 @@ export declare class MicrosoftStreamProviderComponent extends MediaProviderCompo
     constructor();
     created(): void;
     mounted(): void;
+    private updateVideoState;
     private saveMSStreamResult;
     private initVideoDataAndGoToNextStep;
     private onVideoUrlChanged;

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

@@ -4,7 +4,7 @@ export declare module MicrosoftStreamProviderLocalization {
         Title: string;
         EditSettingsTitle: string;
         FeatureTitle: string;
-        FeatureDescription: string;
+        New7FeatureDescription: string;
         Labels: {
             ChooseVideo: string;
             VideoUrl: string;
@@ -14,6 +14,7 @@ export declare module MicrosoftStreamProviderLocalization {
             AutoPlay: string;
             Responsive: string;
             ShowInfo: string;
+            VideoInformation: string;
         };
         Message: {
             InvalidInputStartTime: string;

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

@@ -2,8 +2,8 @@ import { IWebComponentInstance } from "../../../";
 import { YouTubeProviderLocalization } from "./loc/localize";
 import { OmniaTheming } from "../..";
 import { IYouTubeProvider } from "./IYouTubeProvider";
-import { MediaProviderComponentBase } from "../mediaproviderbase/MediaProviderComponentBase";
-export declare class YouTubeProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, IYouTubeProvider {
+import { MultiSelectMediaProviderComponentBase } from "../mediaproviderbase/MultiSelectMediaProviderComponentBase";
+export declare class YouTubeProviderComponent extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance, IYouTubeProvider {
     loc: YouTubeProviderLocalization.locInterface;
     omniaTheming: OmniaTheming;
     private videoProviderResult;
@@ -17,6 +17,7 @@ export declare class YouTubeProviderComponent extends MediaProviderComponentBase
     private enableStartTime;
     private omniaUrl;
     private validateMessage;
+    private caption;
     private rules;
     $refs: {
         startTime: any;
@@ -44,6 +45,7 @@ export declare class YouTubeProviderComponent extends MediaProviderComponentBase
     private getParameterByName;
     private getStartTimeAsSeconds;
     private processResponsiveIframe;
+    private updateVideoState;
     private saveYoutubeResult;
     private renderVideoIframe;
     private renderResponsiveVideoIframe;

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

@@ -4,7 +4,7 @@ export declare module YouTubeProviderLocalization {
         Title: string;
         EditSettingsTitle: string;
         FeatureTitle: string;
-        FeatureDescription: string;
+        New7FeatureDescription: string;
         Labels: {
             ChooseVideo: string;
             VideoUrl: string;
@@ -17,6 +17,7 @@ export declare module YouTubeProviderLocalization {
             Mute: string;
             Responsive: string;
             ShowInfo: string;
+            VideoInformation: string;
         };
         Message: {
             InvalidInputStartTime: string;

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

@@ -4,7 +4,7 @@ export declare module BingProviderLocalization {
         Title: string;
         TransformComponentTitle: string;
         FeatureTitle: string;
-        FeatureDescription: string;
+        New7FeatureDescription: string;
         SearchboxPlaceholder: string;
         More: string;
         PredefinedSearch: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/DallEProvider.css.d.ts

@@ -1,3 +1,5 @@
+import { types } from "typestyle";
+import { ITheming } from "@omnia/fx/ux";
 export declare const imageSize = 357.25;
 export declare const DallEProviderStyles: {
     wrapper: string;
@@ -14,6 +16,19 @@ export declare const DallEProviderStyles: {
     DallEFilterContentErrorWrapper: string;
     ErrorIcon: string;
     promptTip: string;
+    FullHeight: string;
+};
+export declare const dallEImageGridStyles: {
+    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;

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/DallEProvider.d.ts

@@ -1,12 +1,13 @@
 import { OmniaTheming } from "@omnia/fx/ux";
-import { IWebComponentInstance } from "@omnia/fx";
+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 } from "../../../models";
+import { ImageInformation, VideoItem, ImageItem, MediaPickerVideo, VideoInformation, MediaPickerImageTransformationResult, IBusinessProfile } from "../../../models";
 import { AzureOpenAIService } from "../../../services";
 import { DallEProviderLocalization } from "./loc/localize";
 import { TextToImageRequest, GeneratedImage, TextToImageResponse } from "@omnia/fx-models";
 import "./DallEProvider.css";
+import { MultilingualStore } from "@omnia/fx/stores";
 export default class DallEProvider extends GridViewMediaProviderComponent implements IWebComponentInstance {
     beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
     getMediaItems(searchKeyword: string): Promise<GeneratedImage[]>;
@@ -15,6 +16,9 @@ export default class DallEProvider extends GridViewMediaProviderComponent implem
     setEmptyResultHandler(): void;
     azureOpenAiService: AzureOpenAIService;
     omniaTheming: OmniaTheming;
+    private aiSettingsService;
+    omniaCtx: OmniaContext;
+    multilingualStore: MultilingualStore;
     dallELoc: DallEProviderLocalization.locInterface;
     omniaUxLoc: OmniaUxLocalization;
     private searchKeyword;
@@ -24,17 +28,26 @@ export default class DallEProvider extends GridViewMediaProviderComponent implem
     private resultStyles;
     private selectedImageResolution;
     private textToImageResponseMap;
+    private dallEPredefinedPromptList;
+    private preDefinedPrompt;
+    private preDefaultPrompt;
+    private dallEConstant;
+    private displayPrompts;
     private getTextToImageRequest;
     constructor();
     created(): void;
     mounted(): void;
+    initDallEPromptSettingsListing(businessProfileId: IBusinessProfile): Promise<void>;
     onGenerateImage(): void;
     onPressEnter: (event: KeyboardEvent) => void;
+    getPredefinedPrompts(predefinedPrompt: string): void;
     selectGridItemPublic(item: GeneratedImage): void;
     addGeneratedImage(item: GeneratedImage, textToImageRequest: TextToImageRequest): void;
     addTextToImageResponse(item: TextToImageResponse, textToImageRequest: TextToImageRequest): void;
     onRegenerateImage(textToImageRequest: TextToImageRequest): void;
     private renderCustomSlot;
+    private getPredefinedPromptsItem;
+    private renderPredefinedPrompts;
     private renderPromptInput;
     render(): JSX.Element;
 }

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

@@ -55,6 +55,8 @@ declare const _default: {
             readonly onRegenerateImage?: (textToImageRequest: TextToImageRequest) => void;
             readonly textToImageResponse?: TextToImageResponse;
             readonly addTextToImageResponse?: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+            readonly imageRef?: HTMLImageElement;
+            readonly setImageRef?: (imageRef: HTMLImageElement) => void;
         };
         $attrs: {
             [x: string]: unknown;
@@ -77,6 +79,8 @@ declare const _default: {
             onRegenerateImage: import("vue").Prop<(textToImageRequest: TextToImageRequest) => void, (textToImageRequest: TextToImageRequest) => void>;
             textToImageResponse: import("vue").Prop<TextToImageResponse, TextToImageResponse>;
             addTextToImageResponse: import("vue").Prop<(textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void, (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void>;
+            imageRef: import("vue").Prop<HTMLImageElement, HTMLImageElement>;
+            setImageRef: import("vue").Prop<(imageRef: HTMLImageElement) => void, (imageRef: HTMLImageElement) => void>;
         }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -105,6 +109,8 @@ declare const _default: {
         onRegenerateImage: import("vue").Prop<(textToImageRequest: TextToImageRequest) => void, (textToImageRequest: TextToImageRequest) => void>;
         textToImageResponse: import("vue").Prop<TextToImageResponse, TextToImageResponse>;
         addTextToImageResponse: import("vue").Prop<(textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void, (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void>;
+        imageRef: import("vue").Prop<HTMLImageElement, HTMLImageElement>;
+        setImageRef: import("vue").Prop<(imageRef: HTMLImageElement) => void, (imageRef: HTMLImageElement) => void>;
     }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
@@ -117,6 +123,8 @@ declare const _default: {
     onRegenerateImage: import("vue").Prop<(textToImageRequest: TextToImageRequest) => void, (textToImageRequest: TextToImageRequest) => void>;
     textToImageResponse: import("vue").Prop<TextToImageResponse, TextToImageResponse>;
     addTextToImageResponse: import("vue").Prop<(textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void, (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void>;
+    imageRef: import("vue").Prop<HTMLImageElement, HTMLImageElement>;
+    setImageRef: import("vue").Prop<(imageRef: HTMLImageElement) => void, (imageRef: HTMLImageElement) => void>;
 }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
         textToImageRequest?: TextToImageRequest;
@@ -126,6 +134,8 @@ declare const _default: {
         onRegenerateImage?: (textToImageRequest: TextToImageRequest) => void;
         textToImageResponse?: TextToImageResponse;
         addTextToImageResponse?: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+        imageRef?: HTMLImageElement;
+        setImageRef?: (imageRef: HTMLImageElement) => void;
     }>, never>;
 };
 export default _default;

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

@@ -18,5 +18,6 @@ export declare module DallEProviderLocalization {
         PromptContent: string;
         PromptExample: string;
         Label: string;
+        ImageStyle: string;
     }
 }

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

@@ -0,0 +1,46 @@
+import { IWebComponentInstance } from "@omnia/fx";
+import { MultiSelectMediaProviderComponentBase } from "@omnia/fx/ux";
+import { ImageInformation, MediaFlowImage, MediaPickerImageTransformationResult, MediaPickerVideo, MediaflowEventData, MediaflowInformation, VideoInformation } from "@omnia/fx-models";
+import { MediaflowService } from "./service/MediaflowService";
+import { MediaflowProviderStore } from "./store/MediaflowProviderStore";
+import "./MediaflowProviderStyles.css";
+declare interface MediaflowImageInformation extends ImageInformation, MediaflowInformation {
+    folderId: number;
+}
+export declare class MediaflowProvider extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance {
+    mediaflowStore: MediaflowProviderStore;
+    mediaflowService: MediaflowService;
+    private loc;
+    private loadedMediaFlowJS;
+    private loadedMediaFlowCSS;
+    private containerIsSetup;
+    private isTransformImage;
+    private settings;
+    private authenticationInfo;
+    private settingsLoaded;
+    private static mediaflowClientScriptId;
+    private lastSelectedFolderId;
+    private get mediaflowLoaded();
+    private mediafileSelector;
+    private mediaflowRefElement;
+    constructor();
+    created(): void;
+    loadMediaflowClient(): void;
+    loadScript(url: any): Promise<any>;
+    mounted(): void;
+    updated(): void;
+    private makeMediaflowUIFullScreen;
+    onContainerIsSetupChanged(): void;
+    beforeDestroy(): void;
+    beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
+    private getLocale;
+    private setupMediaContainer;
+    handleMediaflowEvent(eventName: string, eventData: MediaflowEventData): void;
+    saveMediaflowMedia(): void;
+    handleImageSelection(source: any): void;
+    fixEmbedHtmlForTextArea(htmlString: string): string;
+    downloadImage(source: MediaFlowImage): Promise<MediaflowImageInformation>;
+    render(): JSX.Element;
+    renderMediaflowContainer(): JSX.Element;
+}
+export {};

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/MediaflowProviderStyles.css.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Styles for the MediaflowProvider component
+ */
+export declare const MediaflowProviderStyles: {
+    sampleStyle: string;
+};
+export declare const overwriteStyles: {
+    cssRaw: void;
+};

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

@@ -0,0 +1,25 @@
+export declare module MediaflowLocalization {
+    const namespace = "Omnia.Ux.MediaflowProvider";
+    interface locInterface {
+        Settings: {
+            MainHeader: string;
+            AuthenticationSectionHeader: string;
+            MediaSectionHeader: string;
+            ClientIdHeader: string;
+            ClientSecretHeader: string;
+            RefreshtokenHeader: string;
+            DefaultLanguageHeader: string;
+            ShowUnsafeGDPRHeader: string;
+            ShowUnassignedGDPRHeader: string;
+            LimitFormatHeader: string;
+            SaveButton: string;
+        };
+        Features: {
+            MediaflowFeature: string;
+            Description: string;
+        };
+        Mediapicker: {
+            IframeMsg: string;
+        };
+    }
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/service/MediaflowService.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from "@omnia/fx";
+import { MediaflowVideoInfo } from "@omnia/fx-models";
+export declare class MediaflowService {
+    protected httpClient: HttpClient;
+    private baseUrl;
+    getVideoInfo: (mediaId: string) => Promise<MediaflowVideoInfo>;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/store/MediaflowProviderStore.d.ts

@@ -0,0 +1,29 @@
+import { Store } from "@omnia/fx/stores";
+import { OmniaContext } from "@omnia/fx";
+import { MediaflowAuthenticationInfo, MediaflowSettings } from "@omnia/fx-models";
+import { SettingsService, SecretsService } from "@omnia/fx/services";
+export declare class MediaflowProviderStore extends Store {
+    settingService: SettingsService<MediaflowSettings>;
+    secretService: SecretsService;
+    omniaContext: OmniaContext;
+    private settings;
+    private authenticationInfo;
+    private mediaflowSecretKey;
+    private mediaflowSettingKey;
+    constructor();
+    getters: {
+        getSettings: () => MediaflowSettings;
+        getAuthenticationInfo: () => MediaflowAuthenticationInfo;
+    };
+    actions: {
+        loadSettings: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: any) => void, (failureReason: any) => void, () => Promise<any>>;
+        loadAuthenticationInfo: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    mutations: {
+        setSetting: import("@omnia/fx/stores").StoreMutation<(item: MediaflowSettings) => void, (item: MediaflowSettings) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setAuthenticationInfo: import("@omnia/fx/stores").StoreMutation<(item: MediaflowAuthenticationInfo) => void, (item: MediaflowAuthenticationInfo) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    private extractAuthenticationInfoFromSecret;
+}