@omnia/fx 8.0.110-vnext → 8.0.111-vnext

package/internal-do-not-import-from-here/shared/models/Bring.d.ts

@@ -14,6 +14,7 @@ export interface BringConfig {
     interceptors?: BringInterceptOptions;
     abortable?: boolean;
     credentials?: BringCredentials;
+    executeOnWorker?: boolean;
 }
 export interface BringResponse<TData> {
     data?: TData;

package/internal-do-not-import-from-here/shared/models/WorkerProxyFuncs.d.ts

@@ -1,8 +1,14 @@
+import { BringResponse } from "./Bring";
 import { Guid } from "./Guid";
 import { WorkerProxyFunction } from "./Workers";
 export declare const WorkerProxyFuncs: {
     ui: {
         loadManifests: WorkerProxyFunction<Guid[], Guid[]>;
     };
-    worker: {};
+    worker: {
+        httpRequest: WorkerProxyFunction<{
+            url: string;
+            reqInit: Omit<RequestInit, "window" | "signal">;
+        }, Promise<BringResponse<any>>>;
+    };
 };

package/internal-do-not-import-from-here/shared/models/WorkerProxyFuncs.js

@@ -10,5 +10,9 @@ exports.WorkerProxyFuncs = {
         }
     },
     //Ui to worker functions
-    worker: {}
+    worker: {
+        httpRequest: {
+            id: new Guid_1.Guid("c77c5845-4ceb-4fe2-939a-36de94be6f6b")
+        }
+    }
 };

package/internal-do-not-import-from-here/stores/MediaPickerProviderStore.d.ts

@@ -1,63 +1,149 @@
-import { GuidValue, MediaItem, MediaPickerProvider } from "@omnia/fx-models";
-import { MediaProviderComponentBase } from "@omnia/fx/ux";
-interface providerRegistrations {
+import { GuidValue, IIcon, IMediaFileProcessor, IMediaPickerSerchProvider, ImageInformation, MediaItem, MediaPickerImageScaling, MediaPickerLimitedSizeSettings, MediaPickerProvider } from "@omnia/fx-models";
+interface ProviderRegistration {
     id: GuidValue;
     active: boolean;
     provider: MediaPickerProvider;
 }
+interface StateMessage {
+    message: string;
+    icon?: IIcon;
+}
 export declare const useMediaPickerProviderStore: (newInstanceWithName?: string) => {
     state: {
-        providers: providerRegistrations[];
+        providers: ProviderRegistration[];
         searchQueryText: string;
         isSearching: boolean;
-        isLoadingMoreItems: boolean;
         showLoadingOverlay: boolean;
         showLoadingProgress: boolean;
+        showSelectFileSize: boolean;
+        showErrorScalingImage: boolean;
+        showErrorDownloadingImage: boolean;
+        showFileTypeNotSupported: boolean;
         selectedMediaItem: MediaItem;
-        activedProviderComponent: MediaProviderComponentBase;
+        selectedMediaItemInfo: ImageInformation;
+        searchResult: MediaItem[];
+        searchProvider: IMediaPickerSerchProvider;
+        statusMessage: StateMessage;
+        maxAllowedFileSize: MediaPickerLimitedSizeSettings;
+        selectedFileScalingOption: MediaPickerImageScaling;
+        fileProcessor: IMediaFileProcessor;
     };
     events: {
-        onMutatingProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<providerRegistrations[]>;
-        onMutatedProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<providerRegistrations[]>;
+        onMutatingProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<ProviderRegistration[]>;
+        onMutatedProviders: import("@omnia/fx").MessageBusExposeOnlySubscription<ProviderRegistration[]>;
         onMutatingSearchQueryText: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
         onMutatedSearchQueryText: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
         onMutatingIsSearching: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedIsSearching: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
-        onMutatingIsLoadingMoreItems: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
-        onMutatedIsLoadingMoreItems: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatingShowLoadingOverlay: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedShowLoadingOverlay: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatingShowLoadingProgress: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedShowLoadingProgress: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowSelectFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowSelectFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowErrorScalingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowErrorScalingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowErrorDownloadingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowErrorDownloadingImage: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatingShowFileTypeNotSupported: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowFileTypeNotSupported: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatingSelectedMediaItem: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem>;
         onMutatedSelectedMediaItem: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem>;
-        onMutatingActivedProviderComponent: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaProviderComponentBase>;
-        onMutatedActivedProviderComponent: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaProviderComponentBase>;
+        onMutatingSelectedMediaItemInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
+        onMutatedSelectedMediaItemInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageInformation>;
+        onMutatingSearchResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem[]>;
+        onMutatedSearchResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaItem[]>;
+        onMutatingSearchProvider: import("@omnia/fx").MessageBusExposeOnlySubscription<IMediaPickerSerchProvider>;
+        onMutatedSearchProvider: import("@omnia/fx").MessageBusExposeOnlySubscription<IMediaPickerSerchProvider>;
+        onMutatingStatusMessage: import("@omnia/fx").MessageBusExposeOnlySubscription<StateMessage>;
+        onMutatedStatusMessage: import("@omnia/fx").MessageBusExposeOnlySubscription<StateMessage>;
+        onMutatingMaxAllowedFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerLimitedSizeSettings>;
+        onMutatedMaxAllowedFileSize: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerLimitedSizeSettings>;
+        onMutatingSelectedFileScalingOption: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageScaling>;
+        onMutatedSelectedFileScalingOption: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageScaling>;
+        onMutatingFileProcessor: import("@omnia/fx").MessageBusExposeOnlySubscription<IMediaFileProcessor>;
+        onMutatedFileProcessor: import("@omnia/fx").MessageBusExposeOnlySubscription<IMediaFileProcessor>;
     } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
     actions: {
         onDispatching<T extends (...args: any) => any>(action: (actions: {
-            setSelectedProvider(id: GuidValue): void;
-            selectMediaItem(item: MediaItem): void;
-            setActiveProviderComponent(component: MediaProviderComponentBase): void;
-            search(immediate?: boolean): void;
+            media: () => {
+                setSelectedProvider(id: GuidValue): void;
+                setFileProcessor(processor: IMediaFileProcessor): void;
+                onItemSelected(item: MediaItem): void;
+                onProcessMediaItem(): void;
+                onRetryGetSelectedImage(): void;
+                onCancelSelectedImageProcess(): void;
+                loadMaxAllowedFileSize: () => Promise<void>;
+            };
+            search: () => {
+                execute: (immediate?: boolean) => Promise<unknown>;
+                searchMore: () => Promise<unknown>;
+                setProvider: (provider: IMediaPickerSerchProvider) => void;
+            };
+            message: () => {
+                show: (message: StateMessage) => void;
+                clear: () => void;
+            };
         }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
-            setSelectedProvider(id: GuidValue): void;
-            selectMediaItem(item: MediaItem): void;
-            setActiveProviderComponent(component: MediaProviderComponentBase): void;
-            search(immediate?: boolean): void;
+            media: () => {
+                setSelectedProvider(id: GuidValue): void;
+                setFileProcessor(processor: IMediaFileProcessor): void;
+                onItemSelected(item: MediaItem): void;
+                onProcessMediaItem(): void;
+                onRetryGetSelectedImage(): void;
+                onCancelSelectedImageProcess(): void;
+                loadMaxAllowedFileSize: () => Promise<void>;
+            };
+            search: () => {
+                execute: (immediate?: boolean) => Promise<unknown>;
+                searchMore: () => Promise<unknown>;
+                setProvider: (provider: IMediaPickerSerchProvider) => void;
+            };
+            message: () => {
+                show: (message: StateMessage) => void;
+                clear: () => void;
+            };
         }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         onFailure<T_2 extends (...args: any) => any>(action: (actions: {
-            setSelectedProvider(id: GuidValue): void;
-            selectMediaItem(item: MediaItem): void;
-            setActiveProviderComponent(component: MediaProviderComponentBase): void;
-            search(immediate?: boolean): void;
+            media: () => {
+                setSelectedProvider(id: GuidValue): void;
+                setFileProcessor(processor: IMediaFileProcessor): void;
+                onItemSelected(item: MediaItem): void;
+                onProcessMediaItem(): void;
+                onRetryGetSelectedImage(): void;
+                onCancelSelectedImageProcess(): void;
+                loadMaxAllowedFileSize: () => Promise<void>;
+            };
+            search: () => {
+                execute: (immediate?: boolean) => Promise<unknown>;
+                searchMore: () => Promise<unknown>;
+                setProvider: (provider: IMediaPickerSerchProvider) => void;
+            };
+            message: () => {
+                show: (message: StateMessage) => void;
+                clear: () => void;
+            };
         }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
     } & {
-        setSelectedProvider(id: GuidValue): void;
-        selectMediaItem(item: MediaItem): void;
-        setActiveProviderComponent(component: MediaProviderComponentBase): void;
-        search(immediate?: boolean): void;
+        media: () => {
+            setSelectedProvider(id: GuidValue): void;
+            setFileProcessor(processor: IMediaFileProcessor): void;
+            onItemSelected(item: MediaItem): void;
+            onProcessMediaItem(): void;
+            onRetryGetSelectedImage(): void;
+            onCancelSelectedImageProcess(): void;
+            loadMaxAllowedFileSize: () => Promise<void>;
+        };
+        search: () => {
+            execute: (immediate?: boolean) => Promise<unknown>;
+            searchMore: () => Promise<unknown>;
+            setProvider: (provider: IMediaPickerSerchProvider) => void;
+        };
+        message: () => {
+            show: (message: StateMessage) => void;
+            clear: () => void;
+        };
     };
     get: {};
 };

package/internal-do-not-import-from-here/ux/docs/Docs.d.ts

@@ -44,6 +44,7 @@ export declare const builtInDocumentationCategories: {
     imagesAndIcons: DocumentationCategory;
     navigation: DocumentationCategory;
     pickers: DocumentationCategory;
+    providers: DocumentationCategory;
 };
 export declare const velcronDocumentationCategories: {
     gettingStarted: DocumentationCategory;

package/internal-do-not-import-from-here/ux/imagegrid/ImageGrid.d.ts

@@ -54,10 +54,9 @@ declare const _default: {
                 default?: import("../DefineVueTypings").Slot<any[]>;
             } & {
                 itemDetailSlot?: (item: MediaItem) => VNodeChild;
-                itemOverlaySlot?: (item: MediaItem) => VNodeChild;
             };
-            readonly images?: MediaItem[];
             readonly appendToGrid?: boolean;
+            readonly images?: MediaItem[];
             readonly searchStatus?: MediaPickerEnums.MediaSearchStatus;
             readonly "search-status"?: MediaPickerEnums.MediaSearchStatus;
         };
@@ -79,7 +78,6 @@ declare const _default: {
                 default?: import("../DefineVueTypings").Slot<any[]>;
             } & {
                 itemDetailSlot?: (item: MediaItem) => VNodeChild;
-                itemOverlaySlot?: (item: MediaItem) => VNodeChild;
             }>;
             "search-status": {
                 type: import("vue").PropType<MediaPickerEnums.MediaSearchStatus>;
@@ -120,7 +118,6 @@ declare const _default: {
             default?: import("../DefineVueTypings").Slot<any[]>;
         } & {
             itemDetailSlot?: (item: MediaItem) => VNodeChild;
-            itemOverlaySlot?: (item: MediaItem) => VNodeChild;
         }>;
         "search-status": {
             type: import("vue").PropType<MediaPickerEnums.MediaSearchStatus>;
@@ -145,7 +142,6 @@ declare const _default: {
         default?: import("../DefineVueTypings").Slot<any[]>;
     } & {
         itemDetailSlot?: (item: MediaItem) => VNodeChild;
-        itemOverlaySlot?: (item: MediaItem) => VNodeChild;
     }>;
     "search-status": {
         type: import("vue").PropType<MediaPickerEnums.MediaSearchStatus>;
@@ -167,10 +163,9 @@ declare const _default: {
             default?: import("../DefineVueTypings").Slot<any[]>;
         } & {
             itemDetailSlot?: (item: MediaItem) => VNodeChild;
-            itemOverlaySlot?: (item: MediaItem) => VNodeChild;
         };
-        images?: MediaItem[];
         appendToGrid?: boolean;
+        images?: MediaItem[];
         searchStatus?: MediaPickerEnums.MediaSearchStatus;
         "search-status"?: MediaPickerEnums.MediaSearchStatus;
     }>, never>;

package/internal-do-not-import-from-here/ux/imagetransformer/ImageTransformer.d.ts

@@ -1,105 +0,0 @@
-import { MediaPickerImageTransformationResult } from "@omnia/fx/models";
-declare const _default: {
-    new (...args: any[]): {
-        $: import("vue").ComponentInternalInstance;
-        $data: {};
-        $props: {
-            style?: unknown;
-            class?: unknown;
-            key?: string | number | symbol;
-            ref?: import("vue").VNodeRef;
-            ref_for?: boolean;
-            ref_key?: string;
-            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-                [key: string]: any;
-            }>) => void)[];
-            onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-        };
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import("vue").Slot<any>;
-        }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
-        $emit: (event: "changed", currentTransformationResult: MediaPickerImageTransformationResult) => void;
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>> & {
-            onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-        }, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            changed: (currentTransformationResult: MediaPickerImageTransformationResult) => true;
-        }, 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
-    } & Readonly<import("vue").ExtractPropTypes<{}>> & {
-        onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-    } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>> & {
-    onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    changed: (currentTransformationResult: MediaPickerImageTransformationResult) => true;
-}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {}>, "onChanged"> & {
-        onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-    };
-};
-export default _default;

package/internal-do-not-import-from-here/ux/journey/v2/JourneyBlade.d.ts

@@ -64,10 +64,10 @@ declare const _default: {
                 actionsFooter?: Func<[VNodeChild]>;
             };
             readonly loading?: boolean;
-            readonly create?: boolean;
             readonly remove?: boolean;
-            readonly ok?: boolean;
             readonly save?: boolean;
+            readonly create?: boolean;
+            readonly ok?: boolean;
             readonly subTitle?: string;
             onDoc$?: (description?: string) => any;
             "onClick:cancel"?: (id: GuidValue) => any;
@@ -369,10 +369,10 @@ declare const _default: {
             actionsFooter?: Func<[VNodeChild]>;
         };
         loading?: boolean;
-        create?: boolean;
         remove?: boolean;
-        ok?: boolean;
         save?: boolean;
+        create?: boolean;
+        ok?: boolean;
         subTitle?: string;
         searchable?: boolean;
         onOk?: () => boolean | Promise<boolean>;

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

@@ -1,5 +1,3 @@
-import { MediaPickerLimitedSizeSettings } from "../../../models";
-import { LegacySvgImage } from "../../models/LegacySvgImage";
 export declare class MediaPickerImageHandler {
     /**
      * Converts a byte to an byte array
@@ -24,7 +22,7 @@ export declare class MediaPickerImageHandler {
     * @param b64Data
     */
     static calculateBase64Size(b64Data: string): number;
-    static getDefaultLimitedSizeSettings(): MediaPickerLimitedSizeSettings;
+    static getDefaultLimitedSizeSettings(): any;
     static isImageFormatSupportForScaling(imageFormat: string): boolean;
     static isImageFormatSupportForMediaPicker(imageFormat: string): boolean;
     /**
@@ -32,5 +30,5 @@ export declare class MediaPickerImageHandler {
     * @param {LegacySvgImage} svgImg
     * @return {string} imgUrl
     */
-    static retrieveImageDatafromSVG(svgImg: LegacySvgImage): string;
+    static retrieveImageDatafromSVG(svgImg: any): string;
 }

package/internal-do-not-import-from-here/ux/mediapickerV2/docs/ExampleComponents.d.ts

@@ -0,0 +1 @@
+export declare const ExampleComponents: import("@omnia/fx/ux").DocumentationSpec;

package/internal-do-not-import-from-here/ux/mediapickerV2/docs/MediaProviderExample.d.ts

@@ -0,0 +1,91 @@
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export declare const spec: import("@omnia/fx/ux").DocumentationSpec;

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

@@ -0,0 +1,4 @@
+export declare const MediaPickerStyles: {
+    navigationMenuWrapper: (dark: boolean) => string;
+    imageMenuWrapper: (dark: boolean) => string;
+};