@omnia/fx 8.0.110-vnext → 8.0.112-vnext

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

@@ -0,0 +1,4 @@
+import { types } from "typestyle";
+export declare const PhotoWallWithSliderDisplayRenderer: {
+    wrapperStyle?: types.NestedCSSProperties;
+};

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

@@ -0,0 +1,128 @@
+import { MediaPickerMedia } from "@omnia/fx-models";
+export interface PhotoWallWithSliderDisplayRenderer {
+    media: Array<MediaPickerMedia>;
+    mediaData: string;
+    defaultVSlot: JSX.Element;
+    imageStyle: string;
+    disableDialog?: boolean;
+}
+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)[];
+            readonly media?: MediaPickerMedia[];
+            readonly imageStyle?: string;
+            readonly disableDialog?: boolean;
+            readonly mediaData?: string;
+            readonly defaultVSlot?: JSX.Element;
+        };
+        $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<{
+            media: import("vue").Prop<MediaPickerMedia[], MediaPickerMedia[]>;
+            mediaData: import("vue").Prop<string, string>;
+            defaultVSlot: import("vue").Prop<JSX.Element, JSX.Element>;
+            imageStyle: import("vue").Prop<string, string>;
+            disableDialog?: import("vue").Prop<boolean, boolean>;
+        }>>, {}, {}, {}, {}, 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<{
+        media: import("vue").Prop<MediaPickerMedia[], MediaPickerMedia[]>;
+        mediaData: import("vue").Prop<string, string>;
+        defaultVSlot: import("vue").Prop<JSX.Element, JSX.Element>;
+        imageStyle: import("vue").Prop<string, string>;
+        disableDialog?: import("vue").Prop<boolean, boolean>;
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    media: import("vue").Prop<MediaPickerMedia[], MediaPickerMedia[]>;
+    mediaData: import("vue").Prop<string, string>;
+    defaultVSlot: import("vue").Prop<JSX.Element, JSX.Element>;
+    imageStyle: import("vue").Prop<string, string>;
+    disableDialog?: import("vue").Prop<boolean, boolean>;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        media?: MediaPickerMedia[];
+        imageStyle?: string;
+        disableDialog?: boolean;
+        mediaData?: string;
+        defaultVSlot?: JSX.Element;
+    }>, never>;
+};
+export default _default;

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

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

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

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

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

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

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

@@ -1,5 +1,19 @@
 export declare const MediaPickerStyles: {
-    navigationMenuWrapper: (dark: boolean) => string;
-    imageMenuWrapper: (dark: boolean) => string;
-    searchBoxWrapper: string;
+    listItemTitleMedia: string;
+    listItemIconMedia: string;
+    closeButton: string;
+    iconSvg: string;
+    iconWrapper: string;
+    providerWrapper: string;
+    toolbarTitle: (width: string) => string;
+    selectedProvider: (bgColor: string) => string;
+    multiPanelNavigationDrawer: (width: string) => string;
+    navigationDrawer: (width: any) => string;
+    bodyWrapper: (showGallery: boolean) => string;
+    body: string;
+    elementWrapper: string;
+    loadingOverlay: string;
+    loadingWrapper: string;
+    editorContainer: string;
+    dialog: string;
 };

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

@@ -1,159 +1,20 @@
-import { useThemeStoreV2 } from "@omnia/fx/ux";
-import { VNodeChild } from "vue";
-import { ThemeDefinitionV2 } from "@omnia/fx-models";
-export type RegisterThemeStore = (store: ReturnType<typeof useThemeStoreV2>) => void;
-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)[];
-            readonly "v-slots"?: {
-                default?: import("../DefineVueTypings").Slot<any[]>;
-            } & {
-                activator?: () => VNodeChild;
-            };
-            "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-            readonly themeStoreRegistrationHook?: RegisterThemeStore;
-            readonly "theme-store-registration-hook"?: RegisterThemeStore;
-        };
-        $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: "update:modelValue", themeDefinition: ThemeDefinitionV2) => void;
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            "v-slots": import("vue").Prop<{
-                default?: import("../DefineVueTypings").Slot<any[]>;
-            } & {
-                activator?: () => VNodeChild;
-            }>;
-            "theme-store-registration-hook": {
-                type: import("vue").PropType<RegisterThemeStore>;
-            };
-            themeStoreRegistrationHook: {
-                type: import("vue").PropType<RegisterThemeStore>;
-            };
-        }>> & {
-            "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            "update:modelValue": (themeDefinition: ThemeDefinitionV2) => 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<{
-        "v-slots": import("vue").Prop<{
-            default?: import("../DefineVueTypings").Slot<any[]>;
-        } & {
-            activator?: () => VNodeChild;
-        }>;
-        "theme-store-registration-hook": {
-            type: import("vue").PropType<RegisterThemeStore>;
-        };
-        themeStoreRegistrationHook: {
-            type: import("vue").PropType<RegisterThemeStore>;
-        };
-    }>> & {
-        "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-    } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    "v-slots": import("vue").Prop<{
-        default?: import("../DefineVueTypings").Slot<any[]>;
-    } & {
-        activator?: () => VNodeChild;
-    }>;
-    "theme-store-registration-hook": {
-        type: import("vue").PropType<RegisterThemeStore>;
-    };
-    themeStoreRegistrationHook: {
-        type: import("vue").PropType<RegisterThemeStore>;
-    };
-}>> & {
-    "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (themeDefinition: ThemeDefinitionV2) => true;
-}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
-        "v-slots"?: {
-            default?: import("../DefineVueTypings").Slot<any[]>;
-        } & {
-            activator?: () => VNodeChild;
-        };
-        themeStoreRegistrationHook?: RegisterThemeStore;
-        "theme-store-registration-hook"?: RegisterThemeStore;
-    }>, "onUpdate:modelValue"> & {
-        "onUpdate:modelValue"?: (themeDefinition: ThemeDefinitionV2) => any;
-    };
-};
-export default _default;
+import { IWebComponentInstance } from "../../";
+import { MediaPickerEnums, MediaPickerImage, type MediaPickerImageSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo } from "../../models";
+import { VueComponentBase } from "../VueComponentBase";
+import { IMediaPicker } from "./IMediaPicker";
+export declare class MediaPicker extends VueComponentBase<IMediaPicker> implements IWebComponentInstance, IMediaPicker {
+    selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
+    providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
+    selectedMedia?: MediaPickerImage | MediaPickerVideo | Array<MediaPickerImage | MediaPickerVideo>;
+    providerContext: MediaPickerStorageProviderContext;
+    imageSettings?: MediaPickerImageSettings;
+    saved: (result: MediaPickerMedia) => void;
+    closed?: () => void;
+    dialog: boolean;
+    enableGallery: boolean;
+    itemLimit: number;
+    enableMediaCaption?: boolean;
+    mounted(): void;
+    private renderRenderer;
+    render(): void | JSX.Element;
+}

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

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

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

@@ -1,86 +1 @@
-import { IMediaPicker } from "@omnia/fx/ux";
-import { OmniaContext } from "../../";
-import { SubscriptionHandler } from "../../core";
-import { MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo } from "../../models";
-import { MediaPickerService, SettingsService } from "../../services";
-import { MediaPickerStore, MultilingualStore } from "../../stores";
-import { VueComponentBase, VueComponentBaseProps } from "../VueComponentBase";
-import { MediaPickerLocalization } from "./loc/localize";
-declare interface MediaPickerActionButton {
-    text: string;
-    show: boolean;
-    onClick: any;
-    icon?: string;
-    iconLeft?: boolean;
-    loading?: boolean;
-    highLighted?: boolean;
-    leftAligned?: boolean;
-}
-export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker & VueComponentBaseProps> {
-    selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
-    providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
-    selectedMedia?: MediaPickerImage | MediaPickerVideo;
-    providerContext: MediaPickerStorageProviderContext;
-    imageSettings?: MediaPickerImageSettings;
-    saved: (result: MediaPickerMedia) => void;
-    closed?: () => void;
-    protected settingsService: SettingsService<MediaPickerLimitedSizeSettings>;
-    omniaContext: OmniaContext;
-    multilingualStore: MultilingualStore;
-    private localizationStore;
-    subscriptionHandler: SubscriptionHandler;
-    loc: MediaPickerLocalization.locInterface;
-    private uxLoc;
-    mediaPickerService: MediaPickerService;
-    mediaPickerStore: MediaPickerStore;
-    private id_search;
-    private defaultEditImageMenuId;
-    private activedMenuItemId;
-    private activedProvider;
-    private transformerElementName;
-    private editingImageActionButtons;
-    private renditions;
-    private convertingFromBase64ToMediaPicker;
-    isSearching: boolean;
-    hasLoadedInfiniteScrollHandler: boolean;
-    searchTimeout: any;
-    searchQueryText: string;
-    currentFile: {
-        size: number;
-        width: number;
-        height: number;
-    };
-    static imageBankElementProvider: string;
-    private currentTransformerResult;
-    private menuItems;
-    private selectedImageTransformationSource;
-    private registeredProviders;
-    created(): void;
-    private init;
-    private processSelectedMediaInput;
-    private EnsureDefaultImageEditProviderIsSelected;
-    private createMediaPickerImageFromUrl;
-    onKeypress(event: any): void;
-    private onPickerClose;
-    private setSearchKeyword;
-    onSearch(immediate?: boolean): void;
-    private onEditingImageSaveButtonClick;
-    private getFileNameFromBase64;
-    private updateImage;
-    private onSelectMenuItem;
-    private onChangedExistedImage;
-    private getMediaProvider;
-    renderMenuItems(): JSX.Element[];
-    renderLeftMenu(): JSX.Element;
-    renderActionButtons(buttons: Array<MediaPickerActionButton>): JSX.Element[];
-    private renderEditImageForm;
-    private renderActivedProvider;
-    private onCreatedProviderComponent;
-    private activedProviderComponent;
-    private isShowLoadingOverlay;
-    private isShowLoading;
-    private renderLoading;
-    private renderMainForm;
-    render(): JSX.Element;
-}
 export {};

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,13 +22,12 @@ 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;
     /**
     * Retrieve imgUrl from svg string
     * @param {LegacySvgImage} svgImg
     * @return {string} imgUrl
     */
-    static retrieveImageDatafromSVG(svgImg: LegacySvgImage): string;
+    static retrieveImageDatafromSVG(svgImg: any): string;
 }

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

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

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

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

package/internal-do-not-import-from-here/ux/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/{compositiontests/TestInjectComponent.d.ts → mediapickerV2/docs/MediaProviderExample.d.ts}

@@ -1,6 +1,3 @@
-type Props = {
-    themeDefinitionId: string;
-};
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -9,7 +6,6 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
-            readonly themeDefinitionId: string;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -65,7 +61,7 @@ declare const _default: {
         $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<Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
+        $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)[];
@@ -85,11 +81,11 @@ declare const _default: {
         $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<Props> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<Props>, 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,8 @@
+export declare const MediaPickerStyles: {
+    navigationMenuWrapper: (dark: boolean) => string;
+    imageMenuWrapper: (dark: boolean) => string;
+    emptyContainer: {
+        wrapper: string;
+        positioner: string;
+    };
+};