@omnia/fx-sp 8.0.192-dev → 8.0.193-dev

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

@@ -1,5 +1,5 @@
 import { OmniaBootstrapData } from "@omnia/fx-models";
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 export interface OmniaSharePointBootstrapData extends OmniaBootstrapData {
     sharepoint: {
         adminUrl: string;
@@ -24,7 +24,7 @@ export interface SharePointWebContext {
     serverRelativeUrl: string;
     language: number;
     templateName: string;
-    id: GuidValue;
+    id: guid;
 }
 export interface SharePointEnvironmentContext {
     authorityUrl?: string;

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

@@ -1,6 +1,6 @@
-import { GuidValue, IFeatureConfiguration } from "@omnia/fx-models";
+import { guid, IFeatureConfiguration } from "@omnia/fx-models";
 export declare class SharePointFeatureConfiguration implements IFeatureConfiguration {
-    readonly typeId: GuidValue;
+    readonly typeId: guid;
     constructor();
     activateSiteSelectedPermissions: boolean;
 }

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SharePointFeatureConfiguration = void 0;
+const fx_models_1 = require("@omnia/fx-models");
 class SharePointFeatureConfiguration {
     constructor() {
-        this.typeId = "f4d7b125-d9db-4ee3-9165-b6e12ec0d0ec";
+        this.typeId = (0, fx_models_1.guid)("f4d7b125-d9db-4ee3-9165-b6e12ec0d0ec");
     }
 }
 exports.SharePointFeatureConfiguration = SharePointFeatureConfiguration;

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

@@ -1,7 +1,7 @@
-import { GuidValue, BaseFilterEngineProperty, FilterEngineContext, FilterEngineOperator, PropertyIndexedType, TypedFilterEnginePropertyOutput } from "@omnia/fx-models";
+import { guid, BaseFilterEngineProperty, FilterEngineContext, FilterEngineOperator, PropertyIndexedType, TypedFilterEnginePropertyOutput } from "@omnia/fx-models";
 export interface TaxonomyFilterEngineProperty extends BaseFilterEngineProperty {
-    value: Array<GuidValue>;
-    targetingPropertyIds: Array<GuidValue>;
+    value: Array<guid>;
+    targetingPropertyIds: Array<guid>;
     type: PropertyIndexedType.Taxonomy | PropertyIndexedType.EnterpriseKeywords | PropertyIndexedType.ExtendedProperty;
     operator: FilterEngineOperator;
     showResultCount: boolean;
@@ -27,13 +27,13 @@ export declare enum DefaultValueType {
 }
 export interface TaxonomyFilterEnginePropertyOutput extends TypedFilterEnginePropertyOutput {
     type: PropertyIndexedType.EnterpriseKeywords | PropertyIndexedType.Taxonomy;
-    value: Array<GuidValue>;
+    value: Array<guid>;
     sub: TaxonomyFilterEnginePropertyOutput[];
 }
 export declare abstract class SPSearchFilterEngineContext extends FilterEngineContext {
-    componentId: string;
-    readonly abstract uniqueId: string;
-    constructor(componentId: string);
+    componentId: guid;
+    readonly abstract uniqueId: guid;
+    constructor(componentId: guid);
     isRefinable(prop: BaseFilterEngineProperty): boolean;
     getAvailableProperties(): import("@omnia/fx-models").EnterprisePropertyDefinition[];
 }

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

@@ -1,10 +1,10 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 export interface LibraryResolveResult {
     resolved: boolean;
     libraryId: string;
     libraryTitle?: string;
     libraryUrl: string;
-    childFolderUniqueId?: GuidValue;
+    childFolderUniqueId?: guid;
     childFolderTitle?: string;
     childFolderUrl?: string;
     parentWebTitle?: string;

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

@@ -1,9 +1,9 @@
-import { AppInstance, GuidValue } from "@omnia/fx-models";
+import { AppInstance, guid } from "@omnia/fx-models";
 export interface ReservedSiteAliasValidationResult {
     isReserved: boolean;
     appInstance: AppInstance;
 }
 export interface ReservedSiteAliasValidationOption {
     enable: boolean;
-    ignoreFromAppId?: GuidValue;
+    ignoreFromAppId?: guid;
 }

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

@@ -1,4 +1,4 @@
-import { GuidValue, UserIdentity } from "@omnia/fx-models";
+import { guid, UserIdentity } from "@omnia/fx-models";
 export declare enum SharePointUserProfilePropertyValueTypes {
     Text = 0,
     TermSet = 1,
@@ -13,10 +13,10 @@ export declare class SharePointUserProfileTextPropertyValue extends SharePointUs
     constructor(texts: string[]);
 }
 export declare class SharePointUserProfileTermSetPropertyValue extends SharePointUserProfilePropertyValueBase {
-    termIds: GuidValue[];
+    termIds: guid[];
     multiple: boolean;
     type: SharePointUserProfilePropertyValueTypes;
-    constructor(termIds: GuidValue[], multiple?: boolean);
+    constructor(termIds: guid[], multiple?: boolean);
 }
 export declare class SharePointUserProfilePersonPropertyValue extends SharePointUserProfilePropertyValueBase {
     user: UserIdentity;

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

@@ -1,9 +1,9 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 export interface EnterprisePropertiesSettings {
-    termIds: Array<GuidValue>;
+    termIds: Array<guid>;
     includeChildTerms: boolean;
     languages: string[];
-    targetingPropertyIds: Array<GuidValue>;
+    targetingPropertyIds: Array<guid>;
 }
 export interface TargetingFilterProperty {
     enterprisePropertiesSettings: {

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

@@ -1,4 +1,4 @@
-import { EnterpriseGlossaryInformationSourceSettings, EnterpriseGlossary, GuidValue, TermUISettings } from "@omnia/fx-models";
+import { EnterpriseGlossaryInformationSourceSettings, EnterpriseGlossary, guid, TermUISettings } from "@omnia/fx-models";
 import { Term } from "./Term";
 export interface ITermGlossaryCustomProperty {
     getPropertyValue: (propertyName: string) => string;
@@ -13,9 +13,9 @@ export interface EnterpriseGlossaryTermData {
     mappingPropertyNames?: Array<string>;
 }
 export declare class SharePointTaxonomyGlossary extends EnterpriseGlossary {
-    readonly termSetId: GuidValue;
-    readonly type: import("@omnia/fx-models").Guid;
-    constructor(termSetId: GuidValue, settings: EnterpriseGlossaryInformationSourceSettings);
+    readonly termSetId: guid;
+    readonly type: guid;
+    constructor(termSetId: guid, settings: EnterpriseGlossaryInformationSourceSettings);
 }
 export declare class SharePointTermGlossarySelectedMessage<T extends EnterpriseGlossaryInformationSourceSettings = EnterpriseGlossaryInformationSourceSettings> {
     readonly term: Term;

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

@@ -1,7 +1,7 @@
-import { GuidValue, PropertyBindingSetting } from "@omnia/fx-models";
+import { guid, PropertyBindingSetting } from "@omnia/fx-models";
 export interface Term extends TermBase {
-    parentId: GuidValue;
-    termSetId: GuidValue;
+    parentId: guid;
+    termSetId: guid;
     isAvailableForTagging: boolean;
     termsCount: number;
     pathOfTerm: string;
@@ -22,7 +22,7 @@ export interface TermSetWithTerms extends TermSet {
 }
 export interface TermBase {
     name: string;
-    id: GuidValue;
+    id: guid;
     labels?: {
         [lcid: string]: TermLabel;
     };
@@ -52,9 +52,9 @@ export interface TermOrganizationFilterBase {
     type: TermOrganizationFilterType;
 }
 export declare class TermOrganizationFilterByTermId implements TermOrganizationFilterBase {
-    readonly termId: GuidValue;
+    readonly termId: guid;
     type: TermOrganizationFilterType;
-    constructor(termId: GuidValue);
+    constructor(termId: guid);
 }
 export declare class TermOrganizationFilterByCustomProperty implements TermOrganizationFilterBase {
     readonly name: string;
@@ -65,7 +65,7 @@ export declare class TermOrganizationFilterByCustomProperty implements TermOrgan
 export interface TermQuery {
     numberOfParentLevels: number;
     numberOfChildrensLimit: number;
-    termSetId: GuidValue;
+    termSetId: guid;
     filter: TermOrganizationFilterBase;
 }
 export interface TermQueryResult {
@@ -81,6 +81,6 @@ export declare class TermSetPropertyBindingSetting extends PropertyBindingSettin
     lookupValues: Array<TermLookupValue>;
 }
 export interface TermLookupValue {
-    id: GuidValue;
+    id: guid;
     title: string;
 }

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

@@ -1,4 +1,4 @@
-import { EnterpriseGlossaryMappingData, GuidValue } from "@omnia/fx-models";
+import { EnterpriseGlossaryMappingData, guid } from "@omnia/fx-models";
 export interface TermGlossaryMappingData extends EnterpriseGlossaryMappingData {
-    termSetId: GuidValue;
+    termSetId: guid;
 }

package/internal-do-not-import-from-here/services/ListsService.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from "../../models";
+import { guid } from "../../models";
 import { LibraryResolveResult, CentralImageLocationResult, OrderByField } from "../models";
 export declare class ListsService {
     private omniaContext;
@@ -6,6 +6,6 @@ export declare class ListsService {
     constructor();
     resolveLibraryUrl: (spSiteUrl: string, libraryUrl: string) => Promise<LibraryResolveResult>;
     resolveLibraryFromAbsoluteUrl: (absoluteUrl: string) => Promise<LibraryResolveResult>;
-    downloadImage: (siteUrl: string, listId: GuidValue, id: number) => Promise<string>;
-    getCentralImageLocationResult: (siteUrl: string, listId: GuidValue, textSearch: string, maxThumbnailSize: number, folderServerRelativeUrl?: string, skipId?: number, limit?: number, pagingInfo?: string, orderByFields?: Array<OrderByField>, includeVideos?: boolean) => Promise<CentralImageLocationResult>;
+    downloadImage: (siteUrl: string, listId: guid, id: number) => Promise<string>;
+    getCentralImageLocationResult: (siteUrl: string, listId: guid, textSearch: string, maxThumbnailSize: number, folderServerRelativeUrl?: string, skipId?: number, limit?: number, pagingInfo?: string, orderByFields?: Array<OrderByField>, includeVideos?: boolean) => Promise<CentralImageLocationResult>;
 }

package/internal-do-not-import-from-here/services/TermService.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue, Language } from "../../models";
+import { guid, Language } from "../../models";
 import { Term, TermSet, TermGroupWithTermSets, TermSetWithTerms, TermQuery, TermQueryResult } from "../models";
 export declare enum StringMatchOption {
     StartsWith = 0,
@@ -11,17 +11,17 @@ export declare class TermService {
     getTermByQuery: (query: TermQuery) => Promise<TermQueryResult>;
     getTermStoreWorkingLanguages: () => Promise<Language[]>;
     getTermStoreDefaultLanguage: () => Promise<number>;
-    getTermSetWithTermsById: (termSetId: GuidValue) => Promise<TermSetWithTerms>;
-    getTermSetById: (termSetId: GuidValue) => Promise<TermSet>;
+    getTermSetWithTermsById: (termSetId: guid) => Promise<TermSetWithTerms>;
+    getTermSetById: (termSetId: guid) => Promise<TermSet>;
     getKeywordTermSet: () => Promise<TermSet>;
-    getByIds: (termIds: Array<GuidValue>) => Promise<Term[]>;
-    getByIdsInTermSet: (termSetId: GuidValue, termIds: Array<GuidValue>) => Promise<Term[]>;
-    getChildTermsInTermSet: (termSetId: GuidValue, termId?: GuidValue) => Promise<Term[]>;
-    addTerm: (termSetId: GuidValue, termName: string, parentTermId: GuidValue) => Promise<Term>;
-    searchTerm: (termSetId: GuidValue, searchText: string, lcid: number) => Promise<Term[]>;
+    getByIds: (termIds: Array<guid>) => Promise<Term[]>;
+    getByIdsInTermSet: (termSetId: guid, termIds: Array<guid>) => Promise<Term[]>;
+    getChildTermsInTermSet: (termSetId: guid, termId?: guid) => Promise<Term[]>;
+    addTerm: (termSetId: guid, termName: string, parentTermId: guid) => Promise<Term>;
+    searchTerm: (termSetId: guid, searchText: string, lcid: number) => Promise<Term[]>;
     getAllTermGroupsWithTermSets: () => Promise<TermGroupWithTermSets<TermSet>[]>;
-    addOrUpdateTermCustomProperties: (termId: GuidValue, customProperties: {
+    addOrUpdateTermCustomProperties: (termId: guid, customProperties: {
         [name: string]: string;
     }) => Promise<Term>;
-    removeTermCustomProperties: (termId: GuidValue, propertyNames: Array<string>) => Promise<Term>;
+    removeTermCustomProperties: (termId: guid, propertyNames: Array<string>) => Promise<Term>;
 }

package/internal-do-not-import-from-here/stores/TermNavigationStore.d.ts

@@ -1,3 +1,4 @@
+import { guid } from "@omnia/fx-models";
 import { Store } from "@omnia/../../fx/stores";
 import { Term } from "../models";
 export declare const CurrentTermToken: {
@@ -9,10 +10,10 @@ export declare class TermNavigationStore extends Store {
     getters: {
         currentTerms: () => {
             value: {
-                [termSetId: string]: Term;
+                [termSetId: guid]: Term;
             };
             onMutated: (fn: (obj: import("@omnia/fx-models").StateMutation<{
-                [termSetId: string]: Term;
+                [termSetId: guid]: Term;
             }>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         };
     };

package/internal-do-not-import-from-here/stores/TermStore.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue, Language } from "../../models";
+import { guid, Language } from "../../models";
 import { Store, MultilingualStore } from "../../../fx/stores";
 import { TermService } from "../services/TermService";
 import { Term, TermSet, TermGroupWithTermSets, TermQuery, TermQueryResult } from "../models";
@@ -9,7 +9,7 @@ export interface TermSetDefinition extends TermSet {
 }
 export interface TermSetEntity {
     terms?: {
-        [termId: string]: TermData;
+        [termId: guid]: TermData;
     };
 }
 export declare class TermStore extends Store {
@@ -32,13 +32,13 @@ export declare class TermStore extends Store {
     getters: {
         getTermStoreWorkingLanguages: () => Language[];
         getOmniaTenantLanguageNotWorkingInTermStore: () => Language[];
-        getTermSetById: (termSetId: GuidValue) => TermSetDefinition;
-        getAllTerms: (termSetId: GuidValue, lcid?: number) => TermData[];
-        getTermById: (termSetId: GuidValue, termId: GuidValue, lcid?: number) => TermData;
-        getTermByIds: (termSetId: GuidValue, termIds: Array<GuidValue>, lcid?: number) => Array<TermData>;
-        getPathOfTerm: (lcid: number, termSetId: GuidValue, term: Term) => string;
-        getChildrenTerms: (termSetId: GuidValue, termId?: GuidValue, lcid?: number) => Term[];
-        getDisplayTermByLanguage: (lcid: number, termSetId: GuidValue, termId: GuidValue) => string;
+        getTermSetById: (termSetId: guid) => TermSetDefinition;
+        getAllTerms: (termSetId: guid, lcid?: number) => TermData[];
+        getTermById: (termSetId: guid, termId: guid, lcid?: number) => TermData;
+        getTermByIds: (termSetId: guid, termIds: Array<guid>, lcid?: number) => Array<TermData>;
+        getPathOfTerm: (lcid: number, termSetId: guid, term: Term) => string;
+        getChildrenTerms: (termSetId: guid, termId?: guid, lcid?: number) => Term[];
+        getDisplayTermByLanguage: (lcid: number, termSetId: guid, termId: guid) => string;
         getTermDisplayTitle: (term: Term, languageName: string, lcid?: number) => string;
         getTermGroupsWithTermSets: (lcid?: number) => TermGroupWithTermSets<TermSetDefinition>[];
         getDisplayLCID: () => number;
@@ -51,23 +51,23 @@ export declare class TermStore extends Store {
     actions: {
         ensureTermStoreWorkingLanguages: import("../../../fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
         ensurekeywordTermSet: import("../../../fx/stores").StoreAction<unknown, () => void, (result: TermSet) => void, (failureReason: any) => void, () => Promise<TermSet>>;
-        ensureTermSet: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue) => void, (result: unknown, termSetId: GuidValue) => void, (failureReason: any, termSetId: GuidValue) => void, (termSetId: GuidValue) => Promise<unknown>>;
-        ensureTermSetWithAllTerms: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue) => void, (result: void, termSetId: GuidValue) => void, (failureReason: any, termSetId: GuidValue) => void, (termSetId: GuidValue) => Promise<void>>;
-        ensureTermByIds: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue, termIds: GuidValue[], lcid?: number) => void, (result: Term[], termSetId: GuidValue, termIds: GuidValue[], lcid?: number) => void, (failureReason: any, termSetId: GuidValue, termIds: GuidValue[], lcid?: number) => void, (termSetId: GuidValue, termIds: Array<GuidValue>, lcid?: number) => Promise<Term[]>>;
-        addTerm: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue, termName: string, parentTermId: GuidValue) => void, (result: unknown, termSetId: GuidValue, termName: string, parentTermId: GuidValue) => void, (failureReason: any, termSetId: GuidValue, termName: string, parentTermId: GuidValue) => void, (termSetId: GuidValue, termName: string, parentTermId: GuidValue) => Promise<unknown>>;
-        searchTerm: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue, searchText: string, lcid: number) => void, (result: unknown, termSetId: GuidValue, searchText: string, lcid: number) => void, (failureReason: any, termSetId: GuidValue, searchText: string, lcid: number) => void, (termSetId: GuidValue, searchText: string, lcid: number) => Promise<unknown>>;
-        ensureChildTerms: import("../../../fx/stores").StoreAction<unknown, (termSetId: GuidValue, id?: GuidValue) => void, (result: Term[], termSetId: GuidValue, id?: GuidValue) => void, (failureReason: any, termSetId: GuidValue, id?: GuidValue) => void, (termSetId: GuidValue, id?: GuidValue) => Promise<Term[]>>;
+        ensureTermSet: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid) => void, (result: unknown, termSetId: guid) => void, (failureReason: any, termSetId: guid) => void, (termSetId: guid) => Promise<unknown>>;
+        ensureTermSetWithAllTerms: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid) => void, (result: void, termSetId: guid) => void, (failureReason: any, termSetId: guid) => void, (termSetId: guid) => Promise<void>>;
+        ensureTermByIds: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid, termIds: guid[], lcid?: number) => void, (result: Term[], termSetId: guid, termIds: guid[], lcid?: number) => void, (failureReason: any, termSetId: guid, termIds: guid[], lcid?: number) => void, (termSetId: guid, termIds: Array<guid>, lcid?: number) => Promise<Term[]>>;
+        addTerm: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid, termName: string, parentTermId: guid) => void, (result: unknown, termSetId: guid, termName: string, parentTermId: guid) => void, (failureReason: any, termSetId: guid, termName: string, parentTermId: guid) => void, (termSetId: guid, termName: string, parentTermId: guid) => Promise<unknown>>;
+        searchTerm: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid, searchText: string, lcid: number) => void, (result: unknown, termSetId: guid, searchText: string, lcid: number) => void, (failureReason: any, termSetId: guid, searchText: string, lcid: number) => void, (termSetId: guid, searchText: string, lcid: number) => Promise<unknown>>;
+        ensureChildTerms: import("../../../fx/stores").StoreAction<unknown, (termSetId: guid, id?: guid) => void, (result: Term[], termSetId: guid, id?: guid) => void, (failureReason: any, termSetId: guid, id?: guid) => void, (termSetId: guid, id?: guid) => Promise<Term[]>>;
         ensureAllTermGroups: import("../../../fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
-        addOrUpdateTermCustomProperties: import("../../../fx/stores").StoreAction<unknown, (termId: GuidValue, customProperties: {
+        addOrUpdateTermCustomProperties: import("../../../fx/stores").StoreAction<unknown, (termId: guid, customProperties: {
             [name: string]: string;
-        }) => void, (result: void, termId: GuidValue, customProperties: {
+        }) => void, (result: void, termId: guid, customProperties: {
             [name: string]: string;
-        }) => void, (failureReason: any, termId: GuidValue, customProperties: {
+        }) => void, (failureReason: any, termId: guid, customProperties: {
             [name: string]: string;
-        }) => void, (termId: GuidValue, customProperties: {
+        }) => void, (termId: guid, customProperties: {
             [name: string]: string;
         }) => Promise<void>>;
-        removeTermCustomProperties: import("../../../fx/stores").StoreAction<unknown, (termId: GuidValue, propertyNames: string[]) => void, (result: void, termId: GuidValue, propertyNames: string[]) => void, (failureReason: any, termId: GuidValue, propertyNames: string[]) => void, (termId: GuidValue, propertyNames: Array<string>) => Promise<void>>;
+        removeTermCustomProperties: import("../../../fx/stores").StoreAction<unknown, (termId: guid, propertyNames: string[]) => void, (result: void, termId: guid, propertyNames: string[]) => void, (failureReason: any, termId: guid, propertyNames: string[]) => void, (termId: guid, propertyNames: Array<string>) => Promise<void>>;
         getTermByQuery: import("../../../fx/stores").StoreAction<unknown, (query: TermQuery) => void, (result: TermQueryResult, query: TermQuery) => void, (failureReason: any, query: TermQuery) => void, (query: TermQuery) => Promise<TermQueryResult>>;
     };
     onActivated(): void;

package/internal-do-not-import-from-here/ux/appwithspaliasinput/AppWithSharePointAliasInput.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
     alias: string;
 } & {
@@ -8,7 +8,7 @@ declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
 } & {
     omniaRoutePrefix?: string;
 } & {
-    ignoreFromAppId?: GuidValue;
+    ignoreFromAppId?: guid;
 }>) => {
     $: import("vue").ComponentInternalInstance;
     $data: {};
@@ -56,7 +56,7 @@ declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
     } & {
         omniaRoutePrefix?: string;
     } & {
-        ignoreFromAppId?: GuidValue;
+        ignoreFromAppId?: guid;
     }> & {
         "v-slots"?: {
             default?: import("vue").Slot;

package/internal-do-not-import-from-here/ux/appwithspaliasinput/IAppWithSharePointAliasInput.d.ts

@@ -1,10 +1,10 @@
-import { GuidValue } from "../../../shared/models";
+import { guid } from "../../../shared/models";
 export interface IAppWithSharePointAliasInput {
     [name: string]: any;
     alias: string;
     useOmniaRootRoute: boolean;
     onChanged: (alias: string, useOmniRootRoute: boolean) => void;
     omniaRoutePrefix: string;
-    ignoreFromAppId?: GuidValue;
+    ignoreFromAppId?: guid;
     dark?: boolean;
 }

package/internal-do-not-import-from-here/ux/enterpriseproperties/display/enterprisekeywordsfield/EnterpriseKeywordsFieldDisplay.d.ts

@@ -1,11 +1,11 @@
 import { Term, EnterpriseKeywordDisplayStyles, SharePointTaxonomyGlossaryStore } from "../../../../";
 import { IEnterpriseKeywordsFieldDisplay } from "./IEnterpriseKeywordsFieldDisplay";
-import { EnterprisePropertyDefinition, EnterprisePropertiesBlockTaxonoyPropertiesSettings } from "../../../../../models";
+import { EnterprisePropertyDefinition, EnterprisePropertiesBlockTaxonoyPropertiesSettings, guid } from "../../../../../models";
 import { IWebComponentInstance } from "../../../../../runtime/core/InternalWebComponentBootstrapper";
 import "./EnterpriseKeywordsFieldDisplay.css";
 import { VueComponentBase } from "../../../../../ux";
 export declare class EnterpriseKeywordsFieldDisplayComponent extends VueComponentBase implements IWebComponentInstance, IEnterpriseKeywordsFieldDisplay {
-    valueBind: Array<string>;
+    valueBind: Array<guid>;
     settings: EnterprisePropertiesBlockTaxonoyPropertiesSettings;
     property: EnterprisePropertyDefinition;
     wrapWithParentContent: (internalName: string, propertyContent: JSX.Element) => JSX.Element;

package/internal-do-not-import-from-here/ux/enterpriseproperties/display/taxonomyfield/ITaxonomyFieldDisplay.d.ts

@@ -1,4 +1,4 @@
-import { EnterprisePropertiesBlockTaxonoyPropertiesSettings, EnterprisePropertiesDisplaySettings, EnterprisePropertyDefinition, GuidValue, IIcon } from "@omnia/fx-models";
+import { EnterprisePropertiesBlockTaxonoyPropertiesSettings, EnterprisePropertiesDisplaySettings, EnterprisePropertyDefinition, guid, IIcon } from "@omnia/fx-models";
 import { TsxAllowUnknowProperties } from "@omnia/fx/ux";
 import { TaxonomyDisplayStyles, Term } from "../../../../models";
 export interface TaxonomyFieldDisplayClickHander {
@@ -15,12 +15,12 @@ export interface ITaxonomyFieldDisplay extends EnterprisePropertiesDisplaySettin
     valueBind: Array<string>;
     property?: EnterprisePropertyDefinition;
     appendMenuItems?: {
-        termId: GuidValue;
+        termId: guid;
         onClick: (term: Term) => void;
         title: string;
     }[];
     validateRenderTooltip?: (items: Array<{
-        termId: GuidValue;
+        termId: guid;
         onClick: (term: Term) => any;
         title: string;
     }>) => {

package/internal-do-not-import-from-here/ux/enterpriseproperties/display/taxonomyfield/TaxonomyFieldDisplay.d.ts

@@ -1,12 +1,12 @@
 import { IWebComponentInstance } from "../../../../../runtime/core/InternalWebComponentBootstrapper";
 import { ITaxonomyFieldDisplay, TaxonomyFieldDisplayClickHander } from ".";
-import { EnterprisePropertyDefinition, EnterprisePropertiesBlockTaxonoyPropertiesSettings, GuidValue, IIcon } from "../../../../../models";
+import { EnterprisePropertyDefinition, EnterprisePropertiesBlockTaxonoyPropertiesSettings, guid, IIcon } from "../../../../../models";
 import { OmniaContext } from "../../../../..";
 import { Term, TermStore, TaxonomyDisplayStyles } from "../../../..";
 import "./TaxonomyFieldDisplay.css";
 import { VueComponentBase } from "../../../../../ux";
 export declare class TaxonomyFieldDisplayComponent extends VueComponentBase implements IWebComponentInstance, ITaxonomyFieldDisplay {
-    valueBind: Array<string>;
+    valueBind: Array<guid>;
     settings: EnterprisePropertiesBlockTaxonoyPropertiesSettings;
     property: EnterprisePropertyDefinition;
     wrapWithParentContent: (internalName: string, propertyContent: JSX.Element) => JSX.Element;
@@ -16,12 +16,12 @@ export declare class TaxonomyFieldDisplayComponent extends VueComponentBase impl
     styles?: typeof TaxonomyDisplayStyles;
     clickHandler?: TaxonomyFieldDisplayClickHander;
     appendMenuItems?: {
-        termId: GuidValue;
+        termId: guid;
         onClick: (term: Term) => void;
         title: string;
     }[];
     validateRenderTooltip?: (items: Array<{
-        termId: GuidValue;
+        termId: guid;
         onClick: (term: Term) => any;
         title: string;
     }>) => {

package/internal-do-not-import-from-here/ux/enterpriseproperties/edit/enterprisekeywordsfield/EnterpriseKeywordsFieldEdit.d.ts

@@ -1,10 +1,10 @@
 import { IWebComponentInstance } from "../../../../..";
 import { VueComponentBase } from "../../../../../ux";
 import { IEnterpriseKeywordsFieldEdit } from "./IEnterpriseKeywordsFieldEdit";
-import { EnterprisePropertyDefinition, EnterprisePropertyEnterpriseKeywordsItemSettings } from "../../../../../models";
+import { EnterprisePropertyDefinition, EnterprisePropertyEnterpriseKeywordsItemSettings, guid } from "../../../../../models";
 export declare class EnterpriseKeywordsFieldEdit extends VueComponentBase implements IWebComponentInstance, IEnterpriseKeywordsFieldEdit {
     valueBind: {
-        [propertyInternalName: string]: Array<string>;
+        [propertyInternalName: guid]: Array<string>;
     };
     onValueChanged: (value: Array<string>) => void;
     disabled: boolean;

package/internal-do-not-import-from-here/ux/enterpriseproperties/edit/taxonomyfield/TaxonomyFieldEdit.d.ts

@@ -1,10 +1,10 @@
 import { ITaxonomyFieldEdit } from "./ITaxonomyFieldEdit";
-import { EnterprisePropertyDefinition, EnterprisePropertyTaxonomyItemSettings, PromotedTagOptions } from "../../../../../models";
+import { EnterprisePropertyDefinition, EnterprisePropertyTaxonomyItemSettings, PromotedTagOptions, guid } from "../../../../../models";
 import { IWebComponentInstance } from "../../../../..";
 import { VueComponentBase } from "../../../../../ux";
 export declare class TaxonomyFieldEdit extends VueComponentBase implements IWebComponentInstance, ITaxonomyFieldEdit {
     valueBind: {
-        [propertyInternalName: string]: Array<string>;
+        [propertyInternalName: guid]: Array<string>;
     };
     onValueChanged: (value: Array<string>) => void;
     disabled: boolean;

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

@@ -2,7 +2,7 @@ import { VueComponentBase } from "@omnia/fx/ux";
 import { ITaxonomyFieldSettings } from "./ITaxonomyFieldSettings";
 import "./TaxonomyFieldSettings.css";
 import { IWebComponentInstance } from "../../../../..";
-import { EnterprisePropertyDefinition, GuidValue } from "../../../../../models";
+import { EnterprisePropertyDefinition, guid } from "../../../../../models";
 import { IValidator } from "../../../../../ux";
 import { TaxonomyFieldSettingsStyles } from "../../../../models";
 import { TermStore } from "../../../../../fx/stores";
@@ -23,7 +23,7 @@ export declare class TaxonomyFieldSettings extends VueComponentBase<ITaxonomyFie
     private originalSettings;
     mounted(): void;
     created(): void;
-    onTermSetChanged(termSetId: GuidValue): void;
+    onTermSetChanged(termSetId: guid): void;
     renderTermSetTreeview(): JSX.Element;
     render(): JSX.Element;
 }

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

@@ -1,4 +1,4 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import TaxonomyFilterEngineHandler from "../../../handler/TaxonomyFilterEngineHandler";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
@@ -11,7 +11,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         typedHandler: {
@@ -28,7 +28,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         typedHandler: {
@@ -52,7 +52,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         typedHandler: {
@@ -73,7 +73,7 @@ declare const _default: {
         required: true;
     };
     termSetId: {
-        type: import("vue").PropType<GuidValue>;
+        type: import("vue").PropType<guid>;
         required: true;
     };
     typedHandler: {
@@ -82,7 +82,7 @@ declare const _default: {
     };
 }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{
-        termSetId: GuidValue;
+        termSetId: guid;
         typedHandler: TaxonomyFilterEngineHandler;
         handleClearFilterValues: () => void;
         canShowSearchValueBox: boolean;

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

@@ -1,4 +1,4 @@
-import { FilterEngineOperator, GuidValue } from "@omnia/fx-models";
+import { FilterEngineOperator, guid } from "@omnia/fx-models";
 import { Term } from "internal/fx/sp";
 export interface FlatTreeViewTerm extends Term {
     selected?: boolean;
@@ -39,7 +39,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         "onUpdate:modelValue": {
@@ -133,7 +133,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         "onUpdate:modelValue": {
@@ -234,7 +234,7 @@ declare const _default: {
             required: true;
         };
         termSetId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
         "onUpdate:modelValue": {
@@ -332,7 +332,7 @@ declare const _default: {
         required: true;
     };
     termSetId: {
-        type: import("vue").PropType<GuidValue>;
+        type: import("vue").PropType<guid>;
         required: true;
     };
     "onUpdate:modelValue": {
@@ -403,7 +403,7 @@ declare const _default: {
     };
 }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{
-        termSetId: GuidValue;
+        termSetId: guid;
         toggleTermSelecting: () => void;
     } & {
         name?: {