@omnia/fx 7.11.33 → 7.12.2

package/internal-do-not-import-from-here/ux/richtexteditor/extensions/Underline/UnderlineToolbar.d.ts

@@ -1,9 +1,6 @@
-import { ToolbarExtension } from "../../ToolbarExtension";
-import { UnderlineToolbarProperties, UnderlineMenuBar } from "../../../../models";
-export default class UnderlineToolbar extends ToolbarExtension implements UnderlineToolbarProperties {
+import { UnderlineMenuBar } from "../../../../models";
+export interface UnderlineToolbarProps {
     menubar: UnderlineMenuBar;
-    private loc;
-    mounted(): void;
-    render(): VueTsxSupport.JSX.Element;
-    getToolbarButtonActiveStyle(val: boolean): string;
 }
+declare const UnderlineToolbar: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<UnderlineToolbarProps, never>, any, any, any>;
+export default UnderlineToolbar;

package/internal-do-not-import-from-here/ux/richtexteditorrenderer/IRichTextEditorRenderer.d.ts

@@ -1,18 +1,4 @@
 import { MultilingualString } from "@omnia/fx-models";
-import { TsxAllowUnknowProperties } from "../../ux";
 export interface IRichTextEditorRenderer {
     editorContent: string | MultilingualString;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-rich-text-editor-renderer": TsxAllowUnknowProperties<IRichTextEditorRenderer>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/richtexteditorrenderer/RichTextEditorRenderer.d.ts

@@ -1,28 +1,11 @@
-import { IWebComponentInstance, OmniaContext, SubscriptionHandler } from "../../";
-import { AnchorLink } from "../AnchorLink";
-import { IRichTextEditorRenderer } from "./IRichTextEditorRenderer";
 import { MultilingualString } from "../../models";
 import "./RichTextEditorRenderer.css";
-import { VueComponentBase } from "../VueComponentBase";
-import { MultilingualStore } from "@omnia/fx/stores";
-export default class RichTextEditorRenderer extends VueComponentBase implements IWebComponentInstance, IRichTextEditorRenderer {
+export interface RichTextEditorRendererProps {
     editorContent: string | MultilingualString;
-    omniaCtx: OmniaContext;
-    subscriptionHandler: SubscriptionHandler;
-    anchorLink: AnchorLink;
-    multilingualStore: MultilingualStore;
-    private useAccessibilityFeature;
-    private rendererClasses;
-    private editorDefaultStyle;
-    private userUiLanguage;
-    private currentLanguage;
-    private state;
-    created(): Promise<void>;
-    mounted(): void;
-    beforeDestroy(): void;
-    private handleAnchorLink;
-    editLink(): void;
-    correctContent(): string;
-    private injectOnClickScript;
-    render(): VueTsxSupport.JSX.Element;
 }
+declare const RichTextEditorRenderer: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>;
+});
+export default RichTextEditorRenderer;

package/internal-do-not-import-from-here/ux/richtexteditorrenderer/RichTextEditorRendererHelper.d.ts

@@ -0,0 +1,2 @@
+export declare function attachPeopleLinkAccessibility(el: Element): void;
+export declare function attachLinkClickListeners(el: Element): void;

package/internal-do-not-import-from-here/ux/richtexteditorrenderer/RichTextEditorRendererSignIn.d.ts

@@ -1,25 +1,11 @@
-import { IWebComponentInstance, OmniaContext, SubscriptionHandler } from "../../";
-import { AnchorLink } from "../AnchorLink";
-import { IRichTextEditorRenderer } from "./IRichTextEditorRenderer";
 import { MultilingualString } from "../../models";
 import "./RichTextEditorRenderer.css";
-import { VueComponentBase } from "../VueComponentBase";
-export default class RichTextEditorRenderer extends VueComponentBase implements IWebComponentInstance, IRichTextEditorRenderer {
+export interface RichTextEditorRendererProps {
     editorContent: string | MultilingualString;
-    omniaCtx: OmniaContext;
-    subscriptionHandler: SubscriptionHandler;
-    anchorLink: AnchorLink;
-    private useAccessibilityFeature;
-    private rendererClasses;
-    private editorDefaultStyle;
-    private userUiLanguage;
-    private currentLanguage;
-    private state;
-    created(): Promise<void>;
-    mounted(): void;
-    beforeDestroy(): void;
-    private handleAnchorLink;
-    correctContent(): string;
-    private injectOnClickScript;
-    render(): VueTsxSupport.JSX.Element;
 }
+declare const RichTextEditorRenderer: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RichTextEditorRendererProps, never>;
+});
+export default RichTextEditorRenderer;

package/internal-do-not-import-from-here/ux/rollupempty/IRollupEmpty.d.ts

@@ -7,10 +7,6 @@ export interface IRollupEmpty {
 }
 declare global {
     namespace JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
         interface IntrinsicElements {
             "omfx-rollup-empty": TsxAllowUnknowProperties<IRollupEmpty>;
         }

package/internal-do-not-import-from-here/ux/rollupempty/RollupEmpty.d.ts

@@ -1,15 +1,11 @@
-import { IWebComponentInstance } from "@omnia/fx";
 import { BlockRenderingModes } from "../../models";
-import { IRollupEmpty } from "./IRollupEmpty";
-import { VueComponentBase } from "..";
-export declare class RollupEmpty extends VueComponentBase<IRollupEmpty> implements IWebComponentInstance, IRollupEmpty {
+export interface RollupEmptyProps {
     text?: string;
     renderingMode?: BlockRenderingModes;
-    private omniaLoc;
-    private blockPlaceholder?;
-    created(): void;
-    beforeDestroy(): void;
-    mounted(): void;
-    init(): void;
-    render(h: any): VueTsxSupport.JSX.Element;
 }
+export declare const RollupEmpty: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<RollupEmptyProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupEmptyProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<RollupEmptyProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupEmptyProps, never>;
+});
+export default RollupEmpty;

package/internal-do-not-import-from-here/ux/rollupfilter/IRollupFilter.d.ts

@@ -26,14 +26,3 @@ export interface IRollupFilter extends IRollupFIlterAttributes {
     useRollupFilterRouter?: boolean;
     searchInputId?: string;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-rollup-filter": IRollupFilter;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/rollupfilter/IRollupFilterPicker.d.ts

@@ -3,16 +3,5 @@ export interface IRollupFilterPicker {
     selectableProperties: Array<EnterprisePropertyDefinition>;
     preSelectedFilterItems: Array<RollupFilter>;
     onSelectedFilterItemChanged: (filterItems: Array<RollupFilter>) => void;
-    actionButtonsRenderer?: (h: any, addFilterButtonRenderer: JSX.Element) => JSX.Element;
-}
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-rollup-filter-picker": IRollupFilterPicker;
-        }
-    }
+    actionButtonsRenderer?: (h: any, addFilterButtonRenderer: VueTsxSupport.JSX.Element) => VueTsxSupport.JSX.Element;
 }

package/internal-do-not-import-from-here/ux/rollupfilter/RollupFilter.d.ts

@@ -1,83 +1,16 @@
-import { IRollupFilter, RollupFilterModel } from ".";
-import { IWebComponentInstance } from "../..";
-import { EnterprisePropertyDefinition, RollupEnums, RollupFilter, TaxonomyPropertySettings, TagRollupFilter } from "../../models";
-import { TermService, TermStore } from "../../sp";
-import { EnterprisePropertyStore, MultilingualStore, UserIdentityStore } from "../../stores";
-import { VueComponentBase } from "../index";
-import { RollupFilterLocalization } from "./loc/localize";
-export declare class RollupFilterComponent extends VueComponentBase implements IWebComponentInstance, IRollupFilter {
+import { RollupFilterModel } from ".";
+import { EnterprisePropertyDefinition, RollupFilter } from "../../models";
+export interface RollupFilterComponentProps {
     searchInputId?: string;
     valueBind: RollupFilterModel;
     onFilterChange?: (filters: Array<RollupFilter>, searchText: string) => void;
     mapRollupUiFilter?: (filters: Array<RollupFilter>) => void;
     contentProperties?: EnterprisePropertyDefinition[];
     useRollupFilterRouter?: boolean;
-    propertyStore: EnterprisePropertyStore;
-    userIdentityStore: UserIdentityStore;
-    termService: TermService;
-    termStore: TermStore;
-    multilingualStore: MultilingualStore;
-    loc: RollupFilterLocalization.locInterface;
-    private uxLoc;
-    private blockInstance;
-    formatter: {
-        timeformat: string;
-        locale: string;
-        firstdayofweek: number;
-    };
-    timewatchUniqueKey: string;
-    originalQueryText: string;
-    currentFilterValues: {
-        [internalName: string]: any;
-    };
-    booleanFilterOptions: Array<{
-        id: RollupEnums.BooleamFilterOption;
-        title: string;
-        value: boolean;
-    }>;
-    searchText: string;
-    textFilterValue: {
-        [internalName: string]: any;
-    };
-    contentPropertyTitleByInternalName: {
-        [internalName: string]: string;
-    };
-    internalFilters: Array<RollupFilter>;
-    filtersExpanded: number;
-    slimView: boolean;
-    lcid: number;
-    private isLoadingKeywordTermset;
-    private keywordTermSet;
-    private searchTimeout;
-    private previousSearchText;
-    private slimmedRollupFilters;
-    mounted(): void;
-    created(): void;
-    init(update: Boolean): void;
-    onValueBindChanged(newValue: RollupFilterModel, oldValue: RollupFilterModel): void;
-    onUseRouter(newValue: boolean, oldValue: boolean): void;
-    timerUpdateFilter(key: any): void;
-    onUpdateFilter(updateRouter?: boolean): void;
-    hasFilters(): boolean;
-    getTaxonomyPropertiesForFilter(propertyName: any): TaxonomyPropertySettings;
-    getPagePropertyAndRemoveInternalName(propertyName: string): string;
-    getTitle(filter: RollupFilter): string;
-    getContentPropTitle(propertyName: string): string;
-    renderDateFilter(filter: RollupFilter): VueTsxSupport.JSX.Element;
-    renderBooleanFilter(filter: RollupFilter): VueTsxSupport.JSX.Element;
-    renderKeywordFilter(filter: RollupFilter): JSX.Element;
-    renderTaxonomyFilter(filter: TagRollupFilter): VueTsxSupport.JSX.Element;
-    renderTagsFilter(filter: TagRollupFilter): VueTsxSupport.JSX.Element;
-    renderPersonFilter(filter: RollupFilter): VueTsxSupport.JSX.Element;
-    renderTextFieldFilter(filter: RollupFilter): VueTsxSupport.JSX.Element;
-    renderCustomFilter(filter: RollupFilter): import("vue").VNode;
-    onSearchKeyup(): void;
-    renderSearchBox(): VueTsxSupport.JSX.Element;
-    renderFilterShowHideFilters(): VueTsxSupport.JSX.Element[];
-    renderToolbar(): VueTsxSupport.JSX.Element;
-    getColumnCount(columns: any, filters: any): number;
-    renderFilters(): VueTsxSupport.JSX.Element;
-    render(): VueTsxSupport.JSX.Element;
-    canRenderFilter(filter: RollupFilter): boolean;
-    renderFilterByType(filter: RollupFilter): VueTsxSupport.JSX.Element;
 }
+export declare const RollupFilterComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<RollupFilterComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupFilterComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<RollupFilterComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupFilterComponentProps, never>;
+});
+export default RollupFilterComponent;

package/internal-do-not-import-from-here/ux/rollupfilter/RollupFilterPicker.d.ts

@@ -1,31 +1,13 @@
 import { EnterprisePropertyDefinition, RollupFilter } from "@omnia/fx-models";
-import { IRollupFilterPicker } from ".";
-import { OmniaUxLocalization, VueComponentBase } from "..";
-import { IWebComponentInstance } from "../..";
-export declare class RollupFilterPicker extends VueComponentBase implements IWebComponentInstance, IRollupFilterPicker {
+export interface RollupFilterPickerProps {
     selectableProperties: Array<EnterprisePropertyDefinition>;
     preSelectedFilterItems: Array<RollupFilter>;
     onSelectedFilterItemChanged: (filterItems: Array<RollupFilter>) => void;
-    actionButtonsRenderer?: (addFilterButtonRenderer: JSX.Element) => JSX.Element;
-    uxLoc: OmniaUxLocalization;
-    private targetingPropertyStore;
-    private filterItems;
-    private booleanFilterOptions;
-    private taxonomyFilterTypes;
-    private taxonomyPropertiesHasTargeting;
-    private renderResourceFilterByTypes;
-    private targetingPropertiesGroupingHash;
-    mounted(): void;
-    created(): void;
-    private onDataChanged;
-    private updateFilterItem;
-    private getSelectionTargetingProperties;
-    private onTargetPropertyCheckboxChange;
-    private renderItem;
-    private renderTaxonomyFilterValueSelection;
-    private renderPersonFilterValueSelection;
-    private renderTextFilterValueSelection;
-    private renderDateTimeFilterValueSelection;
-    private renderBooleanFilterValueSelection;
-    render(): VueTsxSupport.JSX.Element;
+    actionButtonsRenderer?: (addFilterButtonRenderer: VueTsxSupport.JSX.Element) => VueTsxSupport.JSX.Element;
 }
+export declare const RollupFilterPicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<RollupFilterPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupFilterPickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<RollupFilterPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<RollupFilterPickerProps, never>;
+});
+export default RollupFilterPicker;

package/internal-do-not-import-from-here/ux/securitytrimer/ISecurityTrimer.d.ts

@@ -1,25 +1,12 @@
 export interface ISecurityTrimer {
     [name: string]: any;
-    content: JSX.Element;
-    alternativeContent?: JSX.Element;
+    content: VueTsxSupport.JSX.Element;
+    alternativeContent?: VueTsxSupport.JSX.Element;
     roles: string[];
     excludedRoles?: string[];
-    excludedRolesContent?: JSX.Element;
+    excludedRolesContent?: VueTsxSupport.JSX.Element;
     clearCacheAndRetryIfUnauthorized?: boolean;
     contextParams?: {
         [key: string]: string | number;
     };
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-security-trimer": ISecurityTrimer;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/securitytrimer/SecurityTrimer.d.ts

@@ -1,27 +1,17 @@
-import Vue from "vue";
-import { IWebComponentInstance, SubscriptionHandler } from "../../";
-import { ISecurityTrimer } from "./ISecurityTrimer";
-export declare class SecurityTrimer extends Vue implements IWebComponentInstance, ISecurityTrimer {
-    content: JSX.Element;
-    alternativeContent?: JSX.Element;
+export interface SecurityTrimerProps {
+    content: VueTsxSupport.JSX.Element;
+    alternativeContent?: VueTsxSupport.JSX.Element;
     roles: string[];
     excludedRoles?: string[];
-    excludedRolesContent?: JSX.Element;
+    excludedRolesContent?: VueTsxSupport.JSX.Element;
     clearCacheAndRetryIfUnauthorized: boolean;
     contextParams?: {
         [key: string]: string | number;
     };
-    private permissionService;
-    subscriptionHandler: SubscriptionHandler;
-    private isAuthorized;
-    private isInExcludedRoles;
-    private checkedPermission;
-    private latestSessionId;
-    mounted(): void;
-    beforeDestroy(): void;
-    created(): void;
-    onUpdateRoles(): void;
-    private checkPermission;
-    private setIsAuthorized;
-    render(): JSX.Element;
 }
+export declare const SecurityTrimer: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<SecurityTrimerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SecurityTrimerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<SecurityTrimerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SecurityTrimerProps, never>;
+});
+export default SecurityTrimer;

package/internal-do-not-import-from-here/ux/selection/ISelection.d.ts

@@ -1,5 +1,4 @@
 import { GuidValue } from "../../models";
-import { TsxAllowUnknowProperties } from "../TsxAllowUnknowProperties";
 export type SelectionTypeId = GuidValue;
 export declare class SelectionToken implements SelectionItem<string> {
     title: string;
@@ -22,14 +21,3 @@ export interface ISelection {
     loading?: boolean;
     dark?: boolean;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-selection": TsxAllowUnknowProperties<ISelection>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/selection/SelectionComponent.d.ts

@@ -1,7 +1,5 @@
-import { IWebComponentInstance } from "@omnia/fx";
-import { VueComponentBase } from "../VueComponentBase";
-import { ISelection, SelectionItem } from "..";
-export declare class SelectionComponent extends VueComponentBase implements IWebComponentInstance, ISelection {
+import { SelectionItem } from "..";
+export interface SelectionComponentProps {
     items: SelectionItem<any>[];
     valueBind: SelectionItem<any>;
     onValueChanged?: (model: SelectionItem<any>) => void;
@@ -10,14 +8,10 @@ export declare class SelectionComponent extends VueComponentBase implements IWeb
     disabled?: boolean;
     dark?: boolean;
     filled?: boolean;
-    private omniaUxLoc;
-    private inputTokenText;
-    private dynamicItem;
-    private visibleSelectionToken;
-    created(): void;
-    mounted(): void;
-    beforeDestroy(): void;
-    private handleChange;
-    private handleTokenChange;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const SelectionComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<SelectionComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SelectionComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<SelectionComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SelectionComponentProps, never>;
+});
+export default SelectionComponent;

package/internal-do-not-import-from-here/ux/settings/ISettingsPane.d.ts

@@ -15,14 +15,3 @@ export interface ISettingsPane extends ISettingsPaneAttributes {
     onCancel?: () => void;
     onSave?: () => Promise<boolean>;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-settings-pane": ISettingsPane;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/settings/SettingsPane.d.ts

@@ -1,8 +1,5 @@
-import { IWebComponentInstance } from "../..";
-import { ISettingsPane, SettingsPaneModel } from "./ISettingsPane";
-import { VueComponentBase } from "../index";
-export declare class SettingsPane extends VueComponentBase implements IWebComponentInstance, ISettingsPane {
-    private uxLoc;
+import { SettingsPaneModel } from "./ISettingsPane";
+export interface SettingsPaneProps {
     contentClass?: string;
     headerClass?: string;
     title?: string;
@@ -15,16 +12,10 @@ export declare class SettingsPane extends VueComponentBase implements IWebCompon
     disableCancel?: boolean;
     showButtons?: boolean;
     warningMessage?: string;
-    onVisibleChanged(): void;
-    private uniqueId;
-    private styleSet;
-    private saving;
-    private headingStyle;
-    mounted(): void;
-    beforeDestroy(): void;
-    handleOnCancel(): void;
-    handleOnSave(): void;
-    private onDialogEscape;
-    render(): VueTsxSupport.JSX.Element;
-    overrideAndGetTransition(): void;
 }
+export declare const SettingsPane: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<SettingsPaneProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SettingsPaneProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<SettingsPaneProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SettingsPaneProps, never>;
+});
+export default SettingsPane;

package/internal-do-not-import-from-here/ux/shapedivider/IShapeDivider.d.ts

@@ -1,13 +1 @@
-import { ShapeDividerSettings } from "../../models";
-import { TsxAllowUnknowProperties } from "..";
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-shape-divider": TsxAllowUnknowProperties<ShapeDividerSettings>;
-        }
-    }
-}
+export {};

package/internal-do-not-import-from-here/ux/shapedivider/IShapeDividerSettings.d.ts

@@ -1,17 +1,5 @@
-import { TsxAllowUnknowProperties } from "@omnia/fx/ux";
 import { ShapeDividerSettings } from "../../models";
 export interface IShapeDividerSettingsComponent {
     settings: ShapeDividerSettings;
     onSettingsUpdated?: (settings: ShapeDividerSettings) => void;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-shape-divider-settings": TsxAllowUnknowProperties<IShapeDividerSettingsComponent>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/shapedivider/ShapeDivider.d.ts

@@ -1,8 +1,5 @@
-import { IWebComponentInstance } from "@omnia/fx";
-import Vue from "vue";
-import { ShapeDividerSettings, ShapeDividerTypes, ShapeDividerPositions } from "../../models";
-import { SpacingSettings } from "../../models";
-export declare class ShapeDividerComponent extends Vue implements IWebComponentInstance, ShapeDividerSettings {
+import { ShapeDividerTypes, ShapeDividerPositions, SpacingSettings } from "../../models";
+export interface ShapeDividerComponentProps {
     invert: boolean;
     position: ShapeDividerPositions;
     flip: boolean;
@@ -12,30 +9,10 @@ export declare class ShapeDividerComponent extends Vue implements IWebComponentI
     borderradius: number;
     width: number;
     height: number;
-    mounted(): void;
-    renderWavesOpacity(): VueTsxSupport.JSX.Element[];
-    renderWaves(): VueTsxSupport.JSX.Element;
-    renderCurve(): VueTsxSupport.JSX.Element;
-    renderCurveAsymmetrical(): VueTsxSupport.JSX.Element;
-    renderTriangle(): VueTsxSupport.JSX.Element;
-    renderTriangleAsymmetrical(): VueTsxSupport.JSX.Element;
-    renderTilt(): VueTsxSupport.JSX.Element;
-    renderArrow(): VueTsxSupport.JSX.Element;
-    renderSplit(): VueTsxSupport.JSX.Element | VueTsxSupport.JSX.Element[];
-    renderBook(): VueTsxSupport.JSX.Element;
-    getDivStyle(): {
-        position: string;
-        left: string;
-        width: string;
-        overflow: string;
-        "line-height": number;
-        transform: any;
-        bottom: string;
-        top: string;
-        "border-top-left-radius": string;
-        "border-top-right-radius": string;
-        "pointer-events": string;
-    };
-    private getSvgStyle;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ShapeDividerComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ShapeDividerComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ShapeDividerComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ShapeDividerComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ShapeDividerComponentProps, never>;
+});
+export default ShapeDividerComponent;

package/internal-do-not-import-from-here/ux/shapedivider/ShapeDividerSettings.d.ts

@@ -1,19 +1,11 @@
-import { IWebComponentInstance } from "@omnia/fx";
-import { IShapeDividerSettingsComponent } from "./IShapeDividerSettings";
-import { ShapeDividerLocalization } from "./loc/localize";
 import { ShapeDividerSettings } from "../../models";
-import { VueComponentBase } from "..";
-export declare class ShapeDividerSettingsComponent extends VueComponentBase implements IWebComponentInstance, IShapeDividerSettingsComponent {
+export interface ShapeDividerSettingsComponentProps {
     settings: ShapeDividerSettings;
     onSettingsUpdated?: (settings: ShapeDividerSettings) => void;
-    loc: ShapeDividerLocalization.locInterface;
-    private showShapeSettings;
-    model: ShapeDividerSettings;
-    private shapeTypes;
-    mounted(): void;
-    created(): void;
-    initModel(): void;
-    updateSettings(): void;
-    private setShapeSettingsVisibility;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ShapeDividerSettingsComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ShapeDividerSettingsComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ShapeDividerSettingsComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ShapeDividerSettingsComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ShapeDividerSettingsComponentProps, never>;
+});
+export default ShapeDividerSettingsComponent;

package/internal-do-not-import-from-here/ux/sharepointvideo/SharepointVideo.d.ts

@@ -1,11 +1,9 @@
-import { IWebComponentInstance, OmniaContext } from "@omnia/fx";
-import { VueComponentBase } from "internal/fx/ux/VueComponentBase";
 /**
  * Render sharepoint video, based on media graph Drive ID and Item ID
  * Usually used as html tag in media component. Internal use only
  * @internal
  */
-export declare class SharepointVideoComponent extends VueComponentBase implements IWebComponentInstance {
+export interface SharepointVideoComponentProps {
     graphDriveId: string;
     graphDriveItemId: string;
     videoUrl?: string;
@@ -13,18 +11,10 @@ export declare class SharepointVideoComponent extends VueComponentBase implement
     autoPlay: boolean;
     showTitle: boolean;
     onLoaded?: () => void;
-    omniaCtx: OmniaContext;
-    private spMediaService;
-    private omniaContext;
-    private sourceEmbedUrl;
-    created(): void;
-    mounted(): void;
-    private onIframeLoad;
-    private buildIframeUrl;
-    private buildTemporaryUrl;
-    private isAutoSignInSharePoint;
-    private trimSensitiveInfo;
-    private getParamOptions;
-    private getStartTimeAsSeconds;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const SharepointVideoComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<SharepointVideoComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SharepointVideoComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<SharepointVideoComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SharepointVideoComponentProps, never>;
+});
+export default SharepointVideoComponent;

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

@@ -3,7 +3,7 @@ export interface OmniaAuthProviderClient {
     title: string;
     icon: string;
     type: AuthenticationMetaData;
-    createRenderer: (ctx: OmniaAuthProviderContext, next: OmniaAuthProviderChainAction) => () => JSX.Element;
+    createRenderer: (ctx: OmniaAuthProviderContext, next: OmniaAuthProviderChainAction) => () => VueTsxSupport.JSX.Element;
 }
 export interface OmniaAuthProviderContext {
     uniqueName: string;