@omnia/fx 8.0.110-vnext → 8.0.112-vnext

package/internal-do-not-import-from-here/ux/mediapickerV2/imagetransformer/Components/settings/ImageSettings.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/imagetransformer/Constants.d.ts

@@ -0,0 +1,92 @@
+import { Topic } from "@omnia/fx-models";
+export declare namespace Constants {
+    namespace TransformerMessages {
+        const TransformerRatioChange: Topic<string>;
+        const TransformerCropChange: Topic<string>;
+        const TransformerFilterChange: Topic<string>;
+    }
+    namespace OutputEvent {
+        const TransformerOutput: string;
+    }
+    namespace MediaPickerTransformer {
+        const CropperAreaMaxWidth: number;
+    }
+    namespace FilterNameMap {
+        const grayscale: string;
+        const invert: string;
+        const sepia: string;
+        const blur: string;
+        const sharpen: string;
+        const emboss: string;
+        const removeWhite: string;
+        const brightness: string;
+        const contrast: string;
+        const saturation: string;
+        const vintage: string;
+        const noise: string;
+        const pixelate: string;
+        const colorFilter: string;
+    }
+    namespace DefaultFilterRangeValus {
+        const tintOpacityRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+        const removewhiteDistanceRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+        const brightnessRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+        const noiseRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+        const pixelateRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+        const colorfilterThresholeRange: {
+            min: number;
+            max: number;
+            step: number;
+            value: number;
+        };
+    }
+    namespace Styles {
+        const wrapperStyle: string;
+        const wrapperResponsive: string;
+        const svgContainer: string;
+        const svgdef: string;
+    }
+    namespace NamespacesURI {
+        const svgURI = "http://www.w3.org/2000/svg";
+        const svgType = "image/svg+xml";
+        const xlink = "http://www.w3.org/1999/xlink";
+    }
+    namespace FilterTemplate {
+        const gaussianblur: string;
+        const componentTransfer: string;
+        const saturate: string;
+        const huerotate: string;
+        const erode: string;
+        const dilate: string;
+        const sepia: string;
+        const grayscale: string;
+    }
+    namespace Utils {
+        const transfomerConfigKeys: string[];
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare const ImageTransformerStyles: {
+    wrapper: string;
+};

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

@@ -0,0 +1,105 @@
+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/mediapickerV2/imagetransformer/loc/localize.d.ts

@@ -0,0 +1,46 @@
+export declare module ImageTransformerLocalization {
+    const namespace: string;
+    interface locInterface {
+        Title: string;
+        Properties: string;
+        Crop: string;
+        Flip: string;
+        Filter: string;
+        Information: string;
+        Rollup: string;
+        ImageUrl: string;
+        Dimension: string;
+        UsefixedSize: string;
+        Apply: string;
+        Cancel: string;
+        FlipX: string;
+        FlipY: string;
+        Reset: string;
+        Grayscale: string;
+        Sepia: string;
+        Vintage: string;
+        Emboss: string;
+        Invert: string;
+        Sharpen: string;
+        RemoveWhite: string;
+        Brightness: string;
+        Noise: string;
+        Pixelate: string;
+        ColorFilter: string;
+        TransformComponentTitle: string;
+        ImageAlt: string;
+        Calculating: string;
+        Size: {
+            Title: string;
+            width: string;
+            height: string;
+        };
+        CustomRatio: string;
+        ResetOriginal: string;
+        ResetOriginalConfirmation: string;
+        Message: {
+            InvalidCropzoneTitle: string;
+            InvalidCropzoneMessage: string;
+        };
+    }
+}

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

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

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

@@ -0,0 +1,128 @@
+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 searchable?: boolean;
+            readonly welcomeMessage?: boolean;
+            readonly infiniteScroll?: boolean;
+        };
+        $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<{
+            infiniteScroll: {
+                type: import("vue").PropType<boolean>;
+            };
+            welcomeMessage: {
+                type: import("vue").PropType<boolean>;
+            };
+            searchable: {
+                type: import("vue").PropType<boolean>;
+            };
+        }>>, () => JSX.Element, unknown, {}, {}, 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<{
+        infiniteScroll: {
+            type: import("vue").PropType<boolean>;
+        };
+        welcomeMessage: {
+            type: import("vue").PropType<boolean>;
+        };
+        searchable: {
+            type: import("vue").PropType<boolean>;
+        };
+    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    infiniteScroll: {
+        type: import("vue").PropType<boolean>;
+    };
+    welcomeMessage: {
+        type: import("vue").PropType<boolean>;
+    };
+    searchable: {
+        type: import("vue").PropType<boolean>;
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        searchable?: boolean;
+        welcomeMessage?: boolean;
+        infiniteScroll?: boolean;
+    }>, never>;
+};
+export default _default;

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

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

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

@@ -0,0 +1,64 @@
+import { IWebComponentInstance } from "../../../";
+import { MediaItem, ImageItem, VideoItem, ImageInformation, MediaPickerEnums, VideoInformation, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../../models";
+import { MediaProviderComponentBase } from "./MediaProviderComponentBase";
+import "./GridViewMediaProviderComponent.css";
+export interface GridViewMediaProviderComponentProps {
+}
+export interface GridViewMediaProviderComponentSlots<MediaItemType extends MediaItem> {
+    mediaSelectionTop?: () => JSX.Element;
+    mediaSelectionBottom?: () => JSX.Element;
+    mediaGridItemHover?: (item: MediaItemType) => JSX.Element;
+    mediaGridItemOverlay?: (item: MediaItemType) => JSX.Element;
+    customSlot?: () => JSX.Element;
+}
+export declare abstract class GridViewMediaProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, GridViewMediaProviderComponentProps {
+    /**
+     * Get media items by search keyword
+     * @param searchKeyword
+     */
+    abstract getMediaItems(searchKeyword: string): Promise<Array<ImageItem | VideoItem>>;
+    /**
+     * Get more media items when reached the last item in grid while scrolling
+     * @param lastLoadedIndex
+     */
+    abstract getMoreMediaItems(lastLoadedIndex: number): Promise<Array<ImageItem | VideoItem>>;
+    /**
+     * Return the information for selected media item in grid
+     * @param mediaItem
+     */
+    abstract getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
+    /**
+     * Manipulate the image result if needed before it is saved. Initiate the video result after video item is selected.
+     * @param resultToBeSaved
+     */
+    abstract beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerImageTransformationResult | MediaPickerVideo>;
+    protected gridViewSlots: GridViewMediaProviderComponentSlots<MediaItem>;
+    private allResults;
+    private mediaGridItems;
+    protected displayPageSize: number;
+    protected enableLoadMoreButton: boolean;
+    protected searchStatus: MediaPickerEnums.MediaSearchStatus;
+    private isShowRetryGetSelectedImageInfoDialog;
+    private gridComponentKey;
+    private imageItemToRetryDownload;
+    private isRetryingGetSelectedImageInfo;
+    private isUpdatingInfiniteScroll;
+    private noMoreResult;
+    private gridViewStyles;
+    constructor();
+    protected selectGridItem(mediaItem: ImageItem | VideoItem): void;
+    protected setAllItems(mediaItems: Array<ImageItem | VideoItem>): void;
+    protected setEmptyResultHandler(): void;
+    protected setSearchStatus(status: MediaPickerEnums.MediaSearchStatus): void;
+    private retryToGetSelectedImageInfo;
+    private handleSelectedMediaItem;
+    private getMediaItemChunks;
+    private onGridViewSearch;
+    private appendGridItems;
+    private onGridViewScroll;
+    private renderRetryGetImageInfoDialog;
+    private renderGridViewItemSelection;
+    private closeRetryGetImageInfoDialog;
+    protected renderLoadMoreButton(): JSX.Element;
+    protected renderGridViewProvider(): JSX.Element;
+}

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

@@ -0,0 +1,9 @@
+export declare const MediaProviderComponentBaseStyles: {
+    baseWrapper: string;
+    providerWrapper: string;
+    loadingProviderWrapper: string;
+    providerContent: string;
+    loadingOverlayWrapper: (darkBackground: boolean) => string;
+    loadingWrapper: string;
+    gridWrapper: string;
+};

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

@@ -0,0 +1,74 @@
+import { IWebComponentInstance, OmniaContext } from "../../../";
+import { MediaPickerImageSettings, MediaPickerEnums, ImageInformation, MediaPickerVideo, MediaPickerStorageProviderContext, GuidValue, MediaPickerMedia, MediaPickerImageTransformationResult, Future } from "../../../models";
+import { OmniaUxLocalization } from "../../UxModels";
+import { MediaPickerProviderComponentProps } from "../../mediapicker";
+import { VueComponentBase } from "../../VueComponentBase";
+import { SettingsService, WebImageService, MediaPickerService } from "../../../services";
+import { MediaProviderBaseLocalization } from "./loc/localize";
+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>;
+}
+export declare abstract class MediaProviderComponentBase extends VueComponentBase implements IWebComponentInstance, MediaPickerProviderComponentProps {
+    providerContext: MediaPickerStorageProviderContext;
+    providerId: GuidValue;
+    saved: (result: MediaPickerMedia) => void;
+    closed?: () => void;
+    imageSettings?: MediaPickerImageSettings;
+    preSelectedMedia?: MediaPickerVideo;
+    selectableMediaTypes?: Array<MediaPickerEnums.OmniaMediaTypes>;
+    setSearchKeyword: (value: string) => void;
+    uxLoc: OmniaUxLocalization;
+    mediaProviderBaseLoc: MediaProviderBaseLocalization.locInterface;
+    colors: ReturnType<typeof useColorSchemaStore>;
+    providerStore: ReturnType<typeof useMediaPickerProviderStore>;
+    /** Define method to get data based on search keyword. Null is to hide the search box in media picker. */
+    onSearch: (searchKeyword: string) => Promise<void>;
+    protected providerSlots: MediaProviderComponentBaseSlots;
+    protected onScroll: (payLoad: UIEvent) => void;
+    protected settingsService: SettingsService<any>;
+    protected webImageService: WebImageService;
+    protected omniaContext: OmniaContext;
+    protected mediaPickerService: MediaPickerService;
+    protected mediaPickerStore: MediaPickerStore;
+    protected multilingualStore: MultilingualStore;
+    private limitedSizeScalingSettings;
+    private imageTransformComponentInput;
+    private imageProviderResult;
+    private keepOriginalSizeOptionValue;
+    private selectedScalingOption;
+    private selectedImageScaling;
+    private isRetryingScalingImage;
+    private isShowRetryImageScalingDialog;
+    private isFileTypeIsNotSupportedDialog;
+    private isShowImageScalingDialog;
+    private selectedImageResolvablePromise;
+    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;
+    private setImageTransformInput;
+    private getImageScalingSettingsKey;
+    private onImageTransformResultChanged;
+    private ensureRemoveBase64Format;
+    private addNewImage;
+    private initLimitedSizeScalingSettings;
+    private checkIfFileSizeExceededLimitation;
+    private handleValidatedImage;
+    private handleImageScaling;
+    private retryToScaleImage;
+    private processLimitedImageFileSize;
+    private onImageScalingOptionSelected;
+    private handleSelectedScalingOptionFromDialog;
+    private resizeImage;
+    private closeImageScalingDialog;
+    private resolveSavingImagePromise;
+    private closeRetryImageScalingDialog;
+    private closeFileTypeIsNotSupportedDialog;
+    protected renderBase(getProviderSlotsFunc: () => Array<JSX.Element> | JSX.Element): JSX.Element;
+}

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

@@ -0,0 +1,2 @@
+export * from "./MediaProviderComponentBase";
+export * from "./GridViewMediaProviderComponent";