@omnia/fx 8.0.111-vnext → 8.0.113-vnext

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/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./bingprovider";
 export * from "./mediaproviderbase";
 export * from "./apis";

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

@@ -0,0 +1,47 @@
+import { IWebComponentInstance, OmniaContext } from "@omnia/fx";
+import { MultiSelectMediaProviderComponentBase } from "@omnia/fx/ux";
+import { MediaPickerImageTransformationResult, MediaPickerVideo, VideoInformation } from "@omnia/fx-models";
+import { MediaflowService } from "./service/MediaflowService";
+import { MediaflowProviderStore } from "./store/MediaflowProviderStore";
+import "./MediaflowProviderStyles.css";
+import { MediaFlowImage, MediaFlowVideo, MediaflowEventData, MediaflowImageInformation, MediaflowVideoInfo } from "./models";
+export declare class MediaflowProvider extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance {
+    mediaflowStore: MediaflowProviderStore;
+    mediaflowService: MediaflowService;
+    omniaContext: OmniaContext;
+    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;
+    private omniaDns;
+    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>;
+    buildHtml: (videoSource: MediaFlowVideo, videoInfo: MediaflowVideoInfo) => string;
+    extractSrcFromIframeHtmlString(iframeHtml: string): string;
+    render(): JSX.Element;
+    renderMediaflowContainer(): JSX.Element;
+}

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/MediaflowVideoPlayer.d.ts

@@ -0,0 +1,101 @@
+import Vue from "vue";
+declare const _default: {
+    new (...args: any[]): {
+        $: Vue.ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            readonly video?: String;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: Vue.VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: Vue.VNode<Vue.RendererNode, Vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Vue.Slot<any>;
+        }>;
+        $root: Vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, Vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $parent: Vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, Vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: Vue.ComponentOptionsBase<Readonly<Vue.ExtractPropTypes<{
+            video: Vue.Prop<String, String>;
+        }>>, () => JSX.Element, {}, {}, {}, Vue.ComponentOptionsMixin, Vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: Vue.DebuggerEvent) => void) | ((e: Vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: Vue.DebuggerEvent) => void) | ((e: Vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: Vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, Vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: Vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, Vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof Vue.nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: Vue.WatchOptions<boolean>): Vue.WatchStopHandle;
+    } & Readonly<Vue.ExtractPropTypes<{
+        video: Vue.Prop<String, String>;
+    }>> & Vue.ShallowUnwrapRef<() => JSX.Element> & {} & Vue.ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & Vue.ComponentOptionsBase<Readonly<Vue.ExtractPropTypes<{
+    video: Vue.Prop<String, String>;
+}>>, () => JSX.Element, {}, {}, {}, Vue.ComponentOptionsMixin, Vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}> & Vue.VNodeProps & Vue.AllowedComponentProps & Vue.ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        video?: String;
+    }>, never>;
+};
+export default _default;

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/models/MediaflowEmbedMethods.d.ts

@@ -0,0 +1,4 @@
+export declare class EmbededMethod {
+    static IFrame: string;
+    static Javascript: string;
+}

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

@@ -0,0 +1,31 @@
+export declare class MediaflowBaseType {
+    static Image: string;
+    static Video: string;
+    static ExternalVideo: string;
+}
+export interface MediaflowInformation {
+    basetype?: string;
+    filename?: string;
+    filetype?: string;
+    id: number;
+    mediaId: string;
+}
+export interface MediaFlowImage extends MediaflowInformation {
+    height: number;
+    name: string;
+    photographer: string;
+    url: string;
+    width: number;
+}
+export interface MediaFlowVideo extends MediaflowInformation {
+    autoPlay: boolean;
+    embedCode: any;
+    embedMethod: string;
+    startTime: string;
+}
+export interface MediaflowEventData {
+    id: number;
+    name: string;
+    mediaId?: string;
+    isSearch?: boolean;
+}

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

@@ -0,0 +1,8 @@
+import { ImageInformation, MediaPickerVideo } from "@omnia/fx-models";
+import { MediaflowInformation } from "./MediaflowMedia";
+export interface MediaflowVideoResult extends MediaPickerVideo, MediaflowInformation {
+    folderId: number;
+}
+export interface MediaflowImageInformation extends ImageInformation, MediaflowInformation {
+    folderId: number;
+}

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

@@ -0,0 +1,27 @@
+export interface Hlss {
+    src: string;
+}
+export interface Mp4s {
+    size: number;
+    src: string;
+}
+export interface MediaflowVideoInfo {
+    id: number;
+    title: string;
+    type: string;
+    hls: boolean;
+    hlss: Hlss[];
+    mp4: boolean;
+    mp4s: Mp4s[];
+    sign: any[];
+    audioTracks: any[];
+    videoTracks: any[];
+    vp: boolean;
+    duration: number;
+    statsURL: string;
+    width: number;
+    height: number;
+    native: string;
+    subtitles: any[];
+    poster: string;
+}

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

@@ -0,0 +1,9 @@
+export interface MediaflowVideoPlayerProps {
+    embedMethod: string;
+    title: string;
+    poster: string;
+    id: number;
+    embedCode?: string;
+    iframeSrc?: string;
+    autoPlay: boolean;
+}

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

@@ -0,0 +1,5 @@
+export * from "./MediaflowMedia";
+export * from "./MediaflowResponse";
+export * from "./MediaflowVideoInfo";
+export * from "./MediaflowEmbedMethods";
+export * from "./MediaflowVideoPlayerProps";

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 "../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;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaproviderbase/GridViewMediaProviderComponent.d.ts

@@ -1,7 +1,7 @@
 import { IWebComponentInstance } from "../../../";
 import { MediaItem, ImageItem, VideoItem, ImageInformation, MediaPickerEnums, VideoInformation, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../../models";
-import { MediaProviderComponentBase } from "./MediaProviderComponentBase";
 import "./GridViewMediaProviderComponent.css";
+import { MultiSelectMediaProviderComponentBase } from "./MultiSelectMediaProviderComponentBase";
 export interface GridViewMediaProviderComponentProps {
 }
 export interface GridViewMediaProviderComponentSlots<MediaItemType extends MediaItem> {
@@ -11,7 +11,7 @@ export interface GridViewMediaProviderComponentSlots<MediaItemType extends Media
     mediaGridItemOverlay?: (item: MediaItemType) => JSX.Element;
     customSlot?: () => JSX.Element;
 }
-export declare abstract class GridViewMediaProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, GridViewMediaProviderComponentProps {
+export declare abstract class GridViewMediaProviderComponent extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance, GridViewMediaProviderComponentProps {
     /**
      * Get media items by search keyword
      * @param searchKeyword
@@ -52,6 +52,7 @@ export declare abstract class GridViewMediaProviderComponent extends MediaProvid
     protected setSearchStatus(status: MediaPickerEnums.MediaSearchStatus): void;
     private retryToGetSelectedImageInfo;
     private handleSelectedMediaItem;
+    onImageTransformResultChanged(transformationResult: MediaPickerImageTransformationResult): void;
     private getMediaItemChunks;
     private onGridViewSearch;
     private appendGridItems;

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaproviderbase/MediaProviderComponentBase.d.ts

@@ -5,8 +5,9 @@ import { MediaPickerProviderComponentProps } from "../../mediapicker";
 import { VueComponentBase } from "../../VueComponentBase";
 import { SettingsService, WebImageService, MediaPickerService } from "../../../services";
 import { MediaProviderBaseLocalization } from "./loc/localize";
-import { MediaPickerStore, MultilingualStore, useMediaPickerProviderStore } from "@omnia/fx/stores";
+import { MediaPickerStore, MultilingualStore } from "@omnia/fx/stores";
 import { useColorSchemaStore } from "../../theming-v2";
+import { useMediaPickerProviderStore } from "../../mediapickerV2/stores";
 export interface MediaProviderComponentBaseSlots {
     bottom?: () => JSX.Element | Array<JSX.Element>;
 }
@@ -19,6 +20,8 @@ export declare abstract class MediaProviderComponentBase extends VueComponentBas
     preSelectedMedia?: MediaPickerVideo;
     selectableMediaTypes?: Array<MediaPickerEnums.OmniaMediaTypes>;
     setSearchKeyword: (value: string) => void;
+    onChanged: (state: any) => void;
+    enableMediaCaption?: boolean;
     uxLoc: OmniaUxLocalization;
     mediaProviderBaseLoc: MediaProviderBaseLocalization.locInterface;
     colors: ReturnType<typeof useColorSchemaStore>;
@@ -52,7 +55,7 @@ export declare abstract class MediaProviderComponentBase extends VueComponentBas
     protected toggleLoadingUI(show: boolean, loadingStyle?: MediaPickerEnums.LoadingStyle): void;
     private setImageTransformInput;
     private getImageScalingSettingsKey;
-    private onImageTransformResultChanged;
+    protected onImageTransformResultChanged(transformationResult: MediaPickerImageTransformationResult): void;
     private ensureRemoveBase64Format;
     private addNewImage;
     private initLimitedSizeScalingSettings;

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaproviderbase/MultiSelectMediaProviderComponentBase.d.ts

@@ -0,0 +1,8 @@
+import { MediaPickerImageTransformationResult, MediaPickerVideo } from "@omnia/fx-models";
+import { MediaProviderComponentBase } from "./MediaProviderComponentBase";
+export declare abstract class MultiSelectMediaProviderComponentBase extends MediaProviderComponentBase {
+    saved: (result: any) => void;
+    protected save(resultToBeSaved: MediaPickerImageTransformationResult | MediaPickerVideo): void;
+    protected onImageTransformResultChanged(transformationResult: MediaPickerImageTransformationResult): void;
+    protected onVideoStateChange(video: MediaPickerVideo): void;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaproviderbase/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./MediaProviderComponentBase";
 export * from "./GridViewMediaProviderComponent";
+export * from "./MultiSelectMediaProviderComponentBase";

package/internal-do-not-import-from-here/ux/mediapickerproviders/mycomputerprovider/MyComputerProvider.d.ts

@@ -2,8 +2,8 @@ import { IWebComponentInstance } from "../../../";
 import { IMyComputerProviderComponent } from "./IMyComputerProvider";
 import { MyComputerProviderLocalization } from "./loc/localize";
 import { OmniaTheming } from "../../OmniaTheming";
-import { MediaProviderComponentBase } from "../mediaproviderbase/MediaProviderComponentBase";
-export declare class MyComputerProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, IMyComputerProviderComponent {
+import { MultiSelectMediaProviderComponentBase } from "../mediaproviderbase/MultiSelectMediaProviderComponentBase";
+export declare class MyComputerProviderComponent extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance, IMyComputerProviderComponent {
     omniaTheming: OmniaTheming;
     private subscriptionHandler;
     locMyComputerProvider: MyComputerProviderLocalization.locInterface;

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

@@ -3,7 +3,7 @@ export declare module MyComputerProviderLocalization {
     interface locInterface {
         Title: string;
         FeatureTitle: string;
-        FeatureDescription: string;
+        New7FeatureDescription: string;
         TransformComponentTitle: string;
         DownloadingFile: string;
         ErrorLoadingImage: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider/IPexelProvider.d.ts

@@ -1,17 +0,0 @@
-import { TsxAllowUnknowProperties, MediaPickerProviderComponentProps } from "../../";
-export interface IPexelProviderComponent extends MediaPickerProviderComponentProps {
-    [name: string]: any;
-}
-declare global {
-    namespace JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-media-picker-pexels-provider": TsxAllowUnknowProperties<IPexelProviderComponent>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider/PexelProvider.css.d.ts

@@ -1,5 +0,0 @@
-export declare const PexelProviderStyles: {
-    wrapper: string;
-    text: string;
-    notify: string;
-};

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider/PexelProvider.d.ts

@@ -1,28 +0,0 @@
-import { IWebComponentInstance } from "../../../";
-import { PexelProviderLocalization } from "./loc/localize";
-import "./PexelProvider.css";
-import { PexelImage } from "./models/PexelImage";
-import { PexelImageService } from "./services/PexelImageService";
-import { IPexelProviderComponent } from "./IPexelProvider";
-import { OmniaTheming } from "../../OmniaTheming";
-import { GridViewMediaProviderComponent } from "../mediaproviderbase/GridViewMediaProviderComponent";
-import { ImageInformation, VideoItem, ImageItem, MediaPickerVideo, VideoInformation, MediaPickerImageTransformationResult } from "../../../models";
-export declare class PexelProviderComponent extends GridViewMediaProviderComponent implements IWebComponentInstance, IPexelProviderComponent {
-    beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
-    getMediaItems(searchKeyword: string): Promise<PexelImage[]>;
-    getMoreMediaItems(lastLoadedIndex: number): Promise<PexelImage[]>;
-    getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
-    setEmptyResultHandler(): void;
-    pexelImageService: PexelImageService;
-    omniaTheming: OmniaTheming;
-    pexelLoc: PexelProviderLocalization.locInterface;
-    private pexelProviderStyles;
-    private searchKeyword;
-    private hasSearchResult;
-    constructor();
-    created(): void;
-    mounted(): void;
-    private renderPexelLink;
-    private renderImageDetail;
-    render(): JSX.Element;
-}

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

@@ -3,7 +3,7 @@ export declare module PexelProviderLocalization {
     interface locInterface {
         Title: string;
         FeatureTitle: string;
-        FeatureDescription: string;
+        New7FeatureDescription: string;
         DowloadImageFailed: string;
         PhotoBy: string;
         PhotosProviderBy: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider/models/PexelImage.d.ts

@@ -1,27 +0,0 @@
-import { ImageItem } from "../../../../models";
-interface PexelImageSource {
-    original: string;
-    large2x: string;
-    large: string;
-    medium: string;
-    small: string;
-    portrait: string;
-    landscape: string;
-    tiny: string;
-}
-export interface PexelServerImage {
-    id: number;
-    width: number;
-    height: number;
-    url: string;
-    photographer: string;
-    photographer_url: string;
-    photographer_id: number;
-    avg_color: string;
-    src: PexelImageSource;
-    liked: boolean;
-}
-export interface PexelImage extends ImageItem {
-    serverImage: PexelServerImage;
-}
-export {};

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider/services/PexelImageService.d.ts

@@ -1,7 +0,0 @@
-import { PexelImage } from "../models/PexelImage";
-export declare class PexelImageService {
-    private httpClient;
-    private commonHttpClient;
-    search: (keyword: string, offset?: number, limit?: number) => Promise<Array<PexelImage>>;
-    private getImages;
-}

package/internal-do-not-import-from-here/ux/mediapickerproviders/sharepointvideosettings/ISharePointVideoSettings.d.ts

@@ -3,6 +3,7 @@ import { TsxAllowUnknowProperties } from "../../";
 export interface ISharePointVideoSettingsComponent {
     selectedMedia: MediaPickerSharePointVideo;
     onMediaChange: (mediaPickerVideo: MediaPickerSharePointVideo) => void;
+    enableMediaCaption?: boolean;
 }
 declare global {
     namespace JSX {