@omnia/fx-sp 7.5.75-dev → 8.0.0-dev

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

@@ -1,9 +1,125 @@
-import { IPropertyDisplayRenderer, SharePointTermSetPropertyDefinition } from "@omnia/fx-models";
+import { IPropertyDisplayRenderer, SharePointTermSetPropertyDefinition, SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyValue } from "@omnia/fx-models";
 import "./TermSetStyles.css";
-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>;
-});
+export type TermSetDisplayProps = IPropertyDisplayRenderer<SharePointTermSetPropertyDefinition> & {
+    "v-model": SharePointTermSetPropertyValue;
+};
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            readonly "v-model"?: SharePointTermSetPropertyValue;
+            readonly modelValue?: SharePointTermSetPropertyValue;
+            readonly displaySettings?: SharePointTermSetPropertyDisplaySettings;
+            readonly setupSettings?: import("@omnia/fx-models").SharePointTermSetPropertySetupSettings;
+            readonly renderTextOnly?: boolean;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $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<{
+            modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+            displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+            setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+            renderTextOnly?: import("vue").Prop<boolean, boolean>;
+            "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+        }>>, {}, {}, {}, {}, 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<{
+        modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+        displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+        setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+        renderTextOnly?: import("vue").Prop<boolean, boolean>;
+        "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+    displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+    setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+    renderTextOnly?: import("vue").Prop<boolean, boolean>;
+    "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        "v-model"?: SharePointTermSetPropertyValue;
+        modelValue?: SharePointTermSetPropertyValue;
+        displaySettings?: SharePointTermSetPropertyDisplaySettings;
+        setupSettings?: import("@omnia/fx-models").SharePointTermSetPropertySetupSettings;
+        renderTextOnly?: boolean;
+    }>, never>;
+};
 export default _default;

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

@@ -1,7 +1,126 @@
-import { IPropertyEditorRenderer, SharePointTermSetPropertyDefinition } from "@omnia/fx-models";
-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>;
-});
+import { SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyEditorSettings, SharePointTermSetPropertyValue } from "@omnia/fx-models";
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            readonly disabled?: boolean;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            readonly "v-model"?: SharePointTermSetPropertyValue;
+            readonly modelValue?: SharePointTermSetPropertyValue;
+            readonly displaySettings?: SharePointTermSetPropertyDisplaySettings;
+            readonly setupSettings?: import("@omnia/fx-models").SharePointTermSetPropertySetupSettings;
+            readonly editorSettings?: SharePointTermSetPropertyEditorSettings;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $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<{
+            modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+            editorSettings: import("vue").Prop<SharePointTermSetPropertyEditorSettings, SharePointTermSetPropertyEditorSettings>;
+            displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+            setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+            disabled?: import("vue").Prop<boolean, boolean>;
+            "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+        }>>, {}, {}, {}, {}, 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<{
+        modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+        editorSettings: import("vue").Prop<SharePointTermSetPropertyEditorSettings, SharePointTermSetPropertyEditorSettings>;
+        displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+        setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+        disabled?: import("vue").Prop<boolean, boolean>;
+        "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    modelValue: import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+    editorSettings: import("vue").Prop<SharePointTermSetPropertyEditorSettings, SharePointTermSetPropertyEditorSettings>;
+    displaySettings: import("vue").Prop<SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyDisplaySettings>;
+    setupSettings?: import("vue").Prop<import("@omnia/fx-models").SharePointTermSetPropertySetupSettings, import("@omnia/fx-models").SharePointTermSetPropertySetupSettings>;
+    disabled?: import("vue").Prop<boolean, boolean>;
+    "v-model": import("vue").Prop<SharePointTermSetPropertyValue, SharePointTermSetPropertyValue>;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        disabled?: boolean;
+        "v-model"?: SharePointTermSetPropertyValue;
+        modelValue?: SharePointTermSetPropertyValue;
+        displaySettings?: SharePointTermSetPropertyDisplaySettings;
+        setupSettings?: import("@omnia/fx-models").SharePointTermSetPropertySetupSettings;
+        editorSettings?: SharePointTermSetPropertyEditorSettings;
+    }>, never>;
+};
 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

@@ -79,8 +79,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;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-sp",
   "license": "MIT",
-  "version": "7.5.75-dev",
+  "version": "8.0.0-dev",
   "description": "Provide Omnia Fx Sharepoint Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx": "7.5.75-dev",
-    "@omnia/fx-sp-models": "7.5.75-dev"
+    "@omnia/fx": "8.0.0-dev",
+    "@omnia/fx-sp-models": "8.0.0-dev"
   },
   "typings": "./index.d.ts",
   "bugs": {