@omnia/fx 8.0.119-dev → 8.0.121-dev

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

@@ -0,0 +1,190 @@
+import { ImageMetaData, MediaGallery, MediaPickerMediaItem, MediaState } from "./types";
+import { IMediaPickerGalleryHandler } from "../interfaces";
+import { GuidValue, MediaPickerImageTransformationResult } from "@omnia/fx-models";
+export declare const GalleryStore: () => {
+    state: {
+        selectedMediaGallery: MediaGallery;
+        editingMediaIndex: number;
+        editingMediaId: GuidValue;
+        preSelectedImageMetaData: ImageMetaData;
+        mediaStates: MediaState[];
+        finishItemCount: number;
+        enableGallery: boolean;
+        enableMediaCaption: boolean;
+        galleryItemLimit: number;
+        enableTransformation: boolean;
+        showMediaGallerySelector: boolean;
+        imgThatNeedToConvertFromBase64ToMediaPicker: {
+            [imageId: string]: boolean;
+        };
+    };
+    actions: {
+        onDispatching: {
+            resetState: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setup: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addOrUpdateItem: {
+                subscribe(fn: (mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateImageTransformed: {
+                subscribe(fn: (transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeItem: {
+                subscribe(fn: (index: number) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            save: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setSelectedMedia: {
+                subscribe(fn: (index: number, galleryHandler: IMediaPickerGalleryHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleGallerySelector: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deSelectItem: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithProvider: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithTransformer: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            resetState: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setup: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addOrUpdateItem: {
+                subscribe(fn: (result: void, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateImageTransformed: {
+                subscribe(fn: (result: void, transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeItem: {
+                subscribe(fn: (result: void, index: number) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            save: {
+                subscribe(fn: (result: MediaPickerMediaItem[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setSelectedMedia: {
+                subscribe(fn: (result: void, index: number, galleryHandler: IMediaPickerGalleryHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleGallerySelector: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deSelectItem: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithProvider: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithTransformer: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            resetState: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setup: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addOrUpdateItem: {
+                subscribe(fn: (failureReason: any, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateImageTransformed: {
+                subscribe(fn: (failureReason: any, transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            removeItem: {
+                subscribe(fn: (failureReason: any, index: number) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            save: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setSelectedMedia: {
+                subscribe(fn: (failureReason: any, index: number, galleryHandler: IMediaPickerGalleryHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleGallerySelector: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deSelectItem: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithProvider: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderGallerySelectorWithTransformer: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        resetState(): void;
+        setup(): Promise<void>;
+        /**
+         * Add item to the gallery, for the video this is used directly in the provider
+         * @param item the item to be added to the gallery, this can be a video or an image
+         * @param id The id of the media state
+         */
+        addOrUpdateItem(mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue): void;
+        /**
+         * @description this is the method that gets called from the image transformer
+         * @param transformation the transformation result from the image transformer
+         */
+        updateImageTransformed(transformation: MediaPickerImageTransformationResult): void;
+        removeItem(index: number): void;
+        save(): Promise<MediaPickerMediaItem[]>;
+        setSelectedMedia(index: number, galleryHandler: IMediaPickerGalleryHandler): void;
+        toggleGallerySelector(show: boolean): void;
+        deSelectItem(): void;
+        renderGallerySelectorWithProvider(): void;
+        renderGallerySelectorWithTransformer(): void;
+    };
+    events: {
+        onMutatedSelectedMediaGallery: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaGallery>;
+        onMutatedEditingMediaIndex: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+        onMutatedEditingMediaId: import("@omnia/fx").MessageBusExposeOnlySubscription<GuidValue>;
+        onMutatedPreSelectedImageMetaData: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageMetaData>;
+        onMutatedMediaStates: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaState[]>;
+        onMutatedFinishItemCount: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+        onMutatedEnableGallery: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedEnableMediaCaption: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedGalleryItemLimit: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+        onMutatedEnableTransformation: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowMediaGallerySelector: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedImgThatNeedToConvertFromBase64ToMediaPicker: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            [imageId: string]: boolean;
+        }>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    mutate: {
+        selectedMediaGallery: (value: MediaGallery | ((prev: MediaGallery) => MediaGallery)) => void;
+        editingMediaIndex: (value: number | ((prev: number) => number)) => void;
+        editingMediaId: (value: GuidValue | ((prev: GuidValue) => GuidValue)) => void;
+        preSelectedImageMetaData: (value: ImageMetaData | ((prev: ImageMetaData) => ImageMetaData)) => void;
+        mediaStates: (value: MediaState[] | ((prev: MediaState[]) => MediaState[])) => void;
+        finishItemCount: (value: number | ((prev: number) => number)) => void;
+        enableGallery: (value: boolean | ((prev: boolean) => boolean)) => void;
+        enableMediaCaption: (value: boolean | ((prev: boolean) => boolean)) => void;
+        galleryItemLimit: (value: number | ((prev: number) => number)) => void;
+        enableTransformation: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showMediaGallerySelector: (value: boolean | ((prev: boolean) => boolean)) => void;
+        imgThatNeedToConvertFromBase64ToMediaPicker: (value: {
+            [imageId: string]: boolean;
+        } | ((prev: {
+            [imageId: string]: boolean;
+        }) => {
+            [imageId: string]: boolean;
+        })) => void;
+    };
+    get: {
+        hasMediaEditing: () => boolean;
+        hasMediaToEdit: () => boolean;
+        isNotEditing: () => boolean;
+    };
+};

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

@@ -0,0 +1,241 @@
+import { GuidValue, ImageInformation, ImageItem, MediaItem, MediaPickerBase64Image, MediaPickerImageScaling, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, VideoInformation, VideoItem } from "@omnia/fx-models";
+import { IMediaPickerProviderHandler } from "../interfaces/IMediaPickerProviderMediaHandler";
+import { MediaPickerMessage } from "./types";
+import { BaseProviderImageHandler } from "../handlers";
+export declare const ProviderStore: () => {
+    state: {
+        showImageTransformer: boolean;
+        showWarningDialog: boolean;
+        showProviderSelector: boolean;
+        renderProviderElement: boolean;
+        showSelectFileSize: boolean;
+        showErrorScalingImage: boolean;
+        showErrorDownloadingImage: boolean;
+        showFileTypeNotSupported: boolean;
+        scaleProcessingImage: boolean;
+        renderProvider: boolean;
+        searchResults: MediaItem[];
+        searchQueryText: string;
+        maxAllowedFileSize: MediaPickerLimitedSizeSettings;
+        selectedFileScalingOption: MediaPickerImageScaling;
+        registeredProviders: MediaPickerProvider[];
+        activeProvider: MediaPickerProvider;
+        selectedMediaInfo: MediaPickerBase64Image | ImageInformation | VideoInformation;
+        selectedMediaItem: ImageItem | VideoItem;
+        selectedMedia: MediaPickerMedia;
+        statusMessage: MediaPickerMessage;
+    };
+    actions: {
+        onDispatching: {
+            resetState: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectMedia: {
+                subscribe(fn: (media: MediaItem, mediaProviderHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderSelector: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showImageScalingDialog: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showErrorScaling: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderRenderer: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectProvider: {
+                subscribe(fn: (provider: MediaPickerProvider) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            search: {
+                subscribe(fn: (providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            searchMore: {
+                subscribe(fn: (providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            message: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureProviderSelected: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderProviderSelectorWithProvider: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            handleResizeImage: {
+                subscribe(fn: (imageHandler: BaseProviderImageHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            onCancelSelectedImageProcess: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            resetState: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectMedia: {
+                subscribe(fn: (result: void, media: MediaItem, mediaProviderHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderSelector: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showImageScalingDialog: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showErrorScaling: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderRenderer: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectProvider: {
+                subscribe(fn: (result: void, provider: MediaPickerProvider) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            search: {
+                subscribe(fn: (result: void, providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            searchMore: {
+                subscribe(fn: (result: MediaItem[], providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            message: {
+                subscribe(fn: (result: {
+                    show(message: MediaPickerMessage): void;
+                    clear: () => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureProviderSelected: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderProviderSelectorWithProvider: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            handleResizeImage: {
+                subscribe(fn: (result: void, imageHandler: BaseProviderImageHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            onCancelSelectedImageProcess: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            resetState: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectMedia: {
+                subscribe(fn: (failureReason: any, media: MediaItem, mediaProviderHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderSelector: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showImageScalingDialog: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showErrorScaling: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleProviderRenderer: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            selectProvider: {
+                subscribe(fn: (failureReason: any, provider: MediaPickerProvider) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            search: {
+                subscribe(fn: (failureReason: any, providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            searchMore: {
+                subscribe(fn: (failureReason: any, providerHandler: IMediaPickerProviderHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            message: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureProviderSelected: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            renderProviderSelectorWithProvider: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            handleResizeImage: {
+                subscribe(fn: (failureReason: any, imageHandler: BaseProviderImageHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            onCancelSelectedImageProcess: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        resetState(): void;
+        selectMedia(media: MediaItem, mediaProviderHandler: IMediaPickerProviderHandler): void;
+        toggleProviderSelector(show: boolean): void;
+        showImageScalingDialog(): void;
+        showErrorScaling(): void;
+        toggleProviderRenderer(show: boolean): void;
+        selectProvider(provider: MediaPickerProvider): void;
+        search(providerHandler: IMediaPickerProviderHandler): Promise<void>;
+        searchMore(providerHandler: IMediaPickerProviderHandler): Promise<MediaItem[]>;
+        message(): {
+            show(message: MediaPickerMessage): void;
+            clear: () => void;
+        };
+        ensureProviderSelected(): void;
+        renderProviderSelectorWithProvider(): void;
+        handleResizeImage(imageHandler: BaseProviderImageHandler): void;
+        onCancelSelectedImageProcess(): void;
+    };
+    events: {
+        onMutatedShowImageTransformer: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowWarningDialog: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowProviderSelector: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedRenderProviderElement: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowSelectFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowErrorScalingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowErrorDownloadingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowFileTypeNotSupported: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedScaleProcessingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedRenderProvider: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedSearchResults: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem[]>;
+        onMutatedSearchQueryText: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+        onMutatedMaxAllowedFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerLimitedSizeSettings>;
+        onMutatedSelectedFileScalingOption: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageScaling>;
+        onMutatedRegisteredProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerProvider[]>;
+        onMutatedActiveProvider: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerProvider>;
+        onMutatedSelectedMediaInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerBase64Image | ImageInformation | VideoInformation>;
+        onMutatedSelectedMediaItem: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageItem | VideoItem>;
+        onMutatedSelectedMedia: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerMedia>;
+        onMutatedStatusMessage: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerMessage>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    mutate: {
+        showImageTransformer: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showWarningDialog: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showProviderSelector: (value: boolean | ((prev: boolean) => boolean)) => void;
+        renderProviderElement: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showSelectFileSize: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showErrorScalingImage: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showErrorDownloadingImage: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showFileTypeNotSupported: (value: boolean | ((prev: boolean) => boolean)) => void;
+        scaleProcessingImage: (value: boolean | ((prev: boolean) => boolean)) => void;
+        renderProvider: (value: boolean | ((prev: boolean) => boolean)) => void;
+        searchResults: (value: MediaItem[] | ((prev: MediaItem[]) => MediaItem[])) => void;
+        searchQueryText: (value: string | ((prev: string) => string)) => void;
+        maxAllowedFileSize: (value: MediaPickerLimitedSizeSettings | ((prev: MediaPickerLimitedSizeSettings) => MediaPickerLimitedSizeSettings)) => void;
+        selectedFileScalingOption: (value: MediaPickerImageScaling | ((prev: MediaPickerImageScaling) => MediaPickerImageScaling)) => void;
+        registeredProviders: (value: MediaPickerProvider[] | ((prev: MediaPickerProvider[]) => MediaPickerProvider[])) => void;
+        activeProvider: (value: MediaPickerProvider | ((prev: MediaPickerProvider) => MediaPickerProvider)) => void;
+        selectedMediaInfo: (value: MediaPickerBase64Image | ImageInformation | VideoInformation | ((prev: MediaPickerBase64Image | ImageInformation | VideoInformation) => MediaPickerBase64Image | ImageInformation | VideoInformation)) => void;
+        selectedMediaItem: (value: ImageItem | VideoItem | ((prev: ImageItem | VideoItem) => ImageItem | VideoItem)) => void;
+        selectedMedia: (value: MediaPickerMedia | ((prev: MediaPickerMedia) => MediaPickerMedia)) => void;
+        statusMessage: (value: MediaPickerMessage | ((prev: MediaPickerMessage) => MediaPickerMessage)) => void;
+    };
+    get: {
+        providerById(id: GuidValue): MediaPickerProvider;
+        activeProvider(): {
+            id: GuidValue;
+            category: string;
+            name: string;
+            icon: import("@omnia/fx-models").IIcon;
+            hasEditorForMedia(media: import("@omnia/fx-models").MediaPickerVideo | import("@omnia/fx-models").MediaPickerPersistedImage): boolean;
+            sortOrder?: number;
+            selectableMediaTypes: import("@omnia/fx-models").MediaPickerEnums.OmniaMediaTypes[];
+            providerComponentManifestId: GuidValue;
+            supportGalleryFeature: boolean;
+        };
+    };
+};

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

@@ -0,0 +1,2 @@
+import { GuidValue } from "@omnia/fx-models";
+export declare const KEEP_ORIGINAL_SIZE_OPTION_VALUE: GuidValue;

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

@@ -1,3 +1,5 @@
-export * from "./MediaPickerEditorStore";
-export * from "./MediaPickerProviderStore";
-export * from "./MediaGalleryStore";
+export * from "./constants";
+export * from "./types";
+export * from "./ProviderStore";
+export * from "./MediaPickerGalleryStore";
+export * from "./MediaPickerCommonStore";

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

@@ -0,0 +1,55 @@
+import { GuidValue, IIcon, MediaPickerImage, MediaPickerImageTransformationResult, MediaPickerMedia, MediaPickerProvider, MediaPickerRenditionData, MediaPickerTransformedBase64Image, MediaPickerVideo } from "@omnia/fx-models";
+import { ProviderStore } from "./ProviderStore";
+import { GalleryStore } from "./MediaPickerGalleryStore";
+import { MediaPickerCommonStore } from "./MediaPickerCommonStore";
+export type MediaPickerMediaItem = MediaPickerImage | MediaPickerVideo | MediaPickerMedia;
+export type MediaGallery = Array<MediaPickerMediaItem>;
+export type ImageMetaData = {
+    [imageId: string]: {
+        renditions: Array<MediaPickerRenditionData>;
+        imageTransformationSource: MediaPickerTransformedBase64Image;
+    };
+};
+export type MediaPickerActionButton = {
+    text: string;
+    show: boolean;
+    onClick: any;
+    icon?: string;
+    iconLeft?: boolean;
+    loading?: boolean;
+    highLighted?: boolean;
+    leftAligned?: boolean;
+};
+export type MediaState = {
+    id: GuidValue;
+    isVideo: boolean;
+    isChanged: boolean;
+    media?: MediaPickerMediaItem;
+    transformerInfo?: MediaPickerImageTransformationResult;
+    isNew: boolean;
+    convertingFromBase64ToMediaPicker: boolean;
+    provider?: MediaPickerProvider;
+    index?: number;
+};
+export type MenuItem = {
+    menuItemId: GuidValue;
+    title?: string;
+    icon: IIcon;
+    connectedProvider: MediaPickerProvider;
+};
+export type MediaResult = {
+    index: number;
+    media: MediaPickerMediaItem;
+};
+export type MediaPickerMessage = {
+    message: string;
+    icon?: IIcon;
+};
+export type ImageRendition = {
+    mediaStateId: GuidValue;
+    mediaPickerRenditionData: MediaPickerRenditionData[];
+    sourceImage: MediaPickerTransformedBase64Image;
+};
+export type MediaPickerProviderStoreType = ReturnType<typeof ProviderStore>;
+export type MediaPickerGalleryStoreType = ReturnType<typeof GalleryStore>;
+export type MediaPickerCommonStoreType = ReturnType<typeof MediaPickerCommonStore>;

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

@@ -0,0 +1,48 @@
+import { MediaPickerVideo } from "@omnia/fx-models";
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        "pre-selected-media": {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+        preSelectedMedia: {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        "pre-selected-media": {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+        preSelectedMedia: {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        "pre-selected-media": {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+        preSelectedMedia: {
+            type: import("vue").PropType<MediaPickerVideo>;
+        };
+    }>>, () => JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    "pre-selected-media": {
+        type: import("vue").PropType<MediaPickerVideo>;
+    };
+    preSelectedMedia: {
+        type: import("vue").PropType<MediaPickerVideo>;
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        preSelectedMedia?: MediaPickerVideo;
+        "pre-selected-media"?: MediaPickerVideo;
+    }>, never>;
+};
+export default _default;