@omnia/fx-sp 7.11.32 → 7.12.1

package/internal-do-not-import-from-here/ux/enterpriseproperties/settings/taxonomyfield/ITaxonomyFieldSettings.d.ts

@@ -2,14 +2,3 @@ import { EnterprisePropertySettingsProps } from "../../../../../ux";
 export interface ITaxonomyFieldSettings extends EnterprisePropertySettingsProps {
     hideOpenTermSet?: boolean;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-enterpriseproperties-taxonomyfield-settings": ITaxonomyFieldSettings;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/enterpriseproperties/settings/taxonomyfield/TaxonomyFieldSettings.d.ts

@@ -1,30 +1,18 @@
-import { Vue } from "vue-property-decorator";
-import { ITaxonomyFieldSettings } from "./ITaxonomyFieldSettings";
 import "./TaxonomyFieldSettings.css";
-import { IWebComponentInstance } from "../../../../..";
-import { EnterprisePropertyDefinition, GuidValue } from "../../../../../models";
+import { EnterprisePropertyDefinition } from "../../../../../models";
 import { IValidator } from "../../../../../ux";
 import { TaxonomyFieldSettingsStyles } from "../../../../models";
-import { TermStore } from "../../../../../fx/stores";
-import { EnterprisePropertiesSettingsTaxonomyLocalization } from "./loc/localize";
-import { EnterprisePropertyStore } from "../../../../../../fx/stores";
-export declare class TaxonomyFieldSettings extends Vue implements IWebComponentInstance, ITaxonomyFieldSettings {
+export interface TaxonomyFieldSettingsProps {
     property: EnterprisePropertyDefinition;
     disabled: boolean;
     dark?: boolean;
     styles?: typeof TaxonomyFieldSettingsStyles;
     useValidator?: IValidator;
     hideOpenTermSet: boolean;
-    loc: EnterprisePropertiesSettingsTaxonomyLocalization.locInterface;
-    private omniaTheming;
-    termStore: TermStore;
-    propertyStore: EnterprisePropertyStore;
-    private taxonomyFieldClasses;
-    private settings;
-    private originalSettings;
-    mounted(): void;
-    created(): void;
-    onTermSetChanged(termSetId: GuidValue): void;
-    renderTermSetTreeview(): VueTsxSupport.JSX.Element;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const TaxonomyFieldSettings: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TaxonomyFieldSettingsProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TaxonomyFieldSettingsProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<TaxonomyFieldSettingsProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TaxonomyFieldSettingsProps, never>;
+});
+export default TaxonomyFieldSettings;

package/internal-do-not-import-from-here/ux/enterpriseproperties/valuedefinition/enterprisekeywordsfield/EnterpriseKeywordsFieldValueDefinition.d.ts

@@ -1,18 +1,12 @@
-import { IEnterpriseKeywordsFieldValueDefinition } from "./IEnterpriseKeywordsFieldValueDefinition";
-import { VueComponentBase } from "../../../../../ux";
-import { IWebComponentInstance } from "../../../../../runtime/core/InternalWebComponentBootstrapper";
 import { EnterprisePropertyEnterpriseKeywordsItemSettings } from "../../../../../models";
-export declare class EnterpriseKeywordsFieldValueDefinition extends VueComponentBase implements IWebComponentInstance, IEnterpriseKeywordsFieldValueDefinition {
+export interface EnterpriseKeywordsFieldValueDefinitionProps {
     valueBind: EnterprisePropertyEnterpriseKeywordsItemSettings;
     onValueChanged: (model: EnterprisePropertyEnterpriseKeywordsItemSettings) => void;
     disabled: boolean;
-    private omniaTheming;
-    private omniaUxLoc;
-    mounted(): void;
-    created(): void;
-    beforeDestroy(): void;
-    private onRequiredChanged;
-    private onAllowMultiValuesChanged;
-    private onDescriptionChanged;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const EnterpriseKeywordsFieldValueDefinition: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<EnterpriseKeywordsFieldValueDefinitionProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<EnterpriseKeywordsFieldValueDefinitionProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<EnterpriseKeywordsFieldValueDefinitionProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<EnterpriseKeywordsFieldValueDefinitionProps, never>;
+});
+export default EnterpriseKeywordsFieldValueDefinition;

package/internal-do-not-import-from-here/ux/enterpriseproperties/valuedefinition/enterprisekeywordsfield/IEnterpriseKeywordsFieldValueDefinition.d.ts

@@ -1,14 +1,3 @@
 import { EnterprisePropertyValueDefinitionProps } from "../../../../../ux";
 export interface IEnterpriseKeywordsFieldValueDefinition extends EnterprisePropertyValueDefinitionProps {
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-enterpriseproperties-enterprisekeywordsfield-value-definition": IEnterpriseKeywordsFieldValueDefinition;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/enterpriseproperties/valuedefinition/taxonomyfield/ITaxonomyFieldValueDefinition.d.ts

@@ -1,18 +1,7 @@
-import { EnterprisePropertyValueDefinitionProps, TsxAllowUnknowProperties } from "../../../../../ux";
+import { EnterprisePropertyValueDefinitionProps } from "../../../../../ux";
 import { EnterprisePropertyDefinition } from "../../../../../models";
 export interface ITaxonomyFieldValueDefinition extends EnterprisePropertyValueDefinitionProps {
     showLimitLevelSettings?: boolean;
     isParentOfOthers?: boolean;
     availableParents?: Array<EnterprisePropertyDefinition>;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-enterpriseproperties-taxonomyfield-value-definition": TsxAllowUnknowProperties<ITaxonomyFieldValueDefinition>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/enterpriseproperties/valuedefinition/taxonomyfield/TaxonomyFieldValueDefinition.d.ts

@@ -1,26 +1,15 @@
-import { ITaxonomyFieldValueDefinition } from "./ITaxonomyFieldValueDefinition";
-import { IWebComponentInstance } from "../../../../..";
 import { EnterprisePropertyTaxonomyItemSettings, EnterprisePropertyDefinition } from "../../../../../models";
-import { VueComponentBase, OmniaTheming } from "../../../../../ux";
-import { EnterprisePropertiesValueDefinitionTaxonomyLocalization } from "./loc/localize";
-export declare class TaxonomyFieldValueDefinition extends VueComponentBase implements IWebComponentInstance, ITaxonomyFieldValueDefinition {
+export interface TaxonomyFieldValueDefinitionProps {
     valueBind: EnterprisePropertyTaxonomyItemSettings;
     onValueChanged: (model: EnterprisePropertyTaxonomyItemSettings) => void;
     showLimitLevelSettings: boolean;
     availableParents: Array<EnterprisePropertyDefinition>;
     isParentOfOthers: boolean;
     disabled: boolean;
-    omniaTheming: OmniaTheming;
-    private omniaUxLoc;
-    loc: EnterprisePropertiesValueDefinitionTaxonomyLocalization.locInterface;
-    mounted(): void;
-    created(): void;
-    beforeDestroy(): void;
-    private navigate;
-    private fixLimitLevel;
-    private onRequiredChanged;
-    private onAllowMultiValuesChanged;
-    private onDescriptionChanged;
-    private renderLimitLevelSettings;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const TaxonomyFieldValueDefinition: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TaxonomyFieldValueDefinitionProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TaxonomyFieldValueDefinitionProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<TaxonomyFieldValueDefinitionProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TaxonomyFieldValueDefinitionProps, never>;
+});
+export default TaxonomyFieldValueDefinition;

package/internal-do-not-import-from-here/ux/features/localize.d.ts

@@ -1,16 +1,26 @@
 export interface FeatureLocalization {
     Features: {
+        SPFxPerformanceEnhancement: {
+            Category: string;
+            Description: string;
+            Title: string;
+        };
         SPFxInfrastructure: {
             Category: string;
             Description: string;
             Title: string;
         };
+        SharePointExternalIdentityMapping: {
+            Category: string;
+            Description: string;
+            Title: string;
+        };
         ProvisionOmniaSearchUserData: {
             Title: string;
             Description: string;
             Category: string;
         };
-        SPFxFontFamilyBase: {
+        SharePointFont: {
             Category: string;
             Description: string;
             Title: string;

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

@@ -1,5 +1,5 @@
 import { FilterEngineOperator, GuidValue } from "@omnia/fx-models";
-import { Term } from "internal/fx/sp";
+import { Term } from "omniaapp/fx/sp";
 export interface FlatTreeViewTerm extends Term {
     selected?: boolean;
 }

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

@@ -1,5 +1,5 @@
 import { GuidValue } from "@omnia/fx-models";
-import { FilterOption, Term } from "internal/fx/sp";
+import { FilterOption, Term } from "omniaapp/fx/sp";
 import TaxonomyFilterEngineHandler from "../../../../handler/TaxonomyFilterEngineHandler";
 declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<{
     typedHandler: TaxonomyFilterEngineHandler;

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

@@ -1,5 +1,5 @@
 import { FilterEngineOperator, GuidValue } from "@omnia/fx-models";
-import { Term } from "internal/fx/sp";
+import { Term } from "omniaapp/fx/sp";
 export interface StructuredTreeViewTerm extends Term {
     selected?: boolean;
     expanding?: boolean;

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

@@ -1,5 +1,5 @@
 import { GuidValue } from "@omnia/fx-models";
-import { FilterOption, Term } from "internal/fx/sp";
+import { FilterOption, Term } from "omniaapp/fx/sp";
 import TaxonomyFilterEngineHandler from "../../../../handler/TaxonomyFilterEngineHandler";
 declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<{
     typedHandler: TaxonomyFilterEngineHandler;

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

@@ -1,5 +1,5 @@
 import { EnterprisePropertyDefinition, FilterEngineContext } from "@omnia/fx-models";
-import { TaxonomyFilterEngineProperty } from "internal/fx/sp";
+import { TaxonomyFilterEngineProperty } from "omniaapp/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;

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

@@ -1,5 +1,5 @@
 import { EnterprisePropertyDefinition, FilterEngineContext } from "@omnia/fx-models";
-import { TaxonomyFilterEngineProperty } from "internal/fx/sp";
+import { TaxonomyFilterEngineProperty } from "omniaapp/fx/sp";
 export default function ensureValidTaxonomyPropertySettings(context: FilterEngineContext, propertySettings: TaxonomyFilterEngineProperty, propertyDefinitionHash: {
     [internalName: string]: EnterprisePropertyDefinition;
 }): void;

package/internal-do-not-import-from-here/ux/filterengine/handler/ExtendedTaxonomyFilterEngineHandler.d.ts

@@ -1,5 +1,5 @@
 import { BaseFilterEnginePropertyOutput, EnterprisePropertyDefinition } from "@omnia/fx-models";
-import { TaxonomyFilterEngineProperty } from "internal/fx/sp";
+import { TaxonomyFilterEngineProperty } from "omniaapp/fx/sp";
 import TaxonomyFilterEngineHandler from "./TaxonomyFilterEngineHandler";
 export default class ExtendedTaxonomyFilterEngineHandler extends TaxonomyFilterEngineHandler {
     readonly termPrefixes: string[];

package/internal-do-not-import-from-here/ux/filterengine/handler/TaxonomyFilterEngineHandler.d.ts

@@ -1,8 +1,8 @@
 import { MessageBusTopicMediator } from "@omnia/fx";
 import { BaseFilterEnginePropertyOutput, EnterprisePropertyDefinition, FilterEngineRefinementOutput, GuidValue, ITypedFilterEngineHandler, PropertyIndexedType, Refinement, Refiner } from "@omnia/fx-models";
 import { Store } from "@omnia/../../fx/stores";
-import { TaxonomyFilterEngineProperty } from "internal/fx/sp";
-import { TaxonomyFilterEnginePropertyOutput, Term } from "internal/fx/sp/models";
+import { TaxonomyFilterEngineProperty } from "omniaapp/fx/sp";
+import { TaxonomyFilterEnginePropertyOutput, Term } from "omniaapp/fx/sp/models";
 export default class TaxonomyFilterEngineHandler extends Store implements ITypedFilterEngineHandler {
     private termStore;
     private targetingPropertyStore;

package/internal-do-not-import-from-here/ux/filterengine/shared/TaxonomyFilterEngineHelper.d.ts

@@ -1,5 +1,5 @@
 import { FilterEngineDefaultPosition, RollupFilter } from "@omnia/fx/models";
-import { TaxonomyFilterEngineProperty } from "internal/fx/sp/models";
+import { TaxonomyFilterEngineProperty } from "omniaapp/fx/sp/models";
 export declare class TaxonomyFilterEngineHelper {
     static migrateTaxonomyProperty(rollupFilter: RollupFilter, defaultPosition: FilterEngineDefaultPosition): TaxonomyFilterEngineProperty;
 }

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

@@ -26,12 +26,6 @@ export interface ILanguagePicker {
 }
 declare global {
     namespace JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
         interface IntrinsicElements {
             "omfx-sp-language-picker": TsxAllowUnknowProperties<ILanguagePicker>;
         }

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

@@ -1,10 +1,7 @@
-import Vue from "vue";
-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 interface LanguagePickerProps {
     valueBind: Language;
     disabled?: boolean;
     label?: string;
@@ -17,10 +14,10 @@ export declare class LanguagePicker extends Vue implements IWebComponentInstance
     loadLanguage?: () => Promise<Array<Language>>;
     scopedSlots?: ScopedSlots<IVSelectScopedSlots>;
     styles?: typeof LanguagePickerStyles;
-    private languageService;
-    created(): void;
-    mounted(): void;
-    beforeDestroy(): void;
-    loadSharepointLanguage(): Promise<Array<Language>>;
-    render(h: any): VueTsxSupport.JSX.Element;
 }
+export declare const LanguagePicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<LanguagePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LanguagePickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<LanguagePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LanguagePickerProps, never>;
+});
+export default LanguagePicker;

package/internal-do-not-import-from-here/ux/listtree/ListTree.d.ts

@@ -3,8 +3,17 @@ export interface ListTreeProps {
     spUrl: string;
     filter: ListTreeFilter;
     valueBind: string;
-    onValueChanged: (value: string) => void;
-    hideChildrens: boolean;
+    onValueChanged?: (value: string | null) => void;
+    onItemChanged?: (item: TreeItem | null) => void;
+    hideChildrens?: boolean;
+}
+export interface TreeItem {
+    name: string;
+    serverRelativeUrl: string;
+    listServerRelativeUrl: string;
+    uniqueId: string;
+    itemType: "List" | "Folder";
+    children: TreeItem[];
 }
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ListTreeProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<ListTreeProps, never>;

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

@@ -3,14 +3,3 @@ export interface IQueryFilterBuilder {
     valueBind: QueryFilter[];
     onValueChanged: (queryFilters: QueryFilter[]) => void;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-query-filter-builder": IQueryFilterBuilder;
-        }
-    }
-}

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

@@ -1,37 +1,11 @@
 import { QueryFilter } from "../../../models";
-import { ThemeStore, VueComponentBase } from "../../../ux";
-import { IQueryFilterBuilder } from "../..";
-export declare class QueryFilterBuilder extends VueComponentBase implements IQueryFilterBuilder {
+export interface QueryFilterBuilderProps {
     valueBind: QueryFilter[];
     onValueChanged: (queryFilters: QueryFilter[]) => void;
-    themeStore: ThemeStore;
-    private propertyStore;
-    private termStore;
-    private loc;
-    private taxonomyPropertySettings;
-    private internalQueryFilters;
-    private booleanFilterOptions;
-    private keywordTermSetId;
-    private availableDataTypeIds;
-    private availableProperties;
-    private modelJson;
-    private dialogTheme;
-    onValueBindChanged(): void;
-    mounted(): void;
-    created(): void;
-    init(): void;
-    private ensureInternalQueryFilters;
-    private onInternalQueryChanged;
-    private showNewQueryFilter;
-    private setDefaultInputValue;
-    private removeQueryFilter;
-    private renderTextFilter;
-    private renderNumberFilter;
-    private renderBooleanFilter;
-    private renderPersonFilter;
-    private renderTaxonomyFilter;
-    private renderDeleteButton;
-    private renderPropertySelection;
-    private renderFilterByType;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const QueryFilterBuilder: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<QueryFilterBuilderProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<QueryFilterBuilderProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<QueryFilterBuilderProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<QueryFilterBuilderProps, never>;
+});
+export default QueryFilterBuilder;

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

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "../../../ux";
 import { TargetingFilterProperty } from "../../models";
 export interface ITargetingFilterProperties {
     disabled?: boolean;
@@ -11,14 +10,3 @@ export interface ITargetingFilter extends ITargetingFilterProperties {
     onFilterChanged: (filter: TargetingFilterProperty) => void;
     fullWidth?: boolean;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-targeting-filter": TsxAllowUnknowProperties<ITargetingFilter>;
-        }
-    }
-}

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

@@ -1,21 +1,6 @@
-import { IWebComponentInstance } from "../../../";
-import { TargetingFilterLocalization } from "./loc/localize";
-import { ITargetingFilter } from "./ITargetingFilter";
-import { VueComponentBase } from "../../../ux";
-import { EnterprisePropertyDefinition, Language, TargetingProperty, TargetingPropertyData } from "../../../models";
-import { EnterprisePropertiesSettings, TargetingFilterProperty } from "../../models";
-import { EnterprisePropertyStore, TargetingPropertyStore } from "../../../../fx/stores";
+import { TargetingFilterProperty } from "../../models";
 import "./TargetingFilter.css";
-import { LocalizationService } from "../../../services";
-interface UIEnterprisePropertiesSettings extends EnterprisePropertiesSettings {
-    propertyName: string;
-}
-export declare class TargetingFilter extends VueComponentBase implements IWebComponentInstance, ITargetingFilter {
-    loc: TargetingFilterLocalization.locInterface;
-    enterprisePropertyStore: EnterprisePropertyStore;
-    targetingPropertyStore: TargetingPropertyStore;
-    private omniaContext;
-    localizationService: LocalizationService;
+export interface TargetingFilterProps {
     filter: TargetingFilterProperty;
     onFilterChanged: (filter: TargetingFilterProperty) => void;
     disabled: boolean;
@@ -23,40 +8,11 @@ export declare class TargetingFilter extends VueComponentBase implements IWebCom
     lcid: number;
     label: string;
     multi?: boolean;
-    filterChange(newValue: TargetingFilterProperty, oldValue: TargetingFilterProperty): void;
-    private targetingClasses;
-    isLoadingProperties: boolean;
-    targetingEnterprisePropertiesHash: {
-        [internalName: string]: EnterprisePropertyDefinition;
-    };
-    targetingEnterprisePropertiesSelections: Array<EnterprisePropertyDefinition>;
-    selectedTargetingFilter: Array<UIEnterprisePropertiesSettings>;
-    languages: Language[];
-    targetingPropertiesGroupingHash: {
-        [internalName: string]: Array<TargetingProperty<TargetingPropertyData>>;
-    };
-    created(): void;
-    mounted(): void;
-    init(): void;
-    beforeDestroy(): void;
-    private addTargetingFilter;
-    private removeTargetingFilter;
-    private onPropertyChange;
-    private onTermPickerChange;
-    private onCheckboxChange;
-    private onTargetPropertyCheckboxChange;
-    private updateFilterValue;
-    private initIfNull;
-    private mapToTargetingFilter;
-    private getSelectionTargetingProperties;
-    get finishLoading(): boolean;
-    get noTargeting(): boolean;
-    render(): VueTsxSupport.JSX.Element;
-    renderFilter(): JSX.Element[];
-    private renderProperty;
-    private renderTaxonomyProperty;
-    private onLanguageChanged;
-    private renderLanguageProperty;
-    renderLabel(): VueTsxSupport.JSX.Element;
+    hideIncludeChildTerms?: boolean;
 }
-export {};
+export declare const TargetingFilter: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TargetingFilterProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TargetingFilterProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<TargetingFilterProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<TargetingFilterProps, never>;
+});
+export default TargetingFilter;

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

@@ -34,14 +34,3 @@ export interface ISharePointTermItemComponent {
         };
     }[];
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-sp-term-item": ISharePointTermItemComponent;
-        }
-    }
-}

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

@@ -1,10 +1,6 @@
 import { GuidValue, IIcon, TermUISettings } from "../../../models";
-import { OmniaContext } from "../../..";
-import { Term, TermStore, SharePointTaxonomyGlossaryStore, ISharePointTermItemComponent, TermItemLanguageOptionProps, TaxonomyFieldDisplayClickHander, TermItemRendererMode } from "../..";
-import { MultilingualStore, EnterpriseGlossaryStore } from "../../../../fx/stores";
-import { EnterpriseGlossaryTermComponentBase } from "../../../ux/enterpriseglossary/componentbase";
-import { IWebComponentInstance } from "../../../runtime/core/InternalWebComponentBootstrapper";
-export declare class SharePointTermItemComponent extends EnterpriseGlossaryTermComponentBase implements IWebComponentInstance, ISharePointTermItemComponent {
+import { Term, TermItemLanguageOptionProps, TaxonomyFieldDisplayClickHander, TermItemRendererMode } from "../..";
+export interface SharePointTermItemComponentProps {
     term: Term;
     tooltip: string;
     languageOption?: TermItemLanguageOptionProps;
@@ -27,18 +23,10 @@ export declare class SharePointTermItemComponent extends EnterpriseGlossaryTermC
             icon: IIcon;
         };
     }[];
-    termStore: TermStore;
-    spTermEnterpriseGlossaryStore: SharePointTaxonomyGlossaryStore;
-    enterpriseGlossaryStore: EnterpriseGlossaryStore;
-    omniaContext: OmniaContext;
-    multilingualStore: MultilingualStore;
-    constructor();
-    getTerm(): Term;
-    getTermTitle(): string;
-    getTermUISettings(): TermUISettings;
-    created(): void;
-    private onEnterpriseGlossaryTermClicked;
-    mounted(): void;
-    private stopBubbleEvent;
-    render(): JSX.Element;
 }
+export declare const SharePointTermItemComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<SharePointTermItemComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SharePointTermItemComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<SharePointTermItemComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<SharePointTermItemComponentProps, never>;
+});
+export default SharePointTermItemComponent;

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

@@ -1,4 +1,4 @@
-import { TsxAllowUnknowProperties, IValidator } from "../../../ux";
+import { IValidator } from "../../../ux";
 import { Term, FilterOption } from "../../models";
 import { GuidValue, PromotedTagOptions } from "../../../models";
 export interface ITermPickerProperties {
@@ -28,14 +28,3 @@ export interface ITermPicker extends ITermPickerProperties {
     description?: string;
     promotedTagOptions?: PromotedTagOptions;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-term-picker": TsxAllowUnknowProperties<ITermPicker>;
-        }
-    }
-}

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

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "../../../ux";
 import { Term, FilterOption } from "../../models";
 import { GuidValue } from "../../../models";
 import { TermData } from "../../../fx/stores";
@@ -21,14 +20,3 @@ export interface ITermPickerSearch extends ITermPickerSearchProperties {
     filterOptions?: (term: Term) => FilterOption;
     loaded: () => void;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-term-picker-search": TsxAllowUnknowProperties<ITermPickerSearch>;
-        }
-    }
-}

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

@@ -1,28 +1,5 @@
-import { TermPickerLocalization } from "./loc/localize";
-import { TermStore } from "../../../fx/stores";
 import "./TermPicker.css";
-import { OmniaUxLocalization, VueComponentBase } from "../../../ux";
-interface ITermNode {
-    label: string;
-    selected: boolean;
-    showExpandedIcon: boolean;
-    allowCreateNewTerm: boolean;
-    termSelecting: () => void;
-    beforeExpandCollapse?: () => void;
-    beforeCreateNewChildTerm?: () => void;
-    isAvailableForTagging: boolean;
-    expanded?: boolean;
-    nodeLevel?: number;
-    tabindex?: number;
-    ariachecked?: boolean;
-    disabled?: boolean;
-    closeMenu?: () => void;
-    nodeStyles?: string;
-}
-export declare class TermNode extends VueComponentBase<ITermNode> {
-    termStore: TermStore;
-    loc: TermPickerLocalization.locInterface;
-    uxLoc: OmniaUxLocalization;
+export interface TermNodeProps {
     label: string;
     selected: boolean;
     showExpandedIcon: boolean;
@@ -38,25 +15,5 @@ export declare class TermNode extends VueComponentBase<ITermNode> {
     disabled: boolean;
     closeMenu: () => void;
     nodeStyles?: string;
-    private termClasses;
-    private VK_LEFT;
-    private VK_UP;
-    private VK_RIGHT;
-    private VK_DOWN;
-    private VK_ESC;
-    private VK_ENTER;
-    private VK_SPACE;
-    private VK_TAB;
-    created(): void;
-    mounted(): void;
-    beforeDestroy(): void;
-    onCheckboxChecked(): void;
-    onItemClicked(): void;
-    onExpandClicked(): void;
-    onCreateClicked(): void;
-    onKeyDownOnItem: (e: any) => void;
-    onKeyDownOnIcon: (e: any) => void;
-    render(): VueTsxSupport.JSX.Element;
-    renderAction(): VueTsxSupport.JSX.Element;
 }
-export {};
+export declare const TermNode: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<TermNodeProps, never>, any, any, any>;