@omnia/fx 8.0.111-vnext → 8.0.112-vnext

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

@@ -1,6 +1,6 @@
 import { useThemeStoreV2 } from "@omnia/fx/ux";
 import { VNodeChild } from "vue";
-import { ThemeDefinitionV2 } from "@omnia/fx-models";
+import { MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerStorageProviderContext, MediaPickerVideo } from "@omnia/fx-models";
 export type RegisterThemeStore = (store: ReturnType<typeof useThemeStoreV2>) => void;
 declare const _default: {
     new (...args: any[]): {
@@ -9,7 +9,69 @@ declare const _default: {
         $props: {
             style?: unknown;
             class?: unknown;
+            readonly name?: {
+                [x: `onUpdate:${string}`]: {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                [x: `v-model:${string}`]: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                [x: string]: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                require(): import("../../DefineVueTypings").DefinePropModelRequire<string, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }>;
+                defaultValue(value?: boolean): import("../../DefineVueTypings").DefinePropModelDefaultValue<string, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }, false>;
+                doc$(description?: string): import("../../DefineVueTypings").DefinePropModelDoc<string, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }>;
+            };
             key?: string | number | symbol;
+            readonly providerContext?: MediaPickerStorageProviderContext;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -56,9 +118,21 @@ declare const _default: {
             } & {
                 activator?: () => VNodeChild;
             };
-            "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-            readonly themeStoreRegistrationHook?: RegisterThemeStore;
-            readonly "theme-store-registration-hook"?: RegisterThemeStore;
+            readonly "v-model"?: boolean;
+            readonly modelValue?: boolean;
+            readonly "onUpdate:modelValue"?: (value: boolean) => any;
+            onClose?: () => any;
+            readonly galleryItemLimit?: number;
+            readonly enableGallery?: boolean;
+            readonly selectableMediaTypes?: MediaPickerEnums.OmniaMediaTypes[];
+            readonly settings?: MediaPickerImageSettings;
+            readonly selectedMedia?: MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[];
+            onSave?: () => any;
+            readonly "selected-media"?: MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[];
+            readonly "selectable-media-types"?: MediaPickerEnums.OmniaMediaTypes[];
+            readonly "provider-context"?: MediaPickerStorageProviderContext;
+            readonly "enable-gallery"?: boolean;
+            readonly "gallery-item-limit"?: number;
         };
         $attrs: {
             [x: string]: unknown;
@@ -71,7 +145,7 @@ declare const _default: {
         }>;
         $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: "update:modelValue", themeDefinition: ThemeDefinitionV2) => void;
+        $emit: ((event: "close") => void) & ((event: "save") => void);
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
             "v-slots": import("vue").Prop<{
@@ -79,16 +153,113 @@ declare const _default: {
             } & {
                 activator?: () => VNodeChild;
             }>;
-            "theme-store-registration-hook": {
-                type: import("vue").PropType<RegisterThemeStore>;
+            "gallery-item-limit": {
+                type: import("vue").PropType<number>;
+            };
+            galleryItemLimit: {
+                type: import("vue").PropType<number>;
+            };
+            settings: {
+                type: import("vue").PropType<MediaPickerImageSettings>;
+            } & {
+                type: import("vue").PropType<MediaPickerImageSettings>;
+            };
+            "enable-gallery": {
+                type: import("vue").PropType<boolean>;
+            };
+            enableGallery: {
+                type: import("vue").PropType<boolean>;
+            };
+            "provider-context": {
+                type: import("vue").PropType<MediaPickerStorageProviderContext>;
+            };
+            providerContext: {
+                type: import("vue").PropType<MediaPickerStorageProviderContext>;
             };
-            themeStoreRegistrationHook: {
-                type: import("vue").PropType<RegisterThemeStore>;
+            "selectable-media-types": {
+                type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+            };
+            selectableMediaTypes: {
+                type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+            };
+            "selected-media": {
+                type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+            };
+            selectedMedia: {
+                type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+            };
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: boolean) => any>;
+            };
+            "v-model": {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            modelValue: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            name: <TName extends string>(n?: TName) => { [key in import("../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
+                type: import("vue").PropType<(value: boolean) => any>;
+            }; } & { [key_1 in import("../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            }; } & { [key_2 in import("../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            }; } & {
+                require(): import("../../DefineVueTypings").DefinePropModelRequire<TName, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }>;
+                defaultValue(value?: boolean): import("../../DefineVueTypings").DefinePropModelDefaultValue<TName, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }, false>;
+                doc$(description?: string): import("../../DefineVueTypings").DefinePropModelDoc<TName, boolean, {
+                    "onUpdate:modelValue": {
+                        type: import("vue").PropType<(value: boolean) => any>;
+                    };
+                } & {
+                    "v-model": {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<boolean>;
+                        required: false;
+                    };
+                }>;
             };
         }>> & {
-            "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
+            onClose?: () => any;
+            onSave?: () => any;
         }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            "update:modelValue": (themeDefinition: ThemeDefinitionV2) => true;
+            save: () => true;
+            close: () => true;
         }, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -115,14 +286,110 @@ declare const _default: {
         } & {
             activator?: () => VNodeChild;
         }>;
-        "theme-store-registration-hook": {
-            type: import("vue").PropType<RegisterThemeStore>;
+        "gallery-item-limit": {
+            type: import("vue").PropType<number>;
+        };
+        galleryItemLimit: {
+            type: import("vue").PropType<number>;
+        };
+        settings: {
+            type: import("vue").PropType<MediaPickerImageSettings>;
+        } & {
+            type: import("vue").PropType<MediaPickerImageSettings>;
+        };
+        "enable-gallery": {
+            type: import("vue").PropType<boolean>;
         };
-        themeStoreRegistrationHook: {
-            type: import("vue").PropType<RegisterThemeStore>;
+        enableGallery: {
+            type: import("vue").PropType<boolean>;
+        };
+        "provider-context": {
+            type: import("vue").PropType<MediaPickerStorageProviderContext>;
+        };
+        providerContext: {
+            type: import("vue").PropType<MediaPickerStorageProviderContext>;
+        };
+        "selectable-media-types": {
+            type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+        };
+        selectableMediaTypes: {
+            type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+        };
+        "selected-media": {
+            type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+        };
+        selectedMedia: {
+            type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: boolean) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        name: <TName extends string>(n?: TName) => { [key in import("../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
+            type: import("vue").PropType<(value: boolean) => any>;
+        }; } & { [key_1 in import("../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        }; } & { [key_2 in import("../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        }; } & {
+            require(): import("../../DefineVueTypings").DefinePropModelRequire<TName, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: boolean): import("../../DefineVueTypings").DefinePropModelDefaultValue<TName, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("../../DefineVueTypings").DefinePropModelDoc<TName, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }>;
         };
     }>> & {
-        "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
+        onClose?: () => any;
+        onSave?: () => any;
     } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
@@ -133,27 +400,198 @@ declare const _default: {
     } & {
         activator?: () => VNodeChild;
     }>;
-    "theme-store-registration-hook": {
-        type: import("vue").PropType<RegisterThemeStore>;
+    "gallery-item-limit": {
+        type: import("vue").PropType<number>;
+    };
+    galleryItemLimit: {
+        type: import("vue").PropType<number>;
+    };
+    settings: {
+        type: import("vue").PropType<MediaPickerImageSettings>;
+    } & {
+        type: import("vue").PropType<MediaPickerImageSettings>;
     };
-    themeStoreRegistrationHook: {
-        type: import("vue").PropType<RegisterThemeStore>;
+    "enable-gallery": {
+        type: import("vue").PropType<boolean>;
+    };
+    enableGallery: {
+        type: import("vue").PropType<boolean>;
+    };
+    "provider-context": {
+        type: import("vue").PropType<MediaPickerStorageProviderContext>;
+    };
+    providerContext: {
+        type: import("vue").PropType<MediaPickerStorageProviderContext>;
+    };
+    "selectable-media-types": {
+        type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+    };
+    selectableMediaTypes: {
+        type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
+    };
+    "selected-media": {
+        type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+    };
+    selectedMedia: {
+        type: import("vue").PropType<MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[]>;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: boolean) => any>;
+    };
+    "v-model": {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    modelValue: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    name: <TName extends string>(n?: TName) => { [key in import("../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
+        type: import("vue").PropType<(value: boolean) => any>;
+    }; } & { [key_1 in import("../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    }; } & { [key_2 in import("../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    }; } & {
+        require(): import("../../DefineVueTypings").DefinePropModelRequire<TName, boolean, {
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: boolean) => any>;
+            };
+        } & {
+            "v-model": {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        }>;
+        defaultValue(value?: boolean): import("../../DefineVueTypings").DefinePropModelDefaultValue<TName, boolean, {
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: boolean) => any>;
+            };
+        } & {
+            "v-model": {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        }, false>;
+        doc$(description?: string): import("../../DefineVueTypings").DefinePropModelDoc<TName, boolean, {
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: boolean) => any>;
+            };
+        } & {
+            "v-model": {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        }>;
     };
 }>> & {
-    "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
+    onClose?: () => any;
+    onSave?: () => any;
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (themeDefinition: ThemeDefinitionV2) => true;
+    save: () => true;
+    close: () => true;
 }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
+        name?: {
+            [x: `onUpdate:${string}`]: {
+                type: import("vue").PropType<(value: boolean) => any>;
+            };
+        } & {
+            [x: `v-model:${string}`]: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        } & {
+            [x: string]: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+        } & {
+            require(): import("../../DefineVueTypings").DefinePropModelRequire<string, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: boolean): import("../../DefineVueTypings").DefinePropModelDefaultValue<string, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("../../DefineVueTypings").DefinePropModelDoc<string, boolean, {
+                "onUpdate:modelValue": {
+                    type: import("vue").PropType<(value: boolean) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<boolean>;
+                    required: false;
+                };
+            }>;
+        };
+        providerContext?: MediaPickerStorageProviderContext;
         "v-slots"?: {
             default?: import("../../DefineVueTypings").Slot<any[]>;
         } & {
             activator?: () => VNodeChild;
         };
-        themeStoreRegistrationHook?: RegisterThemeStore;
-        "theme-store-registration-hook"?: RegisterThemeStore;
-    }>, "onUpdate:modelValue"> & {
-        "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
+        "v-model"?: boolean;
+        modelValue?: boolean;
+        "onUpdate:modelValue"?: (value: boolean) => any;
+        galleryItemLimit?: number;
+        enableGallery?: boolean;
+        selectableMediaTypes?: MediaPickerEnums.OmniaMediaTypes[];
+        settings?: MediaPickerImageSettings;
+        selectedMedia?: MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[];
+        "selected-media"?: MediaPickerImage | MediaPickerVideo | (MediaPickerImage | MediaPickerVideo)[];
+        "selectable-media-types"?: MediaPickerEnums.OmniaMediaTypes[];
+        "provider-context"?: MediaPickerStorageProviderContext;
+        "enable-gallery"?: boolean;
+        "gallery-item-limit"?: number;
+    }>, "onClose" | "onSave"> & {
+        onClose?: () => any;
+        onSave?: () => any;
     };
 };
 export default _default;

package/internal-do-not-import-from-here/ux/mediapickerV2/framework/core/MediaFileProcessor.d.ts

@@ -1,14 +1,10 @@
-import { IMediaFileProcessor, ImageInformation, ImageItem, MediaPickerImage, MediaPickerImageScalingDefinition, MediaPickerImageTransformationResult, MediaPickerVideo, VideoInformation, VideoItem } from "@omnia/fx-models";
+import { IMediaFileProcessor, ImageInformation, ImageItem, MediaPickerImageScalingDefinition, MediaPickerImageTransformationResult, VideoInformation, VideoItem } from "@omnia/fx-models";
 import { WebImageService } from "@omnia/fx/services";
 export declare class MediaFileProcessor implements IMediaFileProcessor {
     protected webImageService: WebImageService;
     constructor();
-    handleSelectedMediaItem(mediaItem: ImageItem | VideoItem): void;
-    beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
-    protected save(resultToBeSaved: MediaPickerImageTransformationResult | MediaPickerVideo): void;
+    getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
     onResizeImage(image: ImageInformation, scalingSettings: MediaPickerImageScalingDefinition): Promise<ImageInformation>;
     private ensureRemoveBase64Format;
-    addNewImage(imageProviderResult: MediaPickerImageTransformationResult): Promise<MediaPickerImage>;
-    private handleValidatedImage;
-    getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
+    onTransformImage(image: ImageInformation): MediaPickerImageTransformationResult;
 }

package/internal-do-not-import-from-here/ux/mediapickerV2/imagetransformer/Components/editor/ImageEditorCanvas.d.ts

@@ -9,6 +9,8 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
+            readonly maxHeight?: number;
+            readonly maxWidth?: number;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -50,13 +52,11 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly maxHeight?: number;
-            readonly maxWidth?: number;
             readonly ratio?: MediaPickerImageRatio;
+            readonly imageSrc?: string;
             readonly "max-height"?: number;
             readonly "max-width"?: number;
             readonly containerId?: string;
-            readonly imageSrc?: string;
             readonly crop?: MediaPickerCropTransformation;
             readonly transformations?: MediaPickerTransformation[];
             readonly "container-id"?: string;
@@ -235,10 +235,10 @@ declare const _default: {
         maxHeight?: number;
         maxWidth?: number;
         ratio?: MediaPickerImageRatio;
+        imageSrc?: string;
         "max-height"?: number;
         "max-width"?: number;
         containerId?: string;
-        imageSrc?: string;
         crop?: MediaPickerCropTransformation;
         transformations?: MediaPickerTransformation[];
         "container-id"?: string;

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaprovider/MediaProvider.css.d.ts

@@ -1,8 +1,10 @@
 export declare const MediaProviderStyles: {
     loadingOverlayWrapper: (darkBackground: boolean) => string;
     searchBoxWrapper: string;
-    messageWrapper: string;
-    messagePositioner: string;
+    message: {
+        wrapper: string;
+        positioner: string;
+    };
     providerWrapper: string;
     providerContent: (searchable: boolean) => string;
 };

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

@@ -5,8 +5,9 @@ import { MediaPickerProviderComponentProps } from "../../mediapicker";
 import { VueComponentBase } from "../../VueComponentBase";
 import { SettingsService, WebImageService, MediaPickerService } from "../../../services";
 import { MediaProviderBaseLocalization } from "./loc/localize";
-import { MediaPickerStore, MultilingualStore, useMediaPickerProviderStore } from "@omnia/fx/stores";
+import { MediaPickerStore, MultilingualStore } from "@omnia/fx/stores";
 import { useColorSchemaStore } from "../../theming-v2";
+import { useMediaPickerProviderStore } from "../stores";
 export interface MediaProviderComponentBaseSlots {
     bottom?: () => JSX.Element | Array<JSX.Element>;
 }
@@ -47,6 +48,7 @@ export declare abstract class MediaProviderComponentBase extends VueComponentBas
     private isSaved;
     private selectedMediaInformation;
     constructor();
+    onChanged: (state: any) => void;
     protected save(resultToBeSaved: MediaPickerImageTransformationResult | MediaPickerVideo): void;
     protected transformImage(imageInfo: ImageInformation): Future<MediaPickerImageTransformationResult>;
     protected toggleLoadingUI(show: boolean, loadingStyle?: MediaPickerEnums.LoadingStyle): void;
@@ -68,6 +70,5 @@ export declare abstract class MediaProviderComponentBase extends VueComponentBas
     private resolveSavingImagePromise;
     private closeRetryImageScalingDialog;
     private closeFileTypeIsNotSupportedDialog;
-    private renderRetryImageScalingDialog;
     protected renderBase(getProviderSlotsFunc: () => Array<JSX.Element> | JSX.Element): JSX.Element;
 }