@omnia/fx-sp 8.0.25-vnext → 8.0.26-dev

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

@@ -1,81 +1,446 @@
-import { GuidValue, PromotedTagOptions } from "../../../models";
-import { PromotedTagStore } from "../../../../fx/stores";
-import { VueComponentBase } from "../../../ux";
 import { FilterOption, Term } from "../../models";
-import { TermData, TermStore } from "../../../fx/stores";
-import { TermPickerLocalization } from "./loc/localize";
-import "./TermPicker.css";
-interface TermPickerTreeProps {
-    startWiths: Array<TermData>;
-    termSetId: GuidValue;
-    preSelectedTermIds?: Array<GuidValue>;
-    lcid?: number;
-    termsSelected?: (termIds: Array<GuidValue>) => void;
-    filterOptions?: (term: Term) => FilterOption;
-    loaded: () => void;
-    selectedTerms: Array<TermData>;
-    promotedTagOptions?: PromotedTagOptions;
-    multi?: boolean;
-    allowCreateNewTerm?: boolean;
-    maxLevel: number;
-    currentRovingTabIndex: number;
-    closeMenu?: () => void;
-    includeDeprecated?: boolean;
-    isEnterpriseKeyword?: boolean;
-    maxHeight: number;
-}
-export declare class TermPickerTree extends VueComponentBase<TermPickerTreeProps> {
-    termStore: TermStore;
-    private subscriptionHandler;
-    promotedTagStore: PromotedTagStore;
-    loc: TermPickerLocalization.locInterface;
-    termSetId: GuidValue;
-    preSelectedTermIds: Array<GuidValue>;
-    multi: boolean;
-    allowCreateNewTerm: boolean;
-    lcid: number;
-    termsSelected: (termIds: Array<GuidValue>) => void;
-    filterOptions: (term: Term) => FilterOption;
-    startWiths: Array<TermData>;
-    maxLevel: number;
-    currentRovingTabIndex: number;
-    closeMenu?: () => void;
-    loaded: () => void;
-    includeDeprecated?: boolean;
-    selectedTerms: Array<TermData>;
-    isEnterpriseKeyword?: boolean;
-    promotedTagOptions?: PromotedTagOptions;
-    maxHeight: number;
-    private startIdToRender;
-    private termClasses;
-    private promotedTermTags;
-    private UIConfig;
-    private treeNodes;
-    private nodeVirtualList;
-    private virtualScrollRef;
-    private openCreateUIForTerm;
-    created(): void;
-    mounted(): void;
-    private init;
-    private generateVirtualTermList;
-    private generateVirtualTermListRecursive;
-    private onCompletedEnsureTerms;
-    private ensurePromotedTermTags;
-    private createNewTerm;
-    private validateTermName;
-    private applyFilter;
-    private isDisableNode;
-    private mapToTreeNode;
-    private getDisplayLabel;
-    private dispatchEnsureChildTerm;
-    private isFullLoaded;
-    private addToDictionary;
-    private sortByCustomSortOrder;
-    private onBeforeExpandCollapse;
-    private onBeforeCreateNewChildTerm;
-    private onTermSelecting;
-    private renderPromotedTerms;
-    private renderTermTree;
-    render(): JSX.Element;
-}
-export {};
+import { GuidValue } from "@omnia/fx-models";
+import { VNodeRef } from "vue";
+export declare const TermPickerTree: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            readonly maxHeight?: number;
+            ref?: 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 "onUpdate:modelValue"?: (value: GuidValue[]) => any;
+            readonly "v-model"?: GuidValue[];
+            readonly modelValue?: GuidValue[];
+            readonly "max-height"?: number;
+            readonly termSetId?: unknown;
+            readonly lcid?: number;
+            readonly filterOptions?: (term: Term) => FilterOption;
+            readonly promotedTagOptions?: any;
+            readonly multi?: boolean;
+            readonly isEnterpriseKeyword?: boolean;
+            readonly "term-set-id"?: unknown;
+            readonly allowCreateNewTerm?: boolean;
+            readonly "filter-options"?: (term: Term) => FilterOption;
+            readonly includeDeprecated?: boolean;
+            readonly "promoted-tag-options"?: any;
+            readonly closeMenu?: () => void;
+            readonly "close-menu"?: () => void;
+            readonly termsSelected?: (termIds: Array<GuidValue>) => void;
+            readonly "terms-selected"?: (termIds: Array<GuidValue>) => void;
+            readonly startWiths?: Term[];
+            readonly "start-withs"?: Term[];
+            readonly maxLevel?: number;
+            readonly "max-level"?: number;
+            readonly currentRovingTabIndex?: number;
+            readonly "current-roving-tab-index"?: number;
+            readonly loaded?: () => void;
+            readonly selectedTerms?: Term[];
+            readonly "selected-terms"?: Term[];
+        };
+        $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<{
+            "max-height": {
+                type: import("vue").PropType<number>;
+            };
+            maxHeight: {
+                type: import("vue").PropType<number>;
+            };
+            "promoted-tag-options": {
+                type: import("vue").PropType<any>;
+            };
+            promotedTagOptions: {
+                type: import("vue").PropType<any>;
+            };
+            isEnterpriseKeyword: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            "selected-terms": {
+                type: import("vue").PropType<Term[]>;
+            };
+            selectedTerms: {
+                type: import("vue").PropType<Term[]>;
+            };
+            includeDeprecated: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            loaded: {
+                type: import("vue").PropType<() => void>;
+            } & {
+                type: import("vue").PropType<() => void>;
+            };
+            "close-menu": {
+                type: import("vue").PropType<() => void>;
+            };
+            closeMenu: {
+                type: import("vue").PropType<() => void>;
+            };
+            "current-roving-tab-index": {
+                type: import("vue").PropType<number>;
+            };
+            currentRovingTabIndex: {
+                type: import("vue").PropType<number>;
+            };
+            "max-level": {
+                type: import("vue").PropType<number>;
+            };
+            maxLevel: {
+                type: import("vue").PropType<number>;
+            };
+            "start-withs": {
+                type: import("vue").PropType<Term[]>;
+            };
+            startWiths: {
+                type: import("vue").PropType<Term[]>;
+            };
+            "filter-options": {
+                type: import("vue").PropType<(term: Term) => FilterOption>;
+            };
+            filterOptions: {
+                type: import("vue").PropType<(term: Term) => FilterOption>;
+            };
+            "terms-selected": {
+                type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+            };
+            termsSelected: {
+                type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+            };
+            lcid: {
+                type: import("vue").PropType<number>;
+            } & {
+                type: import("vue").PropType<number>;
+            };
+            allowCreateNewTerm: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            multi: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: GuidValue[]) => any>;
+            };
+            "v-model": {
+                type: import("vue").PropType<GuidValue[]>;
+                required: false;
+            };
+            modelValue: {
+                type: import("vue").PropType<GuidValue[]>;
+                required: false;
+            };
+            "term-set-id": {
+                type: import("vue").PropType<GuidValue>;
+            };
+            termSetId: {
+                type: import("vue").PropType<GuidValue>;
+            };
+        }>>, () => JSX.Element, unknown, {}, {}, 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<{
+        "max-height": {
+            type: import("vue").PropType<number>;
+        };
+        maxHeight: {
+            type: import("vue").PropType<number>;
+        };
+        "promoted-tag-options": {
+            type: import("vue").PropType<any>;
+        };
+        promotedTagOptions: {
+            type: import("vue").PropType<any>;
+        };
+        isEnterpriseKeyword: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "selected-terms": {
+            type: import("vue").PropType<Term[]>;
+        };
+        selectedTerms: {
+            type: import("vue").PropType<Term[]>;
+        };
+        includeDeprecated: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        loaded: {
+            type: import("vue").PropType<() => void>;
+        } & {
+            type: import("vue").PropType<() => void>;
+        };
+        "close-menu": {
+            type: import("vue").PropType<() => void>;
+        };
+        closeMenu: {
+            type: import("vue").PropType<() => void>;
+        };
+        "current-roving-tab-index": {
+            type: import("vue").PropType<number>;
+        };
+        currentRovingTabIndex: {
+            type: import("vue").PropType<number>;
+        };
+        "max-level": {
+            type: import("vue").PropType<number>;
+        };
+        maxLevel: {
+            type: import("vue").PropType<number>;
+        };
+        "start-withs": {
+            type: import("vue").PropType<Term[]>;
+        };
+        startWiths: {
+            type: import("vue").PropType<Term[]>;
+        };
+        "filter-options": {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        filterOptions: {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        "terms-selected": {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        termsSelected: {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        lcid: {
+            type: import("vue").PropType<number>;
+        } & {
+            type: import("vue").PropType<number>;
+        };
+        allowCreateNewTerm: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        multi: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: GuidValue[]) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        "term-set-id": {
+            type: import("vue").PropType<GuidValue>;
+        };
+        termSetId: {
+            type: import("vue").PropType<GuidValue>;
+        };
+    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    "max-height": {
+        type: import("vue").PropType<number>;
+    };
+    maxHeight: {
+        type: import("vue").PropType<number>;
+    };
+    "promoted-tag-options": {
+        type: import("vue").PropType<any>;
+    };
+    promotedTagOptions: {
+        type: import("vue").PropType<any>;
+    };
+    isEnterpriseKeyword: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    "selected-terms": {
+        type: import("vue").PropType<Term[]>;
+    };
+    selectedTerms: {
+        type: import("vue").PropType<Term[]>;
+    };
+    includeDeprecated: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    loaded: {
+        type: import("vue").PropType<() => void>;
+    } & {
+        type: import("vue").PropType<() => void>;
+    };
+    "close-menu": {
+        type: import("vue").PropType<() => void>;
+    };
+    closeMenu: {
+        type: import("vue").PropType<() => void>;
+    };
+    "current-roving-tab-index": {
+        type: import("vue").PropType<number>;
+    };
+    currentRovingTabIndex: {
+        type: import("vue").PropType<number>;
+    };
+    "max-level": {
+        type: import("vue").PropType<number>;
+    };
+    maxLevel: {
+        type: import("vue").PropType<number>;
+    };
+    "start-withs": {
+        type: import("vue").PropType<Term[]>;
+    };
+    startWiths: {
+        type: import("vue").PropType<Term[]>;
+    };
+    "filter-options": {
+        type: import("vue").PropType<(term: Term) => FilterOption>;
+    };
+    filterOptions: {
+        type: import("vue").PropType<(term: Term) => FilterOption>;
+    };
+    "terms-selected": {
+        type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+    };
+    termsSelected: {
+        type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+    };
+    lcid: {
+        type: import("vue").PropType<number>;
+    } & {
+        type: import("vue").PropType<number>;
+    };
+    allowCreateNewTerm: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    multi: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: GuidValue[]) => any>;
+    };
+    "v-model": {
+        type: import("vue").PropType<GuidValue[]>;
+        required: false;
+    };
+    modelValue: {
+        type: import("vue").PropType<GuidValue[]>;
+        required: false;
+    };
+    "term-set-id": {
+        type: import("vue").PropType<GuidValue>;
+    };
+    termSetId: {
+        type: import("vue").PropType<GuidValue>;
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        maxHeight?: number;
+        "onUpdate:modelValue"?: (value: GuidValue[]) => any;
+        "v-model"?: GuidValue[];
+        modelValue?: GuidValue[];
+        "max-height"?: number;
+        termSetId?: unknown;
+        lcid?: number;
+        filterOptions?: (term: Term) => FilterOption;
+        promotedTagOptions?: any;
+        multi?: boolean;
+        isEnterpriseKeyword?: boolean;
+        "term-set-id"?: unknown;
+        allowCreateNewTerm?: boolean;
+        "filter-options"?: (term: Term) => FilterOption;
+        includeDeprecated?: boolean;
+        "promoted-tag-options"?: any;
+        closeMenu?: () => void;
+        "close-menu"?: () => void;
+        termsSelected?: (termIds: Array<GuidValue>) => void;
+        "terms-selected"?: (termIds: Array<GuidValue>) => void;
+        startWiths?: Term[];
+        "start-withs"?: Term[];
+        maxLevel?: number;
+        "max-level"?: number;
+        currentRovingTabIndex?: number;
+        "current-roving-tab-index"?: number;
+        loaded?: () => void;
+        selectedTerms?: Term[];
+        "selected-terms"?: Term[];
+    }>, never>;
+};

package/internal-do-not-import-from-here/ux/user/UserPropertiesBySharePointProvider.d.ts

@@ -1 +1,6 @@
-export {};
+import { DataSourceProperty, PropertyDataSourceId } from "@omnia/fx-models";
+export declare class SharepointProperty extends DataSourceProperty {
+    readonly internalName: string;
+    constructor(dataSourceId: PropertyDataSourceId, internalName: string);
+    isEqual: (property: SharepointProperty) => boolean;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-sp",
   "license": "MIT",
-  "version": "8.0.25-vnext",
+  "version": "8.0.26-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": "8.0.25-vnext",
-    "@omnia/fx-sp-models": "8.0.25-vnext"
+    "@omnia/fx": "8.0.26-dev",
+    "@omnia/fx-sp-models": "8.0.26-dev"
   },
   "typings": "./index.d.ts",
   "bugs": {

package/internal-do-not-import-from-here/models/TermSetPropertyValue.d.ts

@@ -1,14 +0,0 @@
-import { Guid, GuidValue, PrimitiveArray, PropertyDisplaySettingsBase, PropertyValue } from "@omnia/fx-models";
-export type SharePointTermSetPropertyDisplaySettings = {
-    termSetId: GuidValue;
-} & PropertyDisplaySettingsBase;
-export type SharePointTermSetPropertyEditorSettings = {
-    multiple?: boolean;
-    required?: boolean;
-};
-export declare const sharePointTermSetPropertyDefinitionId: Guid;
-export declare class SharePointTermSetPropertyValue extends PropertyValue<SharePointTermSetPropertyValue, Guid[]> {
-    termIds: Guid[];
-    primitive: PrimitiveArray<SharePointTermSetPropertyValue, Guid[]>;
-    constructor(termIds: Guid[]);
-}

package/internal-do-not-import-from-here/models/TermSetPropertyValue.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharePointTermSetPropertyValue = exports.sharePointTermSetPropertyDefinitionId = void 0;
-const fx_models_1 = require("@omnia/fx-models");
-exports.sharePointTermSetPropertyDefinitionId = new fx_models_1.Guid("73b6db0e-27f2-45d6-b57d-1f18db45f182");
-class SharePointTermSetPropertyValue extends fx_models_1.PropertyValue {
-    constructor(termIds) {
-        super();
-        this.termIds = termIds;
-        this.primitive = {
-            type: fx_models_1.PrimitiveType.guid,
-            arrayValueType: fx_models_1.PrimitiveType.guid,
-            path: p => p.termIds
-        };
-    }
-}
-exports.SharePointTermSetPropertyValue = SharePointTermSetPropertyValue;

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

@@ -1,4 +0,0 @@
-import { types } from "typestyle";
-export declare const TermPickerStructuredTreeStyles: {
-    scrollBarStyle: (isHiden?: boolean) => types.NestedCSSProperties;
-};

package/internal-do-not-import-from-here/ux/user/UserPropertiesBySharePointDefinition.d.ts

@@ -1,19 +0,0 @@
-import { Guid, PropertyDefinition, PropertyValue, UserPropertyConfiguration } from "@omnia/fx-models";
-import { SharePointUserProfilePropertyValueBase } from "@omnia/fx-sp-models";
-export declare class SharePointUserPropertyValue extends PropertyValue<SharePointUserPropertyValue, any> {
-    valueToRender: string;
-    valueToUpdate: SharePointUserProfilePropertyValueBase;
-    primitive: null;
-    constructor(valueToRender: string, valueToUpdate?: SharePointUserProfilePropertyValueBase);
-}
-export type SharePointUserPropertyDisplaySettings = {};
-export type SharePointUserPropertyEditorSettings = {};
-export declare class UserPropertiesBySharePointDefinition extends PropertyDefinition<SharePointUserPropertyValue, SharePointUserPropertyDisplaySettings, SharePointUserPropertyEditorSettings> {
-    id: Guid;
-    typeName: string;
-    hidden: boolean;
-    private static userIdentityStore;
-    private static termStore;
-    static createPropertyValue(configuration: UserPropertyConfiguration, spValue: SharePointUserPropertyValue): Promise<PropertyValue<any, any>>;
-    static createSharePointUserPropertyValue(configuration: UserPropertyConfiguration, value: PropertyValue<any, any>): SharePointUserPropertyValue;
-}