@omnia/fx 7.11.32 → 7.12.1

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/LayoutCanvasStore.d.ts

@@ -155,7 +155,16 @@ export declare class LayoutCanvasStore extends Store implements ILayoutCanvasSto
     private addItem;
     private moveItem;
     private copyItem;
+    private ensureLayoutItemChildren;
     private changeIdAndCopyData;
+    /**
+     * Regenerates the ids of any inline theme definitions on a settings object so that a copied
+     * section/block/layout does not share a theme target id with its source. Theming instances are
+     * keyed by these ids in the theme store, so a shared id makes two items resolve the same mutable
+     * theming instance and bleed into one another. Mirrors LayoutManager.updateThemingId for the
+     * copy/paste/clipboard path.
+     */
+    private regenerateThemeDefinitionIds;
     private addItemAtCorrectSibling;
     private getLayoutItemFromParentLayout;
     private getBlocks;

package/internal-do-not-import-from-here/ux/layoutcanvas/stores/LayoutTemplateStore.d.ts

@@ -1,15 +1,18 @@
 import { Store } from "../../../stores";
-import { LayoutTemplateRegistration } from "../../../models";
+import { LayoutDefinitionContext, LayoutTemplateRegistration } from "../../../models";
 import { LocalizationService } from "../../../services";
 export declare class LayoutTemplateStore extends Store {
     localizationService: LocalizationService;
     private resolvableRegistrationTemplates;
+    private validatorInstances;
     registrations: import("../../../stores").StoreState<LayoutTemplateRegistration[]>;
     onActivated(): void;
     onDisposing(): void;
     areItemsLoaded(): boolean;
     getters: {
-        searchTemplates: (searchText: string) => LayoutTemplateRegistration[];
+        getValidTemplates: (context?: LayoutDefinitionContext) => Array<LayoutTemplateRegistration>;
+        isTemplateValid: (item: LayoutTemplateRegistration, context?: LayoutDefinitionContext) => boolean;
+        searchTemplates: (searchText: string, context?: LayoutDefinitionContext) => LayoutTemplateRegistration[];
     };
     /**
      * Implementation of mutations
@@ -22,4 +25,5 @@ export declare class LayoutTemplateStore extends Store {
     };
     private ensureLoadTemplates;
     private setTemplates;
+    private isTemplateValid;
 }

package/internal-do-not-import-from-here/ux/letteravatar/ILetterAvatar.d.ts

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "..";
 export interface ILetterAvatarProperties {
     name?: string;
     size?: number;
@@ -8,16 +7,3 @@ export interface ILetterAvatarProperties {
 export interface ILetterAvatar extends ILetterAvatarProperties {
     [name: string]: any;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-letter-avatar": TsxAllowUnknowProperties<ILetterAvatar>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/letteravatar/LetterAvatar.d.ts

@@ -1,21 +1,12 @@
-import Vue from "vue";
-import { IWebComponentInstance } from "../..";
-import { ILetterAvatar } from "./ILetterAvatar";
-export declare class LetterAvatar extends Vue implements IWebComponentInstance, ILetterAvatar {
+export interface LetterAvatarProps {
     name: string;
     size: number;
     color: string;
     rounded?: boolean;
-    private initals;
-    private backGroundColor;
-    static colors: string[];
-    private dataURI;
-    onNameUpdate(): void;
-    setBackgroundColor(): void;
-    mounted(): void;
-    getImageDataURI(): void;
-    getInitials(input: string): string;
-    getInitial(word: string): string;
-    startWithAlphanumeric(input: string): boolean;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const LetterAvatar: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<LetterAvatarProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LetterAvatarProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<LetterAvatarProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LetterAvatarProps, never>;
+});
+export default LetterAvatar;

package/internal-do-not-import-from-here/ux/magiclink/Shared.d.ts

@@ -7,5 +7,6 @@ export declare enum MagicLinkCompleteType {
 }
 export declare enum MagicLinkFailureType {
     ExpiredError = 0,
-    SelfServiceEmailIsUsed = 1
+    SelfServiceEmailIsUsed = 1,
+    InvalidLink = 2
 }

package/internal-do-not-import-from-here/ux/mediagallery/gallerydialogproviders/slider/Delimiter.d.ts

@@ -7,6 +7,7 @@ export interface CarouselDelimiter {
 export interface ThumbnailMetadata {
     src: string;
     isVideo: boolean;
+    alt: string;
 }
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<CarouselDelimiter, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<CarouselDelimiter, never>;

package/internal-do-not-import-from-here/ux/mediagallery/galleryviewproviders/photowall/components/CollageMetadata.d.ts

@@ -1,4 +1,4 @@
-import { PhotoWallDirection } from "internal/fx/models/media-gallery";
+import { PhotoWallDirection } from "omniaapp/fx/models/media-gallery";
 export interface CollageMetadata {
     borderRadius: string;
     direction: PhotoWallDirection;

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

@@ -2,7 +2,7 @@ import { MediaPickerMedia } from "@omnia/fx-models";
 export interface PhotoWallWithSliderDisplayRenderer {
     media: Array<MediaPickerMedia>;
     mediaData: string;
-    defaultVSlot: JSX.Element;
+    defaultVSlot: VueTsxSupport.JSX.Element;
     imageStyle: string;
     disableDialog?: boolean;
     inlineMediaNodeDisplayData?: string;

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

@@ -1,6 +1,3 @@
-import { IWebComponentInstance } from "internal/fx/runtime/core/InternalWebComponentBootstrapper";
-import { VueComponentBase } from "../VueComponentBase";
-import { MediaPickerService } from "@omnia/fx/services";
 import { MediaPickerImage, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../models";
 export interface IGalleryPanels {
     selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
@@ -10,27 +7,12 @@ export interface IGalleryPanels {
     activeIndex: number;
     addNewEvent: () => void;
 }
-export declare class GalleryPanels extends VueComponentBase<IGalleryPanels> implements IWebComponentInstance, IGalleryPanels {
+export interface GalleryPanelsProps {
     selectedMedia: (Array<MediaPickerImageTransformationResult | MediaPickerImage | MediaPickerVideo>);
     orderChange: (oldIndex: number, newIndex: number) => void;
     selectEvent: (index: number) => void;
     removeItemEvent: (index: number) => void;
     activeIndex: number;
     addNewEvent: () => void;
-    mediaPickerService: MediaPickerService;
-    private uxLoc;
-    private activeElement;
-    private omniaUrl;
-    created(): 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): 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;
 }
+export declare const GalleryPanels: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<GalleryPanelsProps, never>, any, any, any>;

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

@@ -1,8 +1,7 @@
-import { MediaPickerMedia, MediaPickerImageSettings, MediaPickerStorageProviderContext, MediaPickerProvider, MediaPickerEnums } from "../../models";
-import { TsxAllowUnknowProperties } from "../";
+import { MediaPickerMedia, MediaPickerImageSettings, MediaPickerImageTransformationResult, MediaPickerStorageProviderContext, MediaPickerProvider, MediaPickerEnums } from "../../models";
 export interface IMediaPicker {
     /** Selected media */
-    selectedMedia?: MediaPickerMedia | Array<MediaPickerMedia>;
+    selectedMedia?: MediaPickerMedia | MediaPickerImageTransformationResult | Array<MediaPickerMedia | MediaPickerImageTransformationResult>;
     /** Indicate web application service ID and the needed properties to handle image */
     providerContext: MediaPickerStorageProviderContext;
     /** Image settings for picking images */
@@ -21,16 +20,3 @@ export interface IMediaPicker {
     itemLimit?: number;
     enableMediaCaption?: boolean;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-media-picker": TsxAllowUnknowProperties<IMediaPicker>;
-        }
-    }
-}

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

