@omnia/fx-sp 7.0.528-dev → 8.0.0-vnext

package/internal-do-not-import-from-here/ux/filterengine/components/renderer/termpicker/structured/TermPickerStructuredTree.d.ts

@@ -1,15 +1,16 @@
 import { GuidValue } from "@omnia/fx-models";
 import { FilterOption, Term } from "internal/fx/sp";
 import TaxonomyFilterEngineHandler from "../../../../handler/TaxonomyFilterEngineHandler";
-declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<{
+interface TermPickerStructureProps {
     typedHandler: TaxonomyFilterEngineHandler;
     termSetId: GuidValue;
-    multi: boolean;
-    handleTermsSelected: (termSelected: Array<GuidValue>) => void;
-    filterOptions: (term: Term) => FilterOption;
-    handleAfterLoading: () => void;
-    includeDeprecated: boolean;
-    selectedTermIds: GuidValue[];
+    selectedTermIds: Array<GuidValue>;
     handleClearFilterValues: () => void;
-}, "termSetId" | "typedHandler" | "selectedTermIds" | "handleClearFilterValues">, any, any, any>;
+    multi?: boolean;
+    handleTermsSelected?: (termSelected: Array<GuidValue>) => void;
+    filterOptions?: (term: Term) => FilterOption;
+    handleAfterLoading?: () => void;
+    includeDeprecated?: boolean;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ComponentObjectPropsOptions<TermPickerStructureProps>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermPickerStructureProps>>>, {}>;
 export default _default;

package/internal-do-not-import-from-here/ux/filterengine/components/settings/TaxonomyPropertyDefaultValueInput.d.ts

@@ -1,32 +1,78 @@
 import { EnterprisePropertyDefinition } from "@omnia/fx-models";
 import { TaxonomyFilterEngineProperty } from "../../../..";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    property: TaxonomyFilterEngineProperty;
-    updateData: () => void;
-    propertyDefinitionAsHash: {
-        [internalName: string]: EnterprisePropertyDefinition;
-    };
-}, "property" | "updateData" | "propertyDefinitionAsHash">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            property: TaxonomyFilterEngineProperty;
+            updateData: () => void;
+            propertyDefinitionAsHash: {
+                [internalName: string]: EnterprisePropertyDefinition;
+            };
+        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            property: TaxonomyFilterEngineProperty;
+            updateData: () => void;
+            propertyDefinitionAsHash: {
+                [internalName: string]: EnterprisePropertyDefinition;
+            };
+        }>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         property: TaxonomyFilterEngineProperty;
         updateData: () => void;
         propertyDefinitionAsHash: {
             [internalName: string]: EnterprisePropertyDefinition;
         };
-    }, "property" | "updateData" | "propertyDefinitionAsHash">;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    }>>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     property: TaxonomyFilterEngineProperty;
     updateData: () => void;
     propertyDefinitionAsHash: {
         [internalName: string]: EnterprisePropertyDefinition;
     };
-}, "property" | "updateData" | "propertyDefinitionAsHash">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+}>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         property: TaxonomyFilterEngineProperty;
         updateData: () => void;
         propertyDefinitionAsHash: {
             [internalName: string]: EnterprisePropertyDefinition;
         };
-    }, "property" | "updateData" | "propertyDefinitionAsHash">;
-});
+    }>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/filterengine/components/settings/TaxonomyPropertySettings.d.ts

@@ -1,36 +1,83 @@
 import { EnterprisePropertyDefinition, FilterEngineContext } from "@omnia/fx-models";
 import { TaxonomyFilterEngineProperty } from "internal/fx/sp";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    property: TaxonomyFilterEngineProperty;
-    updateData: () => void;
-    propertyDefinitionAsHash: {
-        [internalName: string]: EnterprisePropertyDefinition;
-    };
-    context: FilterEngineContext;
-}, "updateData" | "context">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            property: TaxonomyFilterEngineProperty;
+            updateData: () => void;
+            propertyDefinitionAsHash: {
+                [internalName: string]: EnterprisePropertyDefinition;
+            };
+            context: FilterEngineContext;
+        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            property: TaxonomyFilterEngineProperty;
+            updateData: () => void;
+            propertyDefinitionAsHash: {
+                [internalName: string]: EnterprisePropertyDefinition;
+            };
+            context: FilterEngineContext;
+        }>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         property: TaxonomyFilterEngineProperty;
         updateData: () => void;
         propertyDefinitionAsHash: {
             [internalName: string]: EnterprisePropertyDefinition;
         };
         context: FilterEngineContext;
-    }, "updateData" | "context">;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    }>>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     property: TaxonomyFilterEngineProperty;
     updateData: () => void;
     propertyDefinitionAsHash: {
         [internalName: string]: EnterprisePropertyDefinition;
     };
     context: FilterEngineContext;
-}, "updateData" | "context">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+}>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         property: TaxonomyFilterEngineProperty;
         updateData: () => void;
         propertyDefinitionAsHash: {
             [internalName: string]: EnterprisePropertyDefinition;
         };
         context: FilterEngineContext;
-    }, "updateData" | "context">;
-});
+    }>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/languagepicker/LanguagePicker.d.ts

@@ -1,10 +1,10 @@
-import Vue from "vue";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { IWebComponentInstance } from "../../../";
 import { Language } from "../../../models";
 import { LanguagePickerStyles, ScopedSlots } from "../../../ux";
 import { IVSelectScopedSlots } from "../../../ux/vuetify";
 import { ILanguagePicker } from "./ILanguagePicker";
-export declare class LanguagePicker extends Vue implements IWebComponentInstance, ILanguagePicker {
+export declare class LanguagePicker extends VueComponentBase implements IWebComponentInstance, ILanguagePicker {
     valueBind: Language;
     disabled?: boolean;
     label?: string;
@@ -22,5 +22,5 @@ export declare class LanguagePicker extends Vue implements IWebComponentInstance
     mounted(): void;
     beforeDestroy(): void;
     loadSharepointLanguage(): Promise<Array<Language>>;
-    render(h: any): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

package/internal-do-not-import-from-here/ux/properties/term-set/TermSetConfiguration.d.ts

@@ -1,8 +1,48 @@
 import { IPropertyConfigurationRenderer } from "@omnia/fx-models";
 import { SharePointTermSetPropertyDefinition } from "./TermSetPropertyDefinition";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyConfigurationRenderer<SharePointTermSetPropertyDefinition>>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/properties/term-set/TermSetDisplay.d.ts

@@ -1,9 +1,49 @@
 import { IPropertyDisplayRenderer } from "@omnia/fx-models";
 import { SharePointTermSetPropertyDefinition } from "./TermSetPropertyDefinition";
 export type TermSetDisplayProps = IPropertyDisplayRenderer<SharePointTermSetPropertyDefinition>;
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TermSetDisplayProps, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<TermSetDisplayProps, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<TermSetDisplayProps, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<TermSetDisplayProps, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermSetDisplayProps>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermSetDisplayProps>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermSetDisplayProps>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermSetDisplayProps>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<TermSetDisplayProps>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/properties/term-set/TermSetEditor.d.ts

@@ -1,8 +1,48 @@
 import { IPropertyEditorRenderer } from "@omnia/fx-models";
 import { SharePointTermSetPropertyDefinition } from "./TermSetPropertyDefinition";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyEditorRenderer<SharePointTermSetPropertyDefinition>>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/queryfilterbuilder/IQueryFilterBuilder.d.ts

@@ -1,16 +1,17 @@
+import { TsxAllowUnknowProperties } from "@omnia/fx/ux";
 import { QueryFilter } from "../../../models";
 export interface IQueryFilterBuilder {
     valueBind: QueryFilter[];
     onValueChanged: (queryFilters: QueryFilter[]) => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {
         }
         interface IntrinsicElements {
-            "omfx-query-filter-builder": IQueryFilterBuilder;
+            "omfx-query-filter-builder": TsxAllowUnknowProperties<IQueryFilterBuilder>;
         }
     }
 }

package/internal-do-not-import-from-here/ux/queryfilterbuilder/QueryFilterBuilder.d.ts

@@ -33,5 +33,5 @@ export declare class QueryFilterBuilder extends VueComponentBase implements IQue
     private renderDeleteButton;
     private renderPropertySelection;
     private renderFilterByType;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

package/internal-do-not-import-from-here/ux/targetingfilter/ITargetingFilter.d.ts

@@ -12,7 +12,7 @@ export interface ITargetingFilter extends ITargetingFilterProperties {
     fullWidth?: boolean;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

package/internal-do-not-import-from-here/ux/targetingfilter/TargetingFilter.d.ts

@@ -51,12 +51,12 @@ export declare class TargetingFilter extends VueComponentBase implements IWebCom
     private getSelectionTargetingProperties;
     get finishLoading(): boolean;
     get noTargeting(): boolean;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
     renderFilter(): JSX.Element[];
     private renderProperty;
     private renderTaxonomyProperty;
     private onLanguageChanged;
     private renderLanguageProperty;
-    renderLabel(): VueTsxSupport.JSX.Element;
+    renderLabel(): JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/termitem/ISharePointTermItemComponent.d.ts

@@ -1,3 +1,4 @@
+import { TsxAllowUnknowProperties } from "@omnia/fx/ux";
 import { TaxonomyFieldDisplayClickHander } from "..";
 import { GuidValue, IIcon, TermUISettings } from "../../../models";
 import { EnterpriseGlossaryTermComponentBaseStyles } from "../../../ux/models";
@@ -35,13 +36,13 @@ export interface ISharePointTermItemComponent {
     }[];
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {
         }
         interface IntrinsicElements {
-            "omfx-sp-term-item": ISharePointTermItemComponent;
+            "omfx-sp-term-item": TsxAllowUnknowProperties<ISharePointTermItemComponent>;
         }
     }
 }

package/internal-do-not-import-from-here/ux/termpicker/ITermPicker.d.ts

@@ -29,7 +29,7 @@ export interface ITermPicker extends ITermPickerProperties {
     promotedTagOptions?: PromotedTagOptions;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

package/internal-do-not-import-from-here/ux/termpicker/ITermPickerSearch.d.ts

@@ -22,7 +22,7 @@ export interface ITermPickerSearch extends ITermPickerSearchProperties {
     loaded: () => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

package/internal-do-not-import-from-here/ux/termpicker/TermNode.d.ts

@@ -55,7 +55,7 @@ export declare class TermNode extends VueComponentBase<ITermNode> {
     onCreateClicked(): void;
     onKeyDownOnItem: (e: any) => void;
     onKeyDownOnIcon: (e: any) => void;
-    render(): VueTsxSupport.JSX.Element;
-    renderAction(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
+    renderAction(): JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/termpicker/TermPicker.d.ts

@@ -78,8 +78,8 @@ export declare class TermPicker extends VueComponentBase implements IWebComponen
     get openForCreate(): boolean;
     get currentTermset(): import("../../../fx/stores").TermSetDefinition;
     beforeDestroy(): void;
-    render(): VueTsxSupport.JSX.Element;
-    renderSelectionMenu(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
+    renderSelectionMenu(): JSX.Element;
     renderAutocompleteTermItem(p: {
         selected: boolean;
         item: Term;

package/internal-do-not-import-from-here/ux/termpicker/TermPickerSearch.d.ts

@@ -1,4 +1,4 @@
-import * as tsx from "vue-tsx-support";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { IWebComponentInstance } from "../../../";
 import { TermPickerLocalization } from "./loc/localize";
 import { TermStore, TermData } from "../../../fx/stores";
@@ -9,7 +9,7 @@ import "./TermPicker.css";
 interface TermSearchNode extends Term {
     selected?: boolean;
 }
-export declare class TermPickerSearch extends tsx.Component<ITermPickerSearch> implements IWebComponentInstance, ITermPickerSearch {
+export declare class TermPickerSearch extends VueComponentBase<ITermPickerSearch> implements IWebComponentInstance, ITermPickerSearch {
     termStore: TermStore;
     loc: TermPickerLocalization.locInterface;
     termSetId: GuidValue;
@@ -40,8 +40,8 @@ export declare class TermPickerSearch extends tsx.Component<ITermPickerSearch> i
     mapToTermSearch(node: Term): TermSearchNode;
     createNewTerm(parentTermId: string, termName: string): void;
     getDisplayLabel(term: Term): string;
-    render(): VueTsxSupport.JSX.Element;
-    renderSearchBox(): VueTsxSupport.JSX.Element;
-    renderNoResult(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
+    renderSearchBox(): JSX.Element;
+    renderNoResult(): JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/termpicker/TermPickerTree.d.ts

@@ -76,6 +76,6 @@ export declare class TermPickerTree extends VueComponentBase<TermPickerTreeProps
     private onTermSelecting;
     private renderPromotedTerms;
     private renderTermTree;
-    render(h: any): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/termsetpicker/ITermSetPicker.d.ts

@@ -14,7 +14,7 @@ export interface ITermSetPicker extends ITermSetPickerProperties {
     onChanged: (termSetId: GuidValue) => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

package/internal-do-not-import-from-here/ux/termsetpicker/TermSetPicker.d.ts

@@ -1,13 +1,13 @@
-import Vue from "vue";
 import { IWebComponentInstance } from "../../../";
 import { ITermSetPicker } from "./ITermSetPicker";
 import { GuidValue, Future } from "../../../models";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { TermStore, TermSetDefinition } from "../../../fx/stores";
 import { TermGroupWithTermSets } from "../..";
 import { OmniaTheming } from "../../../ux";
 import { TermSetPickerLocalization } from "./loc/localize";
 import "./TermSetPicker.css";
-export declare class TermSetPicker extends Vue implements IWebComponentInstance, ITermSetPicker {
+export declare class TermSetPicker extends VueComponentBase implements IWebComponentInstance, ITermSetPicker {
     omniaTheming: OmniaTheming;
     termStore: TermStore;
     loc: TermSetPickerLocalization.locInterface;
@@ -46,8 +46,8 @@ export declare class TermSetPicker extends Vue implements IWebComponentInstance,
     mounted(): void;
     onTermGroupArrowIconClick(e: Event, termGroupId: string): void;
     onTermSetClick(e: MouseEvent, group: TermGroupWithTermSets<TermSetDefinition>, termSet: TermSetDefinition): void;
-    renderTermGroupsWithScrollable(): VueTsxSupport.JSX.Element;
-    renderTermGroups(): VueTsxSupport.JSX.Element[];
-    renderTermSets(group: TermGroupWithTermSets<TermSetDefinition>): VueTsxSupport.JSX.Element[];
-    render(): VueTsxSupport.JSX.Element;
+    renderTermGroupsWithScrollable(): JSX.Element;
+    renderTermGroups(): JSX.Element[];
+    renderTermSets(group: TermGroupWithTermSets<TermSetDefinition>): JSX.Element[];
+    render(): JSX.Element;
 }

package/internal-do-not-import-from-here/ux/termtree/TermTreeComponentBase.d.ts

@@ -19,5 +19,5 @@ export declare abstract class TermTreeComponentBase extends VueComponentBase<Ter
     constructor();
     private renderTerm;
     private renderChildTerms;
-    protected renderBase(): VueTsxSupport.JSX.Element;
+    protected renderBase(): JSX.Element;
 }