@omnia/fx 7.1.50-dev → 7.1.50

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

@@ -0,0 +1,15 @@
+import { MediaPickerMedia } from "@omnia/fx-models";
+export interface MediaDisplayRenderer {
+    media: MediaPickerMedia | MediaPickerMedia[];
+    imageRatioId?: number;
+    mediaStyle?: string | object | object[];
+    mediaClass?: string;
+    showCaption?: boolean;
+    thumbnailOnly?: boolean;
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MediaDisplayRenderer, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaDisplayRenderer, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<MediaDisplayRenderer, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaDisplayRenderer, never>;
+});
+export default _default;

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,14 @@
+import { MediaPickerMedia } from "@omnia/fx-models";
+export interface PhotoWallWithSliderDisplayRenderer {
+    media: Array<MediaPickerMedia>;
+    mediaData: string;
+    defaultVSlot: JSX.Element;
+    imageStyle: string;
+    disableDialog?: boolean;
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<PhotoWallWithSliderDisplayRenderer, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<PhotoWallWithSliderDisplayRenderer, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<PhotoWallWithSliderDisplayRenderer, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<PhotoWallWithSliderDisplayRenderer, never>;
+});
+export default _default;

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

@@ -1,6 +1,7 @@
 import { VueComponentBase } from "../VueComponentBase";
 import { IWebComponentInstance } from "internal/fx/runtime/core/InternalWebComponentBootstrapper";
-import { GuidValue, MediaPickerImage, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../models";
+import { MediaPickerImage, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../models";
+import { MediaPickerService } from "@omnia/fx/services";
 export interface IGalleryPanels {
     selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
     selectEvent: (index: number) => void;
@@ -8,7 +9,6 @@ export interface IGalleryPanels {
     removeItemEvent: (index: number) => void;
     activeIndex: number;
     addNewEvent: () => void;
-    setFocus: (setFocusEvent: () => void) => void;
 }
 export declare class GalleryPanels extends VueComponentBase<IGalleryPanels> implements IWebComponentInstance, IGalleryPanels {
     selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
@@ -17,24 +17,18 @@ export declare class GalleryPanels extends VueComponentBase<IGalleryPanels> impl
     removeItemEvent: (index: number) => void;
     activeIndex: number;
     addNewEvent: () => void;
-    setFocus: (setFocusEvent: () => void) => void;
+    mediaPickerService: MediaPickerService;
     private activeElement;
     private omniaUrl;
-    private activeId;
-    private media;
     created(): void;
-    onSelectedMediaChange(): void;
-    processMedia(): void;
     updated(): void;
     setActiveIndexIntoView(): void;
     getMediaPickerImageTransformationResultImg(media: MediaPickerImageTransformationResult, index: number): VueTsxSupport.JSX.Element;
     getVideoThumbnail(media: MediaPickerVideo, index: number): VueTsxSupport.JSX.Element;
-    getImgSource(media: MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo, index: number, id: GuidValue): VueTsxSupport.JSX.Element;
-    cloneElement(item: any): any;
-    renderMultiSelectPanel(media: Array<{
-        id: GuidValue;
-        media: MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo;
-    }>): VueTsxSupport.JSX.Element;
+    getImgSource(media: MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo, index: number): VueTsxSupport.JSX.Element;
+    getMediaPickerImage(img: MediaPickerImage, index: number): VueTsxSupport.JSX.Element;
+    private resolveImageUrl;
+    renderMultiSelectPanel(media: Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>): VueTsxSupport.JSX.Element;
     private onMediaSelect;
     private onOrdinalChange;
     render(): VueTsxSupport.JSX.Element;

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

@@ -19,6 +19,7 @@ export interface IMediaPicker {
     dialog?: boolean;
     enableGallery?: boolean;
     itemLimit?: number;
+    enableMediaCaption?: boolean;
 }
 declare global {
     namespace VueTsxSupport.JSX {

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

@@ -5,10 +5,11 @@ export declare const MediaPickerStyles: {
     iconSvg: string;
     iconWrapper: string;
     providerWrapper: string;
-    toolbarTitle: string;
+    toolbarTitle: (width: string) => string;
+    toolbarFiller: (width: string) => string;
     selectedProvider: (bgColor: string) => string;
-    multiPanelNavigationDrawer: string;
-    navigationDrawer: string;
+    multiPanelNavigationDrawer: (width: string) => string;
+    navigationDrawer: (width: any) => string;
     bodyWrapper: (showGallery: boolean) => string;
     body: string;
     elementWrapper: string;

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

@@ -13,6 +13,7 @@ export declare class MediaPicker extends VueComponentBase<IMediaPicker> implemen
     dialog: boolean;
     enableGallery: boolean;
     itemLimit: number;
+    enableMediaCaption?: boolean;
     mounted(): void;
     private renderRenderer;
     render(): VueTsxSupport.JSX.Element;

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

@@ -17,6 +17,8 @@ export interface MediaPickerProviderComponentProps {
     /** Set the search keyword value and execute the onSearch method */
     setSearchKeyword: (value: string) => void;
     onChanged: (state: any) => void;
+    /**Enable caption for media */
+    enableMediaCaption?: boolean;
 }
 export interface MediaPickerImageTransformerProps {
     sourceImage: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
@@ -27,4 +29,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,7 +1,7 @@
 import { IMediaPicker } from "@omnia/fx/ux";
 import { OmniaContext } from "../../";
 import { SubscriptionHandler } from "../../core";
-import { MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerRenditionData, MediaPickerStorageProviderContext, MediaPickerTransformedBase64Image, MediaPickerVideo } from "../../models";
+import { GuidValue, MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerImageTransformationResult, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerRenditionData, MediaPickerStorageProviderContext, MediaPickerTransformedBase64Image, MediaPickerVideo } from "../../models";
 import { MediaPickerService, SettingsService } from "../../services";
 import { MediaPickerStore, MultilingualStore } from "../../stores";
 import { VueComponentBase, VueComponentBaseProps } from "../VueComponentBase";
@@ -26,6 +26,7 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     closed?: () => void;
     enableGallery: boolean;
     itemLimit: number;
+    enableMediaCaption?: boolean;
     protected settingsService: SettingsService<MediaPickerLimitedSizeSettings>;
     omniaContext: OmniaContext;
     multilingualStore: MultilingualStore;
@@ -50,6 +51,7 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     private mediaStates;
     private cacheKey;
     private galleryPanelRefreshKey;
+    private finishItemCount;
     isSearching: boolean;
     hasLoadedInfiniteScrollHandler: boolean;
     searchTimeout: any;
@@ -63,6 +65,7 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     private transformerResults;
     private menuItems;
     private registeredProviders;
+    private readonly navigationDrawerWidth;
     created(): void;
     private processMediaGallery;
     private initMediaState;
@@ -83,7 +86,7 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     private onSelectMenuItem;
     private onChangedExistedImage;
     private getMediaProvider;
-    CurrentRendition(): [MediaPickerRenditionData[], MediaPickerTransformedBase64Image];
+    CurrentRendition(): [GuidValue, MediaPickerRenditionData[], MediaPickerTransformedBase64Image];
     setActiveEditingMedia(index: number): void;
     private onMediaOrderChange;
     onEditingMediaIndexChange(): void;
@@ -92,15 +95,15 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     private updateMediaToServer;
     private saveMediaToServer;
     private onStateChange;
-    panelRef: import("vue").Ref<{}>;
-    focusEvent: () => void;
-    setFocusEvent(focusEvent: () => void): void;
+    panelRef: import("vue").Ref<any>;
     renderMenuItems(): VueTsxSupport.JSX.Element[];
     onNewMediaBtnClick(): void;
+    getData(): (MediaPickerImage | MediaPickerImageTransformationResult | MediaPickerVideo)[];
     renderMultiSelectPanel(): VueTsxSupport.JSX.Element;
     renderLeftMenu(): VueTsxSupport.JSX.Element;
     renderActionButtons(buttons: Array<MediaPickerActionButton>): JSX.Element[];
     private renderEditImageForm;
+    private deSelectMediaItemPanel;
     private renderActivedProvider;
     private onCreatedProviderComponent;
     private activedProviderComponent;

package/internal-do-not-import-from-here/ux/mediapickerimage/IMediaPickerImage.d.ts

@@ -16,10 +16,16 @@ export interface IMediaPickerImage {
     * The scaling to use for the image
     * */
     scalingId?: number;
+    /**
+     * Specify if image is contain or cover
+     */
+    contain?: boolean;
     avatar?: {
         size: number;
     };
     displayVSlot?: boolean;
+    containerClass?: string;
+    showCaption?: boolean;
 }
 declare global {
     namespace VueTsxSupport.JSX {

package/internal-do-not-import-from-here/ux/mediapickerimage/MediaPickerImage.css.d.ts

@@ -1,3 +1,4 @@
 export declare const MediaPickerImageStyles: {
     wrapper: string;
+    imgCaption: string;
 };

package/internal-do-not-import-from-here/ux/mediapickerimage/MediaPickerImage.d.ts

@@ -14,7 +14,13 @@ export declare class MediaPickerImageComponent extends VueComponentBase<IMediaPi
         size: number;
     };
     displayVSlot?: boolean;
+    contain: boolean;
+    containerClass?: string;
+    showCaption?: boolean;
+    imgClass: string;
     mediaPickerService: MediaPickerService;
+    private omniaUrl;
+    private isLoading;
     created(): void;
     mounted(): void;
     onImagedataChanged(imagejson: string): void;

package/internal-do-not-import-from-here/ux/mediapickerproviders/MicrosoftStream/loc/localize.d.ts

@@ -14,6 +14,8 @@ export declare module MicrosoftStreamProviderLocalization {
             AutoPlay: string;
             Responsive: string;
             ShowInfo: string;
+            VideoInformation: string;
+            VideoCaption: string;
         };
         Message: {
             InvalidInputStartTime: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/Youtube/YouTubeProvider.d.ts

@@ -17,6 +17,7 @@ export declare class YouTubeProviderComponent extends MultiSelectMediaProviderCo
     private enableStartTime;
     private omniaUrl;
     private validateMessage;
+    private caption;
     private rules;
     $refs: {
         startTime: any;

package/internal-do-not-import-from-here/ux/mediapickerproviders/Youtube/loc/localize.d.ts

@@ -17,6 +17,8 @@ export declare module YouTubeProviderLocalization {
             Mute: string;
             Responsive: string;
             ShowInfo: string;
+            VideoInformation: string;
+            VideoCaption: string;
         };
         Message: {
             InvalidInputStartTime: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/DallEProvider.css.d.ts

@@ -1,3 +1,5 @@
+import { types } from "typestyle";
+import { ITheming } from "@omnia/fx/ux";
 export declare const imageSize = 357.25;
 export declare const DallEProviderStyles: {
     wrapper: string;
@@ -14,6 +16,19 @@ export declare const DallEProviderStyles: {
     DallEFilterContentErrorWrapper: string;
     ErrorIcon: string;
     promptTip: string;
+    FullHeight: string;
+};
+export declare const dallEImageGridStyles: {
+    row?: types.NestedCSSProperties;
+    column?: types.NestedCSSProperties;
+    imageWrapper?: types.NestedCSSProperties;
+    image?: types.NestedCSSProperties;
+    noResultsWrapper: types.NestedCSSProperties;
+    noResultsPositioner: types.NestedCSSProperties;
+    noResultsText: (theme: ITheming) => types.NestedCSSProperties;
+    overlay?: types.NestedCSSProperties;
+    backgroundColor?: types.NestedCSSProperties;
+    defaultOverlay?: types.NestedCSSProperties;
 };
 export declare const MediaProviderComponentBaseStyles: {
     baseWrapper: string;

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/DallEProvider.d.ts

@@ -1,12 +1,13 @@
 import { OmniaTheming } from "@omnia/fx/ux";
-import { IWebComponentInstance } from "@omnia/fx";
+import { IWebComponentInstance, OmniaContext } from "@omnia/fx";
 import { type OmniaUxLocalization } from "@omnia/fx/ux";
 import { GridViewMediaProviderComponent } from "../mediaproviderbase/GridViewMediaProviderComponent";
-import { ImageInformation, VideoItem, ImageItem, MediaPickerVideo, VideoInformation, MediaPickerImageTransformationResult } from "../../../models";
+import { ImageInformation, VideoItem, ImageItem, MediaPickerVideo, VideoInformation, MediaPickerImageTransformationResult, IBusinessProfile } from "../../../models";
 import { AzureOpenAIService } from "../../../services";
 import { DallEProviderLocalization } from "./loc/localize";
 import { TextToImageRequest, GeneratedImage, TextToImageResponse } from "@omnia/fx-models";
 import "./DallEProvider.css";
+import { MultilingualStore } from "@omnia/fx/stores";
 export default class DallEProvider extends GridViewMediaProviderComponent implements IWebComponentInstance {
     beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
     getMediaItems(searchKeyword: string): Promise<GeneratedImage[]>;
@@ -15,6 +16,9 @@ export default class DallEProvider extends GridViewMediaProviderComponent implem
     setEmptyResultHandler(): void;
     azureOpenAiService: AzureOpenAIService;
     omniaTheming: OmniaTheming;
+    private aiSettingsService;
+    omniaCtx: OmniaContext;
+    multilingualStore: MultilingualStore;
     dallELoc: DallEProviderLocalization.locInterface;
     omniaUxLoc: OmniaUxLocalization;
     private searchKeyword;
@@ -24,17 +28,26 @@ export default class DallEProvider extends GridViewMediaProviderComponent implem
     private resultStyles;
     private selectedImageResolution;
     private textToImageResponseMap;
+    private dallEPredefinedPromptList;
+    private preDefinedPrompt;
+    private preDefaultPrompt;
+    private dallEConstant;
+    private displayPrompts;
     private getTextToImageRequest;
     constructor();
     created(): void;
     mounted(): void;
+    initDallEPromptSettingsListing(businessProfileId: IBusinessProfile): Promise<void>;
     onGenerateImage(): void;
     onPressEnter: (event: KeyboardEvent) => void;
+    getPredefinedPrompts(predefinedPrompt: string): void;
     selectGridItemPublic(item: GeneratedImage): void;
     addGeneratedImage(item: GeneratedImage, textToImageRequest: TextToImageRequest): void;
     addTextToImageResponse(item: TextToImageResponse, textToImageRequest: TextToImageRequest): void;
     onRegenerateImage(textToImageRequest: TextToImageRequest): void;
     private renderCustomSlot;
+    private getPredefinedPromptsItem;
+    private renderPredefinedPrompts;
     private renderPromptInput;
     render(): VueTsxSupport.JSX.Element;
 }

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/PollingImageComponent.d.ts

@@ -7,6 +7,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
     onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
     textToImageResponse: TextToImageResponse;
     addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
 }, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
         textToImageRequest: TextToImageRequest;
@@ -16,6 +18,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
         onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
         textToImageResponse: TextToImageResponse;
         addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+        imageRef: HTMLImageElement;
+        setImageRef: (imageRef: HTMLImageElement) => void;
     }, never>;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
     textToImageRequest: TextToImageRequest;
@@ -25,6 +29,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
     onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
     textToImageResponse: TextToImageResponse;
     addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+    imageRef: HTMLImageElement;
+    setImageRef: (imageRef: HTMLImageElement) => void;
 }, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
         textToImageRequest: TextToImageRequest;
@@ -34,6 +40,8 @@ declare const _default: (import("vue").VueConstructor<import("vue-tsx-support").
         onRegenerateImage: (textToImageRequest: TextToImageRequest) => void;
         textToImageResponse: TextToImageResponse;
         addTextToImageResponse: (textToImageResponse: TextToImageResponse, textToImageRequest: TextToImageRequest) => void;
+        imageRef: HTMLImageElement;
+        setImageRef: (imageRef: HTMLImageElement) => void;
     }, never>;
 });
 export default _default;

package/internal-do-not-import-from-here/ux/mediapickerproviders/dalleprovider/loc/localize.d.ts

@@ -18,5 +18,6 @@ export declare module DallEProviderLocalization {
         PromptContent: string;
         PromptExample: string;
         Label: string;
+        ImageStyle: string;
     }
 }

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/MediaflowProvider.d.ts

@@ -0,0 +1,47 @@
+import { IWebComponentInstance, OmniaContext } from "@omnia/fx";
+import { MultiSelectMediaProviderComponentBase } from "@omnia/fx/ux";
+import { MediaPickerImageTransformationResult, MediaPickerVideo, VideoInformation } from "@omnia/fx-models";
+import { MediaflowService } from "./service/MediaflowService";
+import { MediaflowProviderStore } from "./store/MediaflowProviderStore";
+import "./MediaflowProviderStyles.css";
+import { MediaFlowImage, MediaFlowVideo, MediaflowEventData, MediaflowImageInformation, MediaflowVideoInfo } from "./models";
+export declare class MediaflowProvider extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance {
+    mediaflowStore: MediaflowProviderStore;
+    mediaflowService: MediaflowService;
+    omniaContext: OmniaContext;
+    private loc;
+    private loadedMediaFlowJS;
+    private loadedMediaFlowCSS;
+    private containerIsSetup;
+    private isTransformImage;
+    private settings;
+    private authenticationInfo;
+    private settingsLoaded;
+    private static mediaflowClientScriptId;
+    private lastSelectedFolderId;
+    private get mediaflowLoaded();
+    private mediafileSelector;
+    private mediaflowRefElement;
+    private omniaDns;
+    constructor();
+    created(): void;
+    loadMediaflowClient(): void;
+    loadScript(url: any): Promise<any>;
+    mounted(): void;
+    updated(): void;
+    private makeMediaflowUIFullScreen;
+    onContainerIsSetupChanged(): void;
+    beforeDestroy(): void;
+    beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerVideo | MediaPickerImageTransformationResult>;
+    private getLocale;
+    private setupMediaContainer;
+    handleMediaflowEvent(eventName: string, eventData: MediaflowEventData): void;
+    saveMediaflowMedia(): void;
+    handleImageSelection(source: any): void;
+    fixEmbedHtmlForTextArea(htmlString: string): string;
+    downloadImage(source: MediaFlowImage): Promise<MediaflowImageInformation>;
+    buildHtml: (videoSource: MediaFlowVideo, videoInfo: MediaflowVideoInfo) => string;
+    extractSrcFromIframeHtmlString(iframeHtml: string): string;
+    render(): VueTsxSupport.JSX.Element;
+    renderMediaflowContainer(): VueTsxSupport.JSX.Element;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/MediaflowProviderStyles.css.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Styles for the MediaflowProvider component
+ */
+export declare const MediaflowProviderStyles: {
+    sampleStyle: string;
+};
+export declare const overwriteStyles: {
+    cssRaw: void;
+};

package/internal-do-not-import-from-here/ux/{compositiontests/CompositionBlockFuture.d.ts → mediapickerproviders/mediaflow/MediaflowVideoPlayer.d.ts}

@@ -1,18 +1,14 @@
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    title: string;
-    name: string;
-}, "name">, any, any, any>> & {
+    video: String;
+}, "video">, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
-        title: string;
-        name: string;
-    }, "name">;
+        video: String;
+    }, "video">;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
-    title: string;
-    name: string;
-}, "name">, any, any, any>> & {
+    video: String;
+}, "video">, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<{
-        title: string;
-        name: string;
-    }, "name">;
+        video: String;
+    }, "video">;
 });
 export default _default;

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/loc/localize.d.ts

@@ -0,0 +1,25 @@
+export declare module MediaflowLocalization {
+    const namespace = "Omnia.Ux.MediaflowProvider";
+    interface locInterface {
+        Settings: {
+            MainHeader: string;
+            AuthenticationSectionHeader: string;
+            MediaSectionHeader: string;
+            ClientIdHeader: string;
+            ClientSecretHeader: string;
+            RefreshtokenHeader: string;
+            DefaultLanguageHeader: string;
+            ShowUnsafeGDPRHeader: string;
+            ShowUnassignedGDPRHeader: string;
+            LimitFormatHeader: string;
+            SaveButton: string;
+        };
+        Features: {
+            MediaflowFeature: string;
+            Description: string;
+        };
+        Mediapicker: {
+            IframeMsg: string;
+        };
+    }
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowEmbedMethods.d.ts

@@ -0,0 +1,4 @@
+export declare class EmbededMethod {
+    static IFrame: string;
+    static Javascript: string;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowMedia.d.ts

@@ -0,0 +1,31 @@
+export declare class MediaflowBaseType {
+    static Image: string;
+    static Video: string;
+    static ExternalVideo: string;
+}
+export interface MediaflowInformation {
+    basetype?: string;
+    filename?: string;
+    filetype?: string;
+    id: number;
+    mediaId: string;
+}
+export interface MediaFlowImage extends MediaflowInformation {
+    height: number;
+    name: string;
+    photographer: string;
+    url: string;
+    width: number;
+}
+export interface MediaFlowVideo extends MediaflowInformation {
+    autoPlay: boolean;
+    embedCode: any;
+    embedMethod: string;
+    startTime: string;
+}
+export interface MediaflowEventData {
+    id: number;
+    name: string;
+    mediaId?: string;
+    isSearch?: boolean;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowResponse.d.ts

@@ -0,0 +1,8 @@
+import { ImageInformation, MediaPickerVideo } from "@omnia/fx-models";
+import { MediaflowInformation } from "./MediaflowMedia";
+export interface MediaflowVideoResult extends MediaPickerVideo, MediaflowInformation {
+    folderId: number;
+}
+export interface MediaflowImageInformation extends ImageInformation, MediaflowInformation {
+    folderId: number;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowVideoInfo.d.ts

@@ -0,0 +1,27 @@
+export interface Hlss {
+    src: string;
+}
+export interface Mp4s {
+    size: number;
+    src: string;
+}
+export interface MediaflowVideoInfo {
+    id: number;
+    title: string;
+    type: string;
+    hls: boolean;
+    hlss: Hlss[];
+    mp4: boolean;
+    mp4s: Mp4s[];
+    sign: any[];
+    audioTracks: any[];
+    videoTracks: any[];
+    vp: boolean;
+    duration: number;
+    statsURL: string;
+    width: number;
+    height: number;
+    native: string;
+    subtitles: any[];
+    poster: string;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/MediaflowVideoPlayerProps.d.ts

@@ -0,0 +1,9 @@
+export interface MediaflowVideoPlayerProps {
+    embedMethod: string;
+    title: string;
+    poster: string;
+    id: number;
+    embedCode?: string;
+    iframeSrc?: string;
+    autoPlay: boolean;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./MediaflowMedia";
+export * from "./MediaflowResponse";
+export * from "./MediaflowVideoInfo";
+export * from "./MediaflowEmbedMethods";
+export * from "./MediaflowVideoPlayerProps";

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/service/MediaflowService.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from "@omnia/fx";
+import { MediaflowVideoInfo } from "../models";
+export declare class MediaflowService {
+    protected httpClient: HttpClient;
+    private baseUrl;
+    getVideoInfo: (mediaId: string) => Promise<MediaflowVideoInfo>;
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/mediaflow/store/MediaflowProviderStore.d.ts

@@ -0,0 +1,29 @@
+import { Store } from "@omnia/fx/stores";
+import { OmniaContext } from "@omnia/fx";
+import { MediaflowAuthenticationInfo, MediaflowSettings } from "@omnia/fx-models";
+import { SettingsService, SecretsService } from "@omnia/fx/services";
+export declare class MediaflowProviderStore extends Store {
+    settingService: SettingsService<MediaflowSettings>;
+    secretService: SecretsService;
+    omniaContext: OmniaContext;
+    private settings;
+    private authenticationInfo;
+    private mediaflowSecretKey;
+    private mediaflowSettingKey;
+    constructor();
+    getters: {
+        getSettings: () => MediaflowSettings;
+        getAuthenticationInfo: () => MediaflowAuthenticationInfo;
+    };
+    actions: {
+        loadSettings: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: any) => void, (failureReason: any) => void, () => Promise<any>>;
+        loadAuthenticationInfo: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    mutations: {
+        setSetting: import("@omnia/fx/stores").StoreMutation<(item: MediaflowSettings) => void, (item: MediaflowSettings) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setAuthenticationInfo: import("@omnia/fx/stores").StoreMutation<(item: MediaflowAuthenticationInfo) => void, (item: MediaflowAuthenticationInfo) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    private extractAuthenticationInfoFromSecret;
+}