@@ -1,11 +1,8 @@
-import { IWebComponentInstance } from "../../";
-import { MediaPickerEnums, MediaPickerImage, type MediaPickerImageSettings, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo } from "../../models";
-import { VueComponentBase } from "../VueComponentBase";
-import { IMediaPicker } from "./IMediaPicker";
-export declare class MediaPicker extends VueComponentBase<IMediaPicker> implements IWebComponentInstance, IMediaPicker {
+import { MediaPickerEnums, MediaPickerImage, type MediaPickerImageSettings, MediaPickerImageTransformationResult, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo } from "../../models";
+export interface MediaPickerProps {
     selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
     providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
-    selectedMedia?: MediaPickerImage | MediaPickerVideo | Array<MediaPickerImage | MediaPickerVideo>;
+    selectedMedia?: MediaPickerImage | MediaPickerVideo | MediaPickerImageTransformationResult | Array<MediaPickerImage | MediaPickerVideo | MediaPickerImageTransformationResult>;
     providerContext: MediaPickerStorageProviderContext;
     imageSettings?: MediaPickerImageSettings;
     saved: (result: MediaPickerMedia) => void;
@@ -14,10 +11,10 @@ export declare class MediaPicker extends VueComponentBase<IMediaPicker> implemen
     enableGallery: boolean;
     itemLimit: number;
     enableMediaCaption?: boolean;
-    private focusStore;
-    mounted(): void;
-    private onClose;
-    private onSave;
-    private renderRenderer;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const MediaPicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MediaPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaPickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<MediaPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaPickerProps, never>;
+});
+export default MediaPicker;

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

@@ -30,4 +30,6 @@ export interface MediaPickerImageTransformerProps {
     nisse: any;
     testThis: any;
     showCaption: boolean;
+    requireAltText?: boolean;
+    validateAltText?: boolean;
 }

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

@@ -1,25 +1,13 @@
-import { IMediaPicker } from "@omnia/fx/ux";
-import { OmniaContext } from "../../";
-import { SubscriptionHandler } from "../../core";
-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";
-import { MediaPickerLocalization } from "./loc/localize";
-declare interface MediaPickerActionButton {
-    text: string;
-    show: boolean;
-    onClick: any;
-    icon?: string;
-    iconLeft?: boolean;
-    loading?: boolean;
-    highLighted?: boolean;
-    leftAligned?: boolean;
+import { GuidValue, MediaPickerEnums, MediaPickerImage, MediaPickerImageSettings, MediaPickerImageTransformationResult, MediaPickerMedia, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerVideo, ProviderMetadata } from "../../models";
+interface StagedMediaPickerImage extends MediaPickerImageTransformationResult {
+    providerId?: GuidValue;
+    providerMetadata?: ProviderMetadata;
 }
-export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker & VueComponentBaseProps> {
+type MediaPickerSelection = MediaPickerImage | MediaPickerVideo | StagedMediaPickerImage;
+export interface MediaPickerRendererProps {
     selectableMediaTypes: MediaPickerEnums.OmniaMediaTypes[];
     providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
-    selectedMedia?: Array<MediaPickerImage | MediaPickerVideo> | MediaPickerImage | MediaPickerVideo;
+    selectedMedia?: Array<MediaPickerSelection> | MediaPickerSelection;
     providerContext: MediaPickerStorageProviderContext;
     imageSettings?: MediaPickerImageSettings;
     saved: (result: MediaPickerMedia | Array<MediaPickerMedia>) => void;
@@ -27,93 +15,6 @@ export declare class MediaPickerRenderer extends VueComponentBase<IMediaPicker &
     enableGallery: boolean;
     itemLimit: number;
     enableMediaCaption?: boolean;
-    protected settingsService: SettingsService<MediaPickerLimitedSizeSettings>;
-    omniaContext: OmniaContext;
-    multilingualStore: MultilingualStore;
-    private localizationService;
-    subscriptionHandler: SubscriptionHandler;
-    loc: MediaPickerLocalization.locInterface;
-    private uxLoc;
-    mediaPickerService: MediaPickerService;
-    mediaPickerStore: MediaPickerStore;
-    private id_search;
-    private defaultEditImageMenuId;
-    private selectedMediasMenuId;
-    private activedMenuItemId;
-    private activedProvider;
-    private transformerElementName;
-    private editingImageActionButtons;
-    private convertingFromBase64ToMediaPicker;
-    private imgThatNeedToConvertFromBase64ToMediaPicker;
-    private selectedMediaGallery?;
-    private editingMediaIndex;
-    private editingMediaId;
-    private preSelectedImgMetada;
-    private mediaStates;
-    private cacheKey;
-    private galleryPanelRefreshKey;
-    private finishItemCount;
-    isSearching: boolean;
-    hasLoadedInfiniteScrollHandler: boolean;
-    searchTimeout: any;
-    searchQueryText: string;
-    currentFile: {
-        size: number;
-        width: number;
-        height: number;
-    };
-    static imageBankElementProvider: string;
-    private transformerResults;
-    private menuItems;
-    private registeredProviders;
-    private readonly navigationDrawerWidth;
-    created(): void;
-    private processMediaGallery;
-    private initMediaState;
-    private isMediaPickerVideo;
-    private init;
-    private preloadImageMetadata;
-    private processSelectedMediaInput;
-    private isPromise;
-    private handleMigrateMedia;
-    private EnsureDefaultImageEditProviderIsSelected;
-    private createMediaPickerImageFromUrl;
-    onKeypress(event: any): void;
-    private onPickerClose;
-    private setSearchKeyword;
-    onSearch(immediate?: boolean): void;
-    private onEditingImageSaveButtonClick;
-    private getFileNameFromBase64;
-    private onSelectMenuItem;
-    private onChangedExistedImage;
-    private getMediaProvider;
-    CurrentRendition(): [GuidValue, MediaPickerRenditionData[], MediaPickerTransformedBase64Image];
-    setActiveEditingMedia(index: number): void;
-    private onMediaOrderChange;
-    onEditingMediaIndexChange(): void;
-    private onMediaRemove;
-    private onDeleteImagePostProcessing;
-    private SaveAllMedia;
-    private updateMediaToServer;
-    private saveMediaToServer;
-    private onStateChange;
-    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;
-    private isShowLoadingOverlay;
-    private isShowLoading;
-    private renderLoading;
-    private renderCardActions;
-    private renderMainForm;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const MediaPickerRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<MediaPickerRendererProps, never>, any, any, any>;
 export {};

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

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "../";
 import { MediaPickerImage } from "../../models";
 export interface IMediaPickerImage {
     /** The image to render*/
@@ -28,16 +27,3 @@ export interface IMediaPickerImage {
     showCaption?: boolean;
     inlineMediaNodeDisplayData?: string;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-media-picker-image": TsxAllowUnknowProperties<IMediaPickerImage>;
-        }
-    }
-}

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

@@ -1,9 +1,5 @@
-import { VueComponentBase } from "..";
-import { IWebComponentInstance } from "../..";
 import { MediaPickerImage } from "../../models";
-import { MediaPickerService } from "../../services";
-import { IMediaPickerImage } from "./IMediaPickerImage";
-export declare class MediaPickerImageComponent extends VueComponentBase<IMediaPickerImage> implements IWebComponentInstance, IMediaPickerImage {
+export interface MediaPickerImageComponentProps {
     image: MediaPickerImage;
     imagedata?: string;
     imageStyle?: string | object | object[];
@@ -19,12 +15,10 @@ export declare class MediaPickerImageComponent extends VueComponentBase<IMediaPi
     showCaption?: boolean;
     imgClass: string;
     inlineMediaNodeDisplayData?: string;
-    mediaPickerService: MediaPickerService;
-    private isLoading;
-    created(): void;
-    mounted(): void;
-    onImagedataChanged(imagejson: string): void;
-    private ensureRemoveInvalidCharactersFromSvgHtml;
-    private resolveImageUrl;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const MediaPickerImageComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MediaPickerImageComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaPickerImageComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<MediaPickerImageComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<MediaPickerImageComponentProps, never>;
+});
+export default MediaPickerImageComponent;

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

@@ -1,16 +1,3 @@
-import { TsxAllowUnknowProperties, MediaPickerProviderComponentProps } from "../../";
+import { MediaPickerProviderComponentProps } from "../../";
 export interface IMicrosoftStreamProviderComponent extends MediaPickerProviderComponentProps {
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-media-picker-microsoft-stream-provider": TsxAllowUnknowProperties<IMicrosoftStreamProviderComponent>;
-        }
-    }
-}

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

@@ -1,59 +1,54 @@
-import { IWebComponentInstance } from "../../../";
-import { MicrosoftStreamService } from "../../../services";
-import { MicrosoftStreamProviderLocalization } from "./loc/localize";
-import { OmniaTheming } from "../..";
-import { IMicrosoftStreamProviderComponent } from "./IMicrosoftStreamProvider";
-import { MultiSelectMediaProviderComponentBase } from "../mediaproviderbase/MultiSelectMediaProviderComponentBase";
-import { SharePointContext } from "../../../sp";
-export declare class MicrosoftStreamProviderComponent extends MultiSelectMediaProviderComponentBase implements IWebComponentInstance, IMicrosoftStreamProviderComponent {
-    loc: MicrosoftStreamProviderLocalization.locInterface;
-    microsoftStreamService: MicrosoftStreamService;
-    omniaTheming: OmniaTheming;
-    sharepointContext: SharePointContext;
-    private apiUrl;
-    private microsoftStreamVideoUrl;
-    private isIframeLoading;
-    private invalidVideoUrl;
-    private invalidStartTimeInput;
-    private microsoftStream;
-    private iframeElement;
-    private validateMessage;
-    private omniaUrl;
-    rules: {
-        required: string;
-    };
-    $refs: {
-        startTime: any;
-    };
-    private enableStartTime;
-    private videoProviderResult;
-    private inVideoUrlInputMode;
-    private isSharepointStream;
-    constructor();
-    created(): void;
-    mounted(): void;
-    private updateVideoState;
-    private saveMSStreamResult;
-    private initVideoDataAndGoToNextStep;
-    private onVideoUrlChanged;
-    private onStartTimeChanged;
-    private onEnableStartTimeChanged;
-    private onAutoPlayChanged;
-    private onShowInfoChanged;
-    private updateQueryStringParameter;
-    private getQueryStringParameter;
-    private getWebUrl;
-    private replaceAttributeFromString;
-    private validateVideoUrl;
-    private validateStartTimeInput;
-    private getStartTimeAsSeconds;
-    private getStreamVideo;
-    private processResponsiveIframe;
-    private renderIframe;
-    private renderVideoIframe;
-    private renderResponsiveVideoIframe;
-    private renderMicrosoftStreamUrlInput;
-    private renderSelectedVideoSettings;
-    private renderProviderButtons;
-    render(): VueTsxSupport.JSX.Element;
-}
+export declare const MicrosoftStreamProviderComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    providerId: unknown;
+    providerContext: unknown;
+    themeTargetId: unknown;
+    onChanged: unknown;
+    closed: unknown;
+    selectableMediaTypes: unknown;
+    imageSettings: unknown;
+    saved: unknown;
+    enableMediaCaption: unknown;
+    preSelectedMedia: unknown;
+    setSearchKeyword: unknown;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        providerId: unknown;
+        providerContext: unknown;
+        themeTargetId: unknown;
+        onChanged: unknown;
+        closed: unknown;
+        selectableMediaTypes: unknown;
+        imageSettings: unknown;
+        saved: unknown;
+        enableMediaCaption: unknown;
+        preSelectedMedia: unknown;
+        setSearchKeyword: unknown;
+    }, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => any>, {}, import("vue-tsx-support").PropsForOutside<{
+    providerId: unknown;
+    providerContext: unknown;
+    themeTargetId: unknown;
+    onChanged: unknown;
+    closed: unknown;
+    selectableMediaTypes: unknown;
+    imageSettings: unknown;
+    saved: unknown;
+    enableMediaCaption: unknown;
+    preSelectedMedia: unknown;
+    setSearchKeyword: unknown;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        providerId: unknown;
+        providerContext: unknown;
+        themeTargetId: unknown;
+        onChanged: unknown;
+        closed: unknown;
+        selectableMediaTypes: unknown;
+        imageSettings: unknown;
+        saved: unknown;
+        enableMediaCaption: unknown;
+        preSelectedMedia: unknown;
+        setSearchKeyword: unknown;
+    }, never>;
+});
+export default MicrosoftStreamProviderComponent;