@omnia/fx 7.1.43-dev → 7.1.44-preview

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/apis/IInternalGalleryDisplayProvider.d.ts

@@ -0,0 +1,4 @@
+import { MediaGalleryDisplayProvider, IGalleryDisplayProvider } from "@omnia/fx-models";
+export interface IInternalGalleryDisplayProvider extends IGalleryDisplayProvider {
+    getAllProviders: () => MediaGalleryDisplayProvider[];
+}

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/apis/Registration.d.ts

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

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/apis/index.d.ts

@@ -0,0 +1 @@
+export * from "./IInternalGalleryDisplayProvider";

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/index.d.ts

@@ -0,0 +1 @@
+export * from "./apis";

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/PhotoWall.d.ts

@@ -0,0 +1,7 @@
+import { MediaDisplayProviderComponentProps } from "@omnia/fx-models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MediaDisplayProviderComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaDisplayProviderComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<MediaDisplayProviderComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaDisplayProviderComponentProps, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/CollageMetadata.d.ts

@@ -0,0 +1,5 @@
+import { PhotoWallDirection } from "internal/fx/models/media-gallery";
+export interface CollageMetadata {
+    borderRadius: string;
+    direction: PhotoWallDirection;
+}

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/NumberOfRemaining.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>;
+export default _default;
+export declare const NumberOfRemainingCss: {
+    container: string;
+};

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoCollage.d.ts

@@ -0,0 +1,15 @@
+import { CollageMetadata } from "./CollageMetadata";
+import { LayoutPhotoMap } from "@omnia/fx-models";
+export interface PhotoCollage extends CollageMetadata {
+    disabled: boolean;
+    width: string;
+    height: Array<string>;
+    layout: Array<number>;
+    layoutPhotoMaps: LayoutPhotoMap;
+    layoutNum: number;
+    remainingNum: number;
+    showNumOfRemainingPhotos: boolean;
+    photoGap: string;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<PhotoCollage, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoCollageWrapper.d.ts

@@ -0,0 +1,17 @@
+import { CollageMetadata } from "./CollageMetadata";
+import { PhotoWallMedia } from "@omnia/fx-models";
+interface PhotoCollageWrapper extends CollageMetadata {
+    disabled: boolean;
+    width: string;
+    height: Array<string>;
+    layout: Array<number>;
+    media: Array<PhotoWallMedia>;
+    showNumberOfRemainingPhotos: boolean;
+    gapSize: string;
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<PhotoCollageWrapper, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<PhotoCollageWrapper, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<PhotoCollageWrapper, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<PhotoCollageWrapper, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoGrid.d.ts

@@ -0,0 +1,10 @@
+import { CollageMetadata } from "./CollageMetadata";
+import { FlexDirection } from "@omnia/fx-models";
+export interface PhotoGrid extends CollageMetadata {
+    photoGridGap: string;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<PhotoGrid, never>, any, any, any>;
+export default _default;
+export declare const PhotoGridCss: {
+    container: (photoGridGap: string, direction: FlexDirection) => string;
+};

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoMask.d.ts

@@ -0,0 +1,8 @@
+export interface PhotoMask {
+    borderRadius: string;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<PhotoMask, never>, any, any, any>;
+export default _default;
+export declare const PhotoMaskCss: {
+    container: (borderRadius: string) => string;
+};

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoRow.d.ts

@@ -0,0 +1,7 @@
+import { CollageMetadata } from "./CollageMetadata";
+export interface PhotoRow extends CollageMetadata {
+    rowHeight: string;
+    photoGridGap: string;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<PhotoRow, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/PhotoThumb.d.ts

@@ -0,0 +1,10 @@
+export interface PhotoThumb {
+    thumb: string;
+    borderRadius: string;
+    isVideo: boolean;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<PhotoThumb, never>, any, any, any>;
+export default _default;
+export declare const PhotoThumnailCss: {
+    container: (backGroundImg: String, borderRadius: string) => string;
+};

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/RowPhotos.d.ts

@@ -0,0 +1,12 @@
+import { CollageMetadata } from "./CollageMetadata";
+import { PhotoWallMediaWithId } from "@omnia/fx-models";
+export interface RowPhotos extends CollageMetadata {
+    height: string;
+    photos: Array<PhotoWallMediaWithId>;
+    layoutNum: number;
+    remainingNum: number;
+    showNumOfRemainingPhotos: boolean;
+    photoGap: string;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<RowPhotos, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/ViewMore.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>;
+export default _default;
+export declare const ViewMoreCss: {
+    container: string;
+};

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/loc/localize.d.ts

@@ -0,0 +1,6 @@
+export declare module PhotoWallLocalization {
+    const namespace = "Omnia.Fx.Media.Gallery.PhotoWall";
+    interface locInterface {
+        Title: string;
+    }
+}

package/internal-do-not-import-from-here/ux/mediagallery/view/GalleryViewDefault.d.ts

@@ -0,0 +1,12 @@
+import { MediaPickerMedia } from "@omnia/fx-models";
+export interface GalleryViewDefault {
+    media: Array<MediaPickerMedia>;
+    mediaData: string;
+    defaultVSlot: JSX.Element;
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<GalleryViewDefault, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<GalleryViewDefault, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<GalleryViewDefault, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<GalleryViewDefault, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/mediagallery/view/MediaView.d.ts

@@ -0,0 +1,11 @@
+import { MediaPickerMedia } from "@omnia/fx-models";
+export interface MediaViewDefault {
+    media: MediaPickerMedia | MediaPickerMedia[];
+    imageRatioId?: number;
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MediaViewDefault, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaViewDefault, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<MediaViewDefault, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaViewDefault, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/mediapicker/GalleryPanel.css.d.ts

@@ -0,0 +1,5 @@
+import { ITheming } from "../theming";
+export declare const GalleryPanelCss: {
+    deleteBtn: (theming: ITheming) => string;
+    activePanel: string;
+};

package/internal-do-not-import-from-here/ux/mediapicker/GalleryPanels.d.ts

@@ -0,0 +1,35 @@
+import { VueComponentBase } from "../VueComponentBase";
+import { IWebComponentInstance } from "internal/fx/runtime/core/InternalWebComponentBootstrapper";
+import { MediaPickerImage, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../models";
+import { MediaPickerService } from "@omnia/fx/services";
+export interface IGalleryPanels {
+    selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
+    selectEvent: (index: number) => void;
+    orderChange: (oldIndex: number, newIndex: number) => void;
+    removeItemEvent: (index: number) => void;
+    activeIndex: number;
+    addNewEvent: () => void;
+}
+export declare class GalleryPanels extends VueComponentBase<IGalleryPanels> implements IWebComponentInstance, IGalleryPanels {
+    selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
+    orderChange: (oldIndex: number, newIndex: number) => void;
+    selectEvent: (index: number) => void;
+    removeItemEvent: (index: number) => void;
+    activeIndex: number;
+    addNewEvent: () => void;
+    mediaPickerService: MediaPickerService;
+    private activeElement;
+    private omniaUrl;
+    created(): void;
+    updated(): void;
+    setActiveIndexIntoView(): void;
+    getMediaPickerImageTransformationResultImg(media: MediaPickerImageTransformationResult, index: number): VueTsxSupport.JSX.Element;
+    getVideoThumbnail(media: MediaPickerVideo, index: number): VueTsxSupport.JSX.Element;
+    getImgSource(media: MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo, index: number): VueTsxSupport.JSX.Element;
+    getMediaPickerImage(img: MediaPickerImage, index: number): VueTsxSupport.JSX.Element;
+    private resolveImageUrl;
+    renderMultiSelectPanel(media: Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>): VueTsxSupport.JSX.Element;
+    private onMediaSelect;
+    private onOrdinalChange;
+    render(): VueTsxSupport.JSX.Element;
+}

package/internal-do-not-import-from-here/ux/mediapicker/IMediaPicker.d.ts

@@ -2,7 +2,7 @@ import { MediaPickerMedia, MediaPickerImageSettings, MediaPickerStorageProviderC
 import { TsxAllowUnknowProperties } from "../";
 export interface IMediaPicker {
     /** Selected media */
-    selectedMedia?: MediaPickerMedia;
+    selectedMedia?: MediaPickerMedia | Array<MediaPickerMedia>;
     /** Indicate web application service ID and the needed properties to handle image */
     providerContext: MediaPickerStorageProviderContext;
     /** Image settings for picking images */
@@ -12,11 +12,14 @@ export interface IMediaPicker {
     /** Change provider order, remove provider, add custom provider*/
     providerConfiguration?: (providers: Array<MediaPickerProvider>) => Array<MediaPickerProvider>;
     /** The callback when image is saved completely or video result is created */
-    saved: (result: MediaPickerMedia) => void;
+    saved: (result: MediaPickerMedia | Array<MediaPickerMedia>) => void;
     /** The callback when close media picker */
     closed?: () => void;
     /** Render the picker in dialog */
     dialog?: boolean;
+    enableGallery?: boolean;
+    itemLimit?: number;
+    enableMediaCaption?: boolean;
 }
 declare global {
     namespace VueTsxSupport.JSX {

package/internal-do-not-import-from-here/ux/mediapicker/MediaPicker.css.d.ts

@@ -7,8 +7,9 @@ export declare const MediaPickerStyles: {
     providerWrapper: string;
     toolbarTitle: string;
     selectedProvider: (bgColor: string) => string;
-    navigationDrawer: string;
-    bodyWrapper: string;
+    multiPanelNavigationDrawer: (width: string) => string;
+    navigationDrawer: (width: any) => string;
+    bodyWrapper: (showGallery: boolean) => string;
     body: string;
     elementWrapper: string;
     loadingOverlay: string;

package/internal-do-not-import-from-here/ux/mediapicker/MediaPicker.d.ts

@@ -5,12 +5,15 @@ import { IMediaPicker } from "./IMediaPicker";
 export declare class MediaPicker extends VueComponentBase<IMediaPicker> implements IWebComponentInstance, IMediaPicker {
     selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
     providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
-    selectedMedia?: MediaPickerImage | MediaPickerVideo;
+    selectedMedia?: MediaPickerImage | MediaPickerVideo | Array<MediaPickerImage | MediaPickerVideo>;
     providerContext: MediaPickerStorageProviderContext;
     imageSettings?: MediaPickerImageSettings;
     saved: (result: MediaPickerMedia) => void;
     closed?: () => void;
     dialog: boolean;
+    enableGallery: boolean;
+    itemLimit: number;
+    enableMediaCaption?: boolean;
     mounted(): void;
     private renderRenderer;
     render(): VueTsxSupport.JSX.Element;

package/internal-do-not-import-from-here/ux/mediapicker/MediaPickerComponentProps.d.ts

@@ -16,6 +16,7 @@ export interface MediaPickerProviderComponentProps {
     selectableMediaTypes?: Array<MediaPickerEnums.OmniaMediaTypes>;
     /** Set the search keyword value and execute the onSearch method */
     setSearchKeyword: (value: string) => void;
+    onChanged: (state: any) => void;
 }
 export interface MediaPickerImageTransformerProps {
     sourceImage: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
@@ -26,4 +27,5 @@ export interface MediaPickerImageTransformerProps {
     options?: ImageTransformerOptions;
     nisse: any;
     testThis: any;
+    showCaption: boolean;
 }

package/internal-do-not-import-from-here/ux/mediapicker/MediaPickerRenderer.d.ts

@@ -1,7 +1,7 @@
 import { IMediaPicker } from "@omnia/fx/ux";
 import { OmniaContext } from "../../";
 import { SubscriptionHandler } from "../../core";
-import { MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo } from "../../models";
+import { GuidValue, MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerImageTransformationResult, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerRenditionData, MediaPickerStorageProviderContext, MediaPickerTransformedBase64Image, MediaPickerVideo } from "../../models";
 import { MediaPickerService, SettingsService } from "../../services";
 import { MediaPickerStore, MultilingualStore } from "../../stores";
 import { VueComponentBase, VueComponentBaseProps } from "../VueComponentBase";
@@ -19,11 +19,14 @@ declare interface MediaPickerActionButton {
 export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker & VueComponentBaseProps> {
     selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
     providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
-    selectedMedia?: MediaPickerImage | MediaPickerVideo;
+    selectedMedia?: Array<MediaPickerImage | MediaPickerVideo> | MediaPickerImage | MediaPickerVideo;
     providerContext: MediaPickerStorageProviderContext;
     imageSettings?: MediaPickerImageSettings;
-    saved: (result: MediaPickerMedia) => void;
+    saved: (result: MediaPickerMedia | Array<MediaPickerMedia>) => void;
     closed?: () => void;
+    enableGallery: boolean;
+    itemLimit: number;
+    enableMediaCaption?: boolean;
     protected settingsService: SettingsService<MediaPickerLimitedSizeSettings>;
     omniaContext: OmniaContext;
     multilingualStore: MultilingualStore;
@@ -39,8 +42,16 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     private activedProvider;
     private transformerElementName;
     private editingImageActionButtons;
-    private renditions;
     private convertingFromBase64ToMediaPicker;
+    private imgThatNeedToConvertFromBase64ToMediaPicker;
+    private selectedMediaGallery?;
+    private editingMediaIndex;
+    private editingMediaId;
+    private preSelectedImgMetada;
+    private mediaStates;
+    private cacheKey;
+    private galleryPanelRefreshKey;
+    private finishItemCount;
     isSearching: boolean;
     hasLoadedInfiniteScrollHandler: boolean;
     searchTimeout: any;
@@ -51,13 +62,19 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
         height: number;
     };
     static imageBankElementProvider: string;
-    private currentTransformerResult;
+    private transformerResults;
     private menuItems;
-    private selectedImageTransformationSource;
     private registeredProviders;
+    private readonly navigationDrawerWidth;
     created(): void;
+    private processMediaGallery;
+    private initMediaState;
+    private isMediaPickerVideo;
     private init;
+    private preloadImageMetadata;
     private processSelectedMediaInput;
+    private isPromise;
+    private handleMigrateMedia;
     private EnsureDefaultImageEditProviderIsSelected;
     private createMediaPickerImageFromUrl;
     onKeypress(event: any): void;
@@ -66,11 +83,23 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     onSearch(immediate?: boolean): void;
     private onEditingImageSaveButtonClick;
     private getFileNameFromBase64;
-    private updateImage;
     private onSelectMenuItem;
     private onChangedExistedImage;
     private getMediaProvider;
+    CurrentRendition(): [GuidValue, MediaPickerRenditionData[], MediaPickerTransformedBase64Image];
+    setActiveEditingMedia(index: number): void;
+    private onMediaOrderChange;
+    onEditingMediaIndexChange(): void;
+    private onMediaRemove;
+    private SaveAllMedia;
+    private updateMediaToServer;
+    private saveMediaToServer;
+    private onStateChange;
+    panelRef: import("vue").Ref<any>;
     renderMenuItems(): VueTsxSupport.JSX.Element[];
+    onNewMediaBtnClick(): void;
+    getData(): (MediaPickerImage | MediaPickerImageTransformationResult | MediaPickerVideo)[];
+    renderMultiSelectPanel(): VueTsxSupport.JSX.Element;
     renderLeftMenu(): VueTsxSupport.JSX.Element;
     renderActionButtons(buttons: Array<MediaPickerActionButton>): JSX.Element[];
     private renderEditImageForm;

package/internal-do-not-import-from-here/ux/mediapicker/core/Utils.d.ts

@@ -0,0 +1,5 @@
+export declare module Utils {
+    const nameof: <T>(name: keyof T) => keyof T;
+    function isImageTransformationResult(obj: any): boolean;
+    function isVideoMediaPicker(obj: any): boolean;
+}

package/internal-do-not-import-from-here/ux/mediapicker/core/index.d.ts

@@ -1 +1,2 @@
 export * from "./MediaPickerImageHandler";
+export * from "./Utils";

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

@@ -16,9 +16,14 @@ 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;
 }
 declare global {
     namespace VueTsxSupport.JSX {

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

@@ -13,7 +13,10 @@ export declare class MediaPickerImageComponent extends VueComponentBase<IMediaPi
     avatar?: {
         size: number;
     };
+    displayVSlot?: boolean;
+    contain: boolean;
     mediaPickerService: MediaPickerService;
+    private omniaUrl;
     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/PollingImageComponent.d.ts

@@ -7,6 +7,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
     onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
     textToImageResponse: TextToImageResponse;
     addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
 }, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
         textToImageRequest: TextToImageRequest;
@@ -16,6 +18,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
         onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
         textToImageResponse: TextToImageResponse;
         addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => 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: TextToImageRequest;
@@ -25,6 +29,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
     onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
     textToImageResponse: TextToImageResponse;
     addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
 }, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
         textToImageRequest: TextToImageRequest;
@@ -34,6 +40,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
         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/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(): VueTsxSupport.JSX.Element;
+    renderMediaflowContainer(): VueTsxSupport.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;
+};