@omnia/fx 8.0.120-dev → 8.0.121-dev

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

@@ -0,0 +1,236 @@
+import { MediaPickerCropTransformation, MediaPickerImageRatio, MediaPickerRenditionData, ImageTransformerOptions, MediaPickerImageSettings, MediaPickerImageInformation, MediaPickerImageTransformationResult, MediaPickerTransformation, MediaPickerRollupImageRatio, MediaPickerFilterTransformation } from "@omnia/fx-models";
+import ImageEditor from "tui-image-editor";
+import { ImageRendition, MediaState } from "../../stores";
+import { IImageTransformHandler } from "../../interfaces";
+export declare const useMediaPickerImageTransformerStore: () => {
+    actions: {
+        onDispatching: {
+            resetState: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            changeEditingImage: {
+                subscribe(fn: (mediaState: MediaState) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transform: {
+                subscribe(fn: (options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedData: {
+                subscribe(fn: (options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedImageToGallery: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ratio: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBase64Image: {
+                subscribe(fn: (base64: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initUiOptions: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureImageRenditionData: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleImageTransformer: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transformImageFromSource: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initCropper: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            resetState: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            changeEditingImage: {
+                subscribe(fn: (result: void, mediaState: MediaState) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transform: {
+                subscribe(fn: (result: void, options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedData: {
+                subscribe(fn: (result: void, options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedImageToGallery: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ratio: {
+                subscribe(fn: (result: {
+                    addDefault(ratio: MediaPickerImageRatio): void;
+                    add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+                    loadRatios(): Promise<void>;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBase64Image: {
+                subscribe(fn: (result: void, base64: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initUiOptions: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureImageRenditionData: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleImageTransformer: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transformImageFromSource: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initCropper: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            resetState: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            changeEditingImage: {
+                subscribe(fn: (failureReason: any, mediaState: MediaState) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transform: {
+                subscribe(fn: (failureReason: any, options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedData: {
+                subscribe(fn: (failureReason: any, options: MediaPickerTransformation, handler: IImageTransformHandler) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateTransformedImageToGallery: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ratio: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBase64Image: {
+                subscribe(fn: (failureReason: any, base64: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initUiOptions: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureImageRenditionData: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleImageTransformer: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            transformImageFromSource: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            initCropper: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        resetState(): void;
+        changeEditingImage(mediaState: MediaState): void;
+        transform(options: MediaPickerTransformation, handler: IImageTransformHandler): void;
+        updateTransformedData(options: MediaPickerTransformation, handler: IImageTransformHandler): void;
+        /**
+         * Update the image transform back to the gallery
+         */
+        updateTransformedImageToGallery(): void;
+        /**
+         * Used after the image is transformed to update the image data transformation
+         * @param imageTransformHandler the image transform handler
+         * @param options options for specific transformation handler
+         */
+        ratio: () => {
+            addDefault(ratio: MediaPickerImageRatio): void;
+            add4Rollup(ratio: MediaPickerRollupImageRatio): void;
+            loadRatios(): Promise<void>;
+        };
+        /**
+         * Set the new base64 image
+         */
+        setBase64Image(base64: string): void;
+        /**
+         * initialize the image transformer
+         */
+        initUiOptions: () => void;
+        ensureImageRenditionData(): void;
+        toggleImageTransformer(show: boolean): void;
+        transformImageFromSource(): Promise<void>;
+        initCropper(): void;
+    };
+    events: {
+        onMutatedShowImageTransformer: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedImageRatios: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageRatio[]>;
+        onMutatedRollupRatios: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerRollupImageRatio[]>;
+        onMutatedEditorOptions: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageTransformerOptions>;
+        onMutatedSettings: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageSettings>;
+        onMutatedImageTransformedResult: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageTransformationResult>;
+        onMutatedCurrentImageFileInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageInformation>;
+        onMutatedUiOptions: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageTransformerOptions>;
+        onMutatedEditorInstance: import("@omnia/fx").MessageBusExposeOnlySubscription<ImageEditor>;
+        onMutatedSelectedCropArea: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerCropTransformation>;
+        onMutatedSelectedRatio: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerImageRatio>;
+        onMutatedSelectedRendition: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerRenditionData>;
+        onMutatedShowWarningCropInvalidDialog: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedCustomCropZone: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerCropTransformation>;
+        onMutatedCurrentFilter: import("@omnia/fx").MessageBusExposeOnlySubscription<MediaPickerFilterTransformation>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    mutate: {
+        showImageTransformer: (value: boolean | ((prev: boolean) => boolean)) => void;
+        imageRatios: (value: MediaPickerImageRatio[] | ((prev: MediaPickerImageRatio[]) => MediaPickerImageRatio[])) => void;
+        rollupRatios: (value: MediaPickerRollupImageRatio[] | ((prev: MediaPickerRollupImageRatio[]) => MediaPickerRollupImageRatio[])) => void;
+        editorOptions: (value: ImageTransformerOptions | ((prev: ImageTransformerOptions) => ImageTransformerOptions)) => void;
+        settings: (value: MediaPickerImageSettings | ((prev: MediaPickerImageSettings) => MediaPickerImageSettings)) => void;
+        imageTransformedResult: (value: MediaPickerImageTransformationResult | ((prev: MediaPickerImageTransformationResult) => MediaPickerImageTransformationResult)) => void;
+        currentImageFileInfo: (value: MediaPickerImageInformation | ((prev: MediaPickerImageInformation) => MediaPickerImageInformation)) => void;
+        uiOptions: (value: ImageTransformerOptions | ((prev: ImageTransformerOptions) => ImageTransformerOptions)) => void;
+        editorInstance: (value: ImageEditor | ((prev: ImageEditor) => ImageEditor)) => void;
+        selectedCropArea: (value: MediaPickerCropTransformation | ((prev: MediaPickerCropTransformation) => MediaPickerCropTransformation)) => void;
+        selectedRatio: (value: MediaPickerImageRatio | ((prev: MediaPickerImageRatio) => MediaPickerImageRatio)) => void;
+        selectedRendition: (value: MediaPickerRenditionData | ((prev: MediaPickerRenditionData) => MediaPickerRenditionData)) => void;
+        showWarningCropInvalidDialog: (value: boolean | ((prev: boolean) => boolean)) => void;
+        customCropZone: (value: MediaPickerCropTransformation | ((prev: MediaPickerCropTransformation) => MediaPickerCropTransformation)) => void;
+        currentFilter: (value: MediaPickerFilterTransformation | ((prev: MediaPickerFilterTransformation) => MediaPickerFilterTransformation)) => void;
+    };
+    get: {
+        renditions(): {
+            /**
+             *
+             * @returns the default rendition, which is the one that will be rendered on the page or anywhere
+             */
+            default: () => {
+                cropArea: () => MediaPickerCropTransformation;
+                ratioId(): number;
+            };
+            /**
+             *
+             * @returns the variants of the rendition, which is the one that will be rolled up
+             */
+            variants: () => {
+                getByRatioId: (ratioId: number) => MediaPickerRenditionData;
+                getCropAreaByRatioId: (ratioId: number) => MediaPickerCropTransformation;
+            };
+            current: () => ImageRendition;
+        };
+        editorInstance(): ImageEditor;
+        currentTransformation(): MediaPickerImageTransformationResult;
+        showImageEditingMenu: () => boolean;
+        ratio(): {
+            getById: (id: number) => MediaPickerImageRatio;
+        };
+    };
+    state: {
+        showImageTransformer: boolean;
+        imageRatios: MediaPickerImageRatio[];
+        rollupRatios: MediaPickerRollupImageRatio[];
+        editorOptions: ImageTransformerOptions;
+        settings: MediaPickerImageSettings;
+        imageTransformedResult: MediaPickerImageTransformationResult;
+        currentImageFileInfo: MediaPickerImageInformation;
+        uiOptions: ImageTransformerOptions;
+        editorInstance: ImageEditor;
+        selectedCropArea: MediaPickerCropTransformation;
+        selectedRatio: MediaPickerImageRatio;
+        selectedRendition: MediaPickerRenditionData;
+        showWarningCropInvalidDialog: boolean;
+        customCropZone: MediaPickerCropTransformation;
+        currentFilter: MediaPickerFilterTransformation;
+    };
+};
+export type ImageTransformerStore = ReturnType<typeof useMediaPickerImageTransformerStore>;

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

@@ -0,0 +1 @@
+export * from "./ImageTransformerStore";

package/internal-do-not-import-from-here/ux/mediapickerV2/interfaces/IImageTransformHandler.d.ts

@@ -0,0 +1,16 @@
+import { MediaPickerTransformation } from "@omnia/fx-models";
+/**
+ * Interface for image transform handlers
+ * Each handler must implement this interface
+ */
+export interface IImageTransformHandler {
+    /**
+     * @param options parameters needed for the transformation
+     */
+    transform(options: MediaPickerTransformation): Promise<void>;
+    /**
+     * Update the transformation data in the store
+     * @param options parameters needed for the transformation
+     */
+    updateTransformationData(options: MediaPickerTransformation): Promise<void>;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/interfaces/IMediaPickerGalleryHandler.d.ts

@@ -0,0 +1,10 @@
+import { MediaState } from "../stores";
+/**
+ * @description interface for the gallery handler
+ */
+export interface IMediaPickerGalleryHandler {
+    /**
+     * @description the handler for when a media is selected, which handles the way the media is updated/transformed
+     */
+    onSelectMedia: (index: number, media: MediaState) => void;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/interfaces/IMediaPickerProviderMediaHandler.d.ts

@@ -0,0 +1,56 @@
+import { GuidValue, ImageInformation, MediaItem, MediaPickerImageScaling, MediaPickerVideo } from "@omnia/fx-models";
+/**
+ * @description interface for media picker provider, which contains the logic for **handling the media picker provider** events
+ */
+export interface IMediaPickerProviderHandler {
+    /**
+     * @description handle select media event in the provider
+     * @param media the media that gets selected in the provider
+     */
+    selectMedia: (media: MediaItem | MediaPickerVideo) => Promise<void>;
+    /**
+     * @param searchKeyword handle the search event in the provider
+     * @returns {Promise<Array<MediaItem>>} the result of the search
+     */
+    search: (searchKeyword: string) => Promise<Array<MediaItem>>;
+    /**
+     * @description handle the search more event in the provider, when the user scrolls to the bottom of the search result
+     * @param searchQueryText search query text
+     * @param lastLoadedIndex index of the last loaded item
+     * @returns {Promise<Array<MediaItem>>} the result of the search
+     */
+    searchMore: (searchQueryText: string, lastLoadedIndex: number) => Promise<Array<MediaItem>>;
+}
+export type ProcessImageOptions = {
+    needScaling: boolean;
+    imageInfo: ImageInformation;
+    scalingOptions?: MediaPickerImageScaling;
+};
+export interface IMediaPickerImageProviderHandler extends IMediaPickerProviderHandler {
+    /**
+     * @description handle the image scaling event in the provider, when the user selects the image scaling option
+     * @param imageInfo the image info of the selected image
+     * @returns {Promise<boolean>} if the image needs scaling
+     */
+    handleImageScaling: (imageInfo: ImageInformation) => Promise<boolean>;
+    /**
+     * @description check if the image supports transformation, This is because we need to handle the event when user selecting scaling options in a provider
+     * @param imageInfo the image info of the selected image
+     * @returns {boolean} if the image supports transformation
+     */
+    processImageAndAddToGallery: (options: ProcessImageOptions) => Promise<void>;
+    /**
+     * @description handle the select image event in the provider, when the provider already process the image.
+     * @param imageInfo the image info of the selected image
+     */
+    selectImageInfo: (imageInfo: ImageInformation) => Promise<void>;
+}
+export interface IMediaPickerVideoProviderHandler extends IMediaPickerProviderHandler {
+    /**
+     * @description handle the update media event in the provider, when the user updates the media in the gallery
+     * @note This will probably be used only for video providers, because in omnia the video provider will update the video, while the image transformer will transform the image **NOT** the provider
+     * @param media This will be the media that gets updated in the gallery
+     * @param id the id of the media that gets updated in gallery store
+     */
+    updateMedia: (media: MediaItem | MediaPickerVideo, id: GuidValue) => Promise<void>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./IImageTransformHandler";
+export * from "./IMediaPickerGalleryHandler";
+export * from "./IMediaPickerProviderMediaHandler";

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

@@ -1,6 +1,4 @@
 export declare const MediaProviderStyles: {
-    loadingOverlayWrapper: (darkBackground: boolean) => string;
-    loadingProgressWrapper: string;
     searchBoxWrapper: string;
     message: {
         wrapper: string;

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

@@ -1,5 +1,18 @@
+import { VNode } from "vue";
+import { IMediaPickerProviderHandler } from "../interfaces";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        handler: {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        } & {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        };
+        "v-slots": import("vue").Prop<{
+            default?: import("../../DefineVueTypings").Slot<any[]>;
+        } & {
+            search?: () => VNode | JSX.Element;
+            provider?: () => VNode | JSX.Element;
+        }>;
         "infinite-scroll": {
             type: import("vue").PropType<boolean>;
         };
@@ -18,6 +31,17 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
         };
     }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        handler: {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        } & {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        };
+        "v-slots": import("vue").Prop<{
+            default?: import("../../DefineVueTypings").Slot<any[]>;
+        } & {
+            search?: () => VNode | JSX.Element;
+            provider?: () => VNode | JSX.Element;
+        }>;
         "infinite-scroll": {
             type: import("vue").PropType<boolean>;
         };
@@ -43,6 +67,17 @@ declare const _default: {
         M: {};
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
+        handler: {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        } & {
+            type: import("vue").PropType<IMediaPickerProviderHandler>;
+        };
+        "v-slots": import("vue").Prop<{
+            default?: import("../../DefineVueTypings").Slot<any[]>;
+        } & {
+            search?: () => VNode | JSX.Element;
+            provider?: () => VNode | JSX.Element;
+        }>;
         "infinite-scroll": {
             type: import("vue").PropType<boolean>;
         };
@@ -65,6 +100,17 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    handler: {
+        type: import("vue").PropType<IMediaPickerProviderHandler>;
+    } & {
+        type: import("vue").PropType<IMediaPickerProviderHandler>;
+    };
+    "v-slots": import("vue").Prop<{
+        default?: import("../../DefineVueTypings").Slot<any[]>;
+    } & {
+        search?: () => VNode | JSX.Element;
+        provider?: () => VNode | JSX.Element;
+    }>;
     "infinite-scroll": {
         type: import("vue").PropType<boolean>;
     };
@@ -84,11 +130,18 @@ declare const _default: {
     };
 }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
+        "v-slots"?: {
+            default?: import("../../DefineVueTypings").Slot<any[]>;
+        } & {
+            search?: () => VNode | JSX.Element;
+            provider?: () => VNode | JSX.Element;
+        };
         searchable?: boolean;
         welcomeMessage?: boolean;
         "welcome-message"?: boolean;
         infiniteScroll?: boolean;
         "infinite-scroll"?: boolean;
+        handler?: IMediaPickerProviderHandler;
     }>, never>;
 };
 export default _default;

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

@@ -0,0 +1,84 @@
+/**
+ * @description The store that holds the common state for the media picker
+ * At the time this store was created, the only common state was the loading flags
+ * This store should not depend on any other store in the media picker
+ */
+export declare const MediaPickerCommonStore: () => {
+    state: {
+        showLoadingOverlay: boolean;
+        showLoadingProgress: boolean;
+        enableMediaCaption: boolean;
+    };
+    events: {
+        onMutatedShowLoadingOverlay: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowLoadingProgress: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedEnableMediaCaption: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    mutate: {
+        showLoadingOverlay: (value: boolean | ((prev: boolean) => boolean)) => void;
+        showLoadingProgress: (value: boolean | ((prev: boolean) => boolean)) => void;
+        enableMediaCaption: (value: boolean | ((prev: boolean) => boolean)) => void;
+    };
+    actions: {
+        onDispatching: {
+            toggleLoadingOverlay: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleLoadingProgress: {
+                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showLoading: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            finishLoading: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            resetState: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            toggleLoadingOverlay: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleLoadingProgress: {
+                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showLoading: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            finishLoading: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            resetState: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            toggleLoadingOverlay: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toggleLoadingProgress: {
+                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            showLoading: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            finishLoading: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            resetState: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        toggleLoadingOverlay(show: boolean): void;
+        toggleLoadingProgress(show: boolean): void;
+        showLoading(): void;
+        finishLoading(): void;
+        resetState(): void;
+    };
+    get: {
+        isLoading: () => boolean;
+    };
+};