@omnia/fx 8.0.191-dev → 8.0.193-dev

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

@@ -1,14 +1,14 @@
-import { EnterprisePropertyDataType, EnterprisePropertyDefinition, GuidValue, PropertyArchive } from "../models";
+import { EnterprisePropertyDataType, EnterprisePropertyDefinition, guid, PropertyArchive } from "../models";
 export declare class EnterprisePropertyService {
     private httpClient;
     getEnterprisePropertyDataTypes: (hash?: string) => Promise<Array<EnterprisePropertyDataType>>;
     getEnterprisePropertyDefinitions: (hash?: string) => Promise<Array<EnterprisePropertyDefinition>>;
-    getEnterprisePropertyDefinitionById: (enterprisePropertyDefinitionId: GuidValue) => Promise<EnterprisePropertyDefinition>;
+    getEnterprisePropertyDefinitionById: (enterprisePropertyDefinitionId: guid) => Promise<EnterprisePropertyDefinition>;
     createEnterprisePropertyDefinition: (enterprisePropertyDefinition: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>;
     updateEnterprisePropertyDefinition: (enterprisePropertyDefinition: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>;
-    removeEnterprisePropertyDefinition: (enterprisePropertyDefinition: GuidValue) => Promise<void>;
-    terminateEnterprisePropertyDefinition: (enterprisePropertyDefinition: GuidValue) => Promise<void>;
-    restoreEnterprisePropertyDefinition: (enterprisePropertyDefinition: GuidValue) => Promise<EnterprisePropertyDefinition>;
+    removeEnterprisePropertyDefinition: (enterprisePropertyDefinition: guid) => Promise<void>;
+    terminateEnterprisePropertyDefinition: (enterprisePropertyDefinition: guid) => Promise<void>;
+    restoreEnterprisePropertyDefinition: (enterprisePropertyDefinition: guid) => Promise<EnterprisePropertyDefinition>;
     getAllArchiveEnterprisePropertyDefinition: () => Promise<Array<PropertyArchive>>;
     getExtendedEnterprisePropertyDefinitions: () => Promise<Array<EnterprisePropertyDefinition>>;
 }

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

@@ -1,11 +1,11 @@
-import { EnterprisePropertySet, GuidValue } from "../models";
+import { EnterprisePropertySet, guid } from "../models";
 export declare class EnterprisePropertySetService {
     private httpClient;
     getEnterprisePropertySets: () => Promise<Array<EnterprisePropertySet>>;
-    getEnterprisePropertySetById: (enterprisePropertySetId: GuidValue) => Promise<EnterprisePropertySet>;
+    getEnterprisePropertySetById: (enterprisePropertySetId: guid) => Promise<EnterprisePropertySet>;
     createEnterprisePropertySet: (enterprisePropertySet: EnterprisePropertySet) => Promise<EnterprisePropertySet>;
     updateEnterprisePropertySet: (enterprisePropertySet: EnterprisePropertySet) => Promise<EnterprisePropertySet>;
-    removeEnterprisePropertySet: (enterprisePropertySetId: GuidValue) => Promise<void>;
-    terminateEnterprisePropertySet: (enterprisePropertySetId: GuidValue) => Promise<void>;
-    restoreEnterprisePropertySet: (enterprisePropertySetId: GuidValue) => Promise<EnterprisePropertySet>;
+    removeEnterprisePropertySet: (enterprisePropertySetId: guid) => Promise<void>;
+    terminateEnterprisePropertySet: (enterprisePropertySetId: guid) => Promise<void>;
+    restoreEnterprisePropertySet: (enterprisePropertySetId: guid) => Promise<EnterprisePropertySet>;
 }

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

@@ -1,14 +1,14 @@
-import { Feature, FeatureInstance, GuidValue, FeatureInstanceProperties } from "../models";
+import { Feature, FeatureInstance, guid, FeatureInstanceProperties } from "../models";
 export declare class FeatureService {
     private httpClient;
     getFeatureDefinitions: () => Promise<Array<Feature>>;
     getFeatureInstances: (targetResolverType: string, params: {
         [name: string]: string;
     }) => Promise<Array<FeatureInstance>>;
-    getFeatureInstanceByFeatureId: (featureId: GuidValue) => Promise<FeatureInstance>;
-    getFeatureInstancesByDefinitionIds: (featureDefinitionIds: GuidValue[]) => Promise<Array<FeatureInstance>>;
-    activeFeature: (featureId: GuidValue, properties: FeatureInstanceProperties) => Promise<FeatureInstance>;
-    requestConsents: (featureIds: GuidValue[]) => Promise<FeatureInstance[]>;
-    upgradeFeature: (featureId: GuidValue, properties: FeatureInstanceProperties) => Promise<FeatureInstance>;
-    removeFeature: (featureId: GuidValue) => Promise<FeatureInstance>;
+    getFeatureInstanceByFeatureId: (featureId: guid) => Promise<FeatureInstance>;
+    getFeatureInstancesByDefinitionIds: (featureDefinitionIds: guid[]) => Promise<Array<FeatureInstance>>;
+    activeFeature: (featureId: guid, properties: FeatureInstanceProperties) => Promise<FeatureInstance>;
+    requestConsents: (featureIds: guid[]) => Promise<FeatureInstance[]>;
+    upgradeFeature: (featureId: guid, properties: FeatureInstanceProperties) => Promise<FeatureInstance>;
+    removeFeature: (featureId: guid) => Promise<FeatureInstance>;
 }

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

@@ -1,5 +1,5 @@
-import { GuidValue } from "../models";
+import { guid } from "../models";
 export declare class ManifestService {
-    loadResourceManifestById(id: GuidValue): void;
+    loadResourceManifestById(id: guid): void;
     loadResourceManifestByElementName(elementName: string): void;
 }

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

@@ -1,4 +1,4 @@
-import { MediaPickerPersistedImage, GuidValue, MediaPickerImageRatio, MediaPickerImageScaling, MediaPickerImageRatioDefinition, MultilingualString, MediaPickerImageScalingDefinition, MediaPickerRenditionData, MediaPickerStorageProviderContext, MediaPickerBase64Image, MediaPickerTransformedBase64Image, MediaPickerImage, MediaPickerImageInformation } from "@omnia/fx/models";
+import { MediaPickerPersistedImage, guid, MediaPickerImageRatio, MediaPickerImageScaling, MediaPickerImageRatioDefinition, MultilingualString, MediaPickerImageScalingDefinition, MediaPickerRenditionData, MediaPickerStorageProviderContext, MediaPickerBase64Image, MediaPickerTransformedBase64Image, MediaPickerImage, MediaPickerImageInformation } from "@omnia/fx/models";
 export declare class MediaPickerService {
     private httpClient;
     private serviceContainerContext;
@@ -7,7 +7,7 @@ export declare class MediaPickerService {
     getMediaPickerImage: (mediaPickerImageId: number) => Promise<MediaPickerPersistedImage>;
     getPersistedImageAsync: (mediaPickerImageId: number) => Promise<MediaPickerPersistedImage>;
     getImageUrl: (mediapickerImage: MediaPickerImage, imageRatioId?: number, scalingId?: number, useWithToken?: boolean) => string;
-    getOriginalImageUrl: (serviceId: GuidValue, mediaPickerImageId: number) => string;
+    getOriginalImageUrl: (serviceId: guid, mediaPickerImageId: number) => string;
     getMediaPickerBase64Image: (mediaPickerImage: MediaPickerImage, imageRatioId?: number, scalingId?: number) => Promise<MediaPickerBase64Image>;
     getMediaPickerBase64OriginalImage: (mediaPickerImage: MediaPickerImage) => Promise<MediaPickerBase64Image>;
     /**
@@ -34,7 +34,7 @@ export declare class MediaPickerService {
      * @param targetProviderContext The target context
      */
     copyImage: (mediaPickerImage: MediaPickerImage, targetProviderContext: MediaPickerStorageProviderContext) => Promise<MediaPickerImage>;
-    ensureRenditions: (omniaServiceId: GuidValue, mediaPickerImageId: number) => Promise<void>;
+    ensureRenditions: (omniaServiceId: guid, mediaPickerImageId: number) => Promise<void>;
     private createImageBase64FromImageUrl;
     removeBase64FormatTags(base64: string): string;
     ensureBase64String(base64: string, imgFormat: string): string;

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

@@ -1,4 +1,4 @@
-import { GuidValue, IPersistedPost, IPostBaseContext, IPostBaseWithContext, IPostReference, ReactionType } from "../models";
+import { guid, IPersistedPost, IPostBaseContext, IPostBaseWithContext, IPostReference, ReactionType } from "../models";
 export declare class PostService<TContextType extends IPostBaseContext> {
     private serviceContainerContext;
     private extensionHttpClients;
@@ -6,7 +6,7 @@ export declare class PostService<TContextType extends IPostBaseContext> {
     create<TPostType extends IPostBaseWithContext<TContextType>>(postToCreate: TPostType): Promise<IPersistedPost<TPostType>>;
     delete<TPostType extends IPostBaseWithContext<TContextType>>(postRef: IPostReference): Promise<IPersistedPost<TPostType>>;
     get<TPostType extends IPostBaseWithContext<TContextType>>(postRef: IPostReference): Promise<IPersistedPost<TPostType>>;
-    getContext<TPostType extends IPostBaseWithContext<TContextType>>(omniaServiceId: GuidValue, postTypeId: GuidValue, topicId: GuidValue): Promise<Array<IPersistedPost<TPostType>>>;
+    getContext<TPostType extends IPostBaseWithContext<TContextType>>(omniaServiceId: guid, postTypeId: guid, topicId: guid): Promise<Array<IPersistedPost<TPostType>>>;
     toggleLike<TPostType extends IPostBaseWithContext<TContextType>>(postToToggle: IPersistedPost<TPostType>): Promise<IPersistedPost<TPostType>>;
     socialReacts<TPostType extends IPostBaseWithContext<TContextType>>(postToReact: IPersistedPost<TPostType>, isReacts: boolean, reactionType: ReactionType): Promise<IPersistedPost<TPostType>>;
     private getHttpClientForServiceId;

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

@@ -1,11 +1,11 @@
-import { GuidValue, EnterprisePropertyColumnMapping } from "../models";
+import { EnterprisePropertyColumnMapping, guid } from "../models";
 export declare class QueryablePropertiesService {
     private serviceContainerContext;
     private httpClient;
     baseUrl: string;
     constructor();
-    getQueryableProperties: (tableName?: string, serviceId?: GuidValue) => Promise<EnterprisePropertyColumnMapping[]>;
-    removeQueryableProperties: (property: EnterprisePropertyColumnMapping, serviceId?: GuidValue) => Promise<EnterprisePropertyColumnMapping>;
-    addQueryableProperties: (properties: EnterprisePropertyColumnMapping[], serviceId?: GuidValue) => Promise<EnterprisePropertyColumnMapping[]>;
+    getQueryableProperties: (tableName?: string, serviceId?: guid) => Promise<EnterprisePropertyColumnMapping[]>;
+    removeQueryableProperties: (property: EnterprisePropertyColumnMapping, serviceId?: guid) => Promise<EnterprisePropertyColumnMapping>;
+    addQueryableProperties: (properties: EnterprisePropertyColumnMapping[], serviceId?: guid) => Promise<EnterprisePropertyColumnMapping[]>;
     private createHttpClientFromServiceId;
 }

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

@@ -1,5 +1,5 @@
-import { Guid, QueueMessageProgress } from "../models";
+import { guid, QueueMessageProgress } from "../models";
 export declare class QueueService {
     private httpClient;
-    getQueueMessageProgress: (queueMessageId: Guid) => Promise<QueueMessageProgress>;
+    getQueueMessageProgress: (queueMessageId: guid) => Promise<QueueMessageProgress>;
 }

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

@@ -1,7 +1,7 @@
-import { Secret, GuidValue } from "../models";
+import { Secret, guid } from "../models";
 export declare class SecretsService {
     private httpClient;
-    getSecret: (key: string, serviceId: GuidValue, profileId?: GuidValue) => Promise<Secret>;
+    getSecret: (key: string, serviceId: guid, profileId?: guid) => Promise<Secret>;
     setTenantSecret: (secret: Secret) => Promise<void>;
-    setBusinessProfileSecret: (secret: Secret, profileId: GuidValue) => Promise<void>;
+    setBusinessProfileSecret: (secret: Secret, profileId: guid) => Promise<void>;
 }

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

@@ -1,33 +1,34 @@
+import { guid } from "@omnia/fx-models";
 /**
  * Built in Omnia security roles
  * */
 export declare class SecurityRoles {
     static Api: {
         new (): {};
-        FullControl: string;
+        FullControl: guid;
     };
     static Tenant: {
         new (): {};
-        Admin: string;
+        Admin: guid;
     };
     static SiteCollection: {
         new (): {};
-        Admin: string;
+        Admin: guid;
     };
     static Site: {
         new (): {};
-        Admin: string;
+        Admin: guid;
     };
     static BusinessProfile: {
         new (): {};
-        Admin: string;
-        Viewer: string;
+        Admin: guid;
+        Viewer: guid;
     };
     static AppInstance: {
         new (): {};
-        Admin: string;
-        Contributor: string;
-        Reader: string;
-        Viewer: string;
+        Admin: guid;
+        Contributor: guid;
+        Reader: guid;
+        Viewer: guid;
     };
 }

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

@@ -1,22 +1,22 @@
 import { OmniaContext } from "../contexts";
-import { GuidValue, OmniaRole, PermissionBinding, RolePermissionSettingWithContextParam, AzurePermissionResource, AuthenticationSettings, AuthenticationConfiguration } from "../models";
+import { guid, OmniaRole, PermissionBinding, RolePermissionSettingWithContextParam, AzurePermissionResource, AuthenticationSettings, AuthenticationConfiguration } from "../models";
 export declare class SecurityService {
     private serviceContainerContext;
     omniaContext: OmniaContext;
     private httpClient;
     constructor();
-    getAppInstancePermissionBindings: (appInstanceId?: GuidValue) => Promise<PermissionBinding[]>;
+    getAppInstancePermissionBindings: (appInstanceId?: guid) => Promise<PermissionBinding[]>;
     getAllOmniaRoles: () => Promise<OmniaRole[]>;
     getPermissionBindings: (roleIds: Array<string>, contextParams?: {
         [key: string]: string | number;
     }) => Promise<{
         [roleId: string]: PermissionBinding[];
     }>;
-    addOrUpdatePermissionBindings: (rolePermissionSettingWithParam: RolePermissionSettingWithContextParam, serviceId?: GuidValue) => Promise<void>;
+    addOrUpdatePermissionBindings: (rolePermissionSettingWithParam: RolePermissionSettingWithContextParam, serviceId?: guid) => Promise<void>;
     getTenantRequiredAzureAdPermissions: () => Promise<AzurePermissionResource[]>;
     getConsentUrl: (redirectUrl: string) => Promise<string>;
     getAuthenticationSettings: () => Promise<AuthenticationSettings>;
-    getAuthenticationSettingsByUserTypeId: (userTypeId: GuidValue) => Promise<AuthenticationSettings>;
+    getAuthenticationSettingsByUserTypeId: (userTypeId: guid) => Promise<AuthenticationSettings>;
     saveAuthenticationSettings: (authConfig: AuthenticationConfiguration) => Promise<void>;
     validateAzureAdPermissionsSynced: (permissionIds: Array<string>) => Promise<boolean>;
     syncAzureAdPermissions: () => Promise<void>;

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

@@ -1,4 +1,4 @@
-import { IMessageBusTopicSubscription, SettingUpdatedMsg } from "../models";
+import { IMessageBusTopicSubscription, SettingUpdatedMsg, guid } from "../models";
 export interface ISuggestedKeyRendererHandler {
     /**
      * Return an array of the registered html element name that has been suggested to be able to render this key
@@ -61,7 +61,7 @@ export declare class SettingsService<T> implements ISettingsStorage<T>, ISetting
     private httpClient;
     private permissionService;
     private settingsLoader;
-    constructor(securityRoleId: string);
+    constructor(securityRoleId: guid);
     onKeyValueUpdated: (key: string) => IMessageBusTopicSubscription<T>;
     onSettingUpdated: () => IMessageBusTopicSubscription<SettingUpdatedMsg>;
     registerKeyProvider: (key: string, keyProvider: ISettingsKeyProvider) => void;

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

@@ -1,12 +1,12 @@
-import { TargetingProperty, GuidValue, TargetingPropertyData, TargetingPropertyResult } from "../models";
+import { TargetingProperty, guid, TargetingPropertyData, TargetingPropertyResult } from "../models";
 export declare class TargetingPropertyService {
     private httpClient;
     getTargetingProperties: () => Promise<Array<TargetingProperty<TargetingPropertyData>>>;
-    getTargetingPropertyById: (propertyId: GuidValue) => Promise<TargetingProperty<TargetingPropertyData>>;
+    getTargetingPropertyById: (propertyId: guid) => Promise<TargetingProperty<TargetingPropertyData>>;
     createTargetingProperty: (property: TargetingProperty<TargetingPropertyData>) => Promise<TargetingProperty<TargetingPropertyData>>;
     updateTargetingProperty: (property: TargetingProperty<TargetingPropertyData>) => Promise<TargetingProperty<TargetingPropertyData>>;
-    removeTargetingProperty: (propertyId: GuidValue) => Promise<void>;
+    removeTargetingProperty: (propertyId: guid) => Promise<void>;
     getTargetingPropertyResult: () => Promise<Array<TargetingPropertyResult>>;
-    terminateTargetingProperty: (propertyId: GuidValue) => Promise<void>;
-    restoreTargetingProperty: (propertyId: GuidValue) => Promise<TargetingProperty<TargetingPropertyData>>;
+    terminateTargetingProperty: (propertyId: guid) => Promise<void>;
+    restoreTargetingProperty: (propertyId: guid) => Promise<TargetingProperty<TargetingPropertyData>>;
 }

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

@@ -1,4 +1,4 @@
-import { VersionedAlternateLayout, DisplayBreakpointVersionedAlternateLayoutMapping, VersionedLayout, VersionedLayoutDefinition, GuidValue, ICheckedoutVersionedData, IVersionedData, IVersionedDataIdentifier, IVersionInformation, IVersionReference, LatestReferenceResponse, VersionedLayoutId, AppScopedVersionedLayoutUrlValidationRequest, VersionedLayoutDataWithParentLayout } from "../models";
+import { VersionedAlternateLayout, DisplayBreakpointVersionedAlternateLayoutMapping, VersionedLayout, VersionedLayoutDefinition, guid, ICheckedoutVersionedData, IVersionedData, IVersionedDataIdentifier, IVersionInformation, IVersionReference, LatestReferenceResponse, VersionedLayoutId, AppScopedVersionedLayoutUrlValidationRequest, VersionedLayoutDataWithParentLayout } from "../models";
 interface VersionedLayoutCreationResponse {
     checkedOutVersionedData: ICheckedoutVersionedData<VersionedLayoutDefinition>;
     versionedLayout: VersionedLayout;
@@ -16,8 +16,8 @@ export declare class VersionedLayoutService {
     private static readonly AppDefaultLayoutInPublicListingSettingsKeyPrefix;
     private httpClient;
     private settingsService;
-    createAppScopedLayout: (appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
-    createBusinessProfileScopedLayout: (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
+    createAppScopedLayout: (appInstanceId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
+    createBusinessProfileScopedLayout: (businessProfileId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
     createTenantScopedLayout: (definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
     createAlternateLayout: (versionedLayout: VersionedLayout, title: string, definition: VersionedLayoutDefinition) => Promise<VersionedAlternateLayoutCreationResponse>;
     deleteLayout: (layout: VersionedLayout) => Promise<void>;
@@ -33,14 +33,14 @@ export declare class VersionedLayoutService {
     discardLayoutDefinition: (versionedData: ICheckedoutVersionedData<VersionedLayoutDefinition>) => Promise<IVersionedData<VersionedLayoutDefinition>>;
     getLayoutByIdentifier: (identifier: IVersionedDataIdentifier) => Promise<VersionedLayout>;
     getLayoutById: (layoutId: number) => Promise<VersionedLayout>;
-    getLayoutsByAppId: (appInstanceId: GuidValue) => Promise<VersionedLayout[]>;
-    getLayoutsByProfileAndTypeId: (businessProfileId: GuidValue, layoutTypeId: GuidValue) => Promise<VersionedLayout[]>;
-    getLayoutsByTypeIds: (layoutTypeIds: GuidValue[]) => Promise<VersionedLayout[]>;
+    getLayoutsByAppId: (appInstanceId: guid) => Promise<VersionedLayout[]>;
+    getLayoutsByProfileAndTypeId: (businessProfileId: guid, layoutTypeId: guid) => Promise<VersionedLayout[]>;
+    getLayoutsByTypeIds: (layoutTypeIds: guid[]) => Promise<VersionedLayout[]>;
     getTenantLayouts: () => Promise<VersionedLayout[]>;
     getLayoutVersionInformation: (dataIdentifier: IVersionedDataIdentifier) => Promise<IVersionInformation[]>;
     setDisplayBreakpointAlternateLayoutMapping: (versionedLayoutId: VersionedLayoutId, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => Promise<void>;
-    getDefaultAppLayoutInPublicListing: (appInstanceId: GuidValue) => Promise<VersionedLayoutId>;
-    setDefaultAppLayoutInPublicListing: (versionedLayoutId: VersionedLayoutId, appInstanceId: GuidValue) => Promise<void>;
+    getDefaultAppLayoutInPublicListing: (appInstanceId: guid) => Promise<VersionedLayoutId>;
+    setDefaultAppLayoutInPublicListing: (versionedLayoutId: VersionedLayoutId, appInstanceId: guid) => Promise<void>;
     getDisplayBreakpointAlternateLayoutMappings: (...versionedLayoutIds: VersionedLayoutId[]) => Promise<{
         [versionedLayoutId: number]: DisplayBreakpointVersionedAlternateLayoutMapping;
     }>;

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

@@ -1,4 +1,4 @@
-import { ResolvedDynamicGroupIdentity, DynamicGroupIdentity, UserType, Future, GuidValue, TextPropertyValue, MultilingualTextPropertyValue } from "../../models";
+import { ResolvedDynamicGroupIdentity, DynamicGroupIdentity, UserType, Future, guid, TextPropertyValue, MultilingualTextPropertyValue } from "../../models";
 export declare class DynamicGroupService {
     private httpClient;
     private apiManagementBase;
@@ -18,7 +18,7 @@ export declare class DynamicGroupService {
     purge: (identity: DynamicGroupIdentity) => Promise<void>;
 }
 export interface DynamicGroupIdentityAddOrUpdateRequest {
-    id: GuidValue;
+    id: guid;
     displayName: MultilingualTextPropertyValue;
     description: MultilingualTextPropertyValue;
     externalIdentityMappings: TextPropertyValue;

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

@@ -1,8 +1,8 @@
-import { Future, GuidValue, IdentityCreationRequest, IdentityCreationRequestConfirmEmailResult, IdentityCreationRequestCreatedResponse, IdentityEmailConfirmationRequest, ResolvedIdentityCreationRequestSettings } from "@omnia/fx-models";
+import { Future, guid, IdentityCreationRequest, IdentityCreationRequestConfirmEmailResult, IdentityCreationRequestCreatedResponse, IdentityEmailConfirmationRequest, ResolvedIdentityCreationRequestSettings } from "@omnia/fx-models";
 export declare class IdentitySelfServiceService {
     private httpClient;
     private baseRoute;
-    resolveSettings: (businessProfileId: GuidValue) => Future<ResolvedIdentityCreationRequestSettings>;
+    resolveSettings: (businessProfileId: guid) => Future<ResolvedIdentityCreationRequestSettings>;
     create: (request: IdentityCreationRequest) => Future<IdentityCreationRequestCreatedResponse>;
     confirmEmail: (request: IdentityEmailConfirmationRequest) => Future<IdentityCreationRequestConfirmEmailResult>;
     resendEmail: (request: IdentityCreationRequestCreatedResponse) => Future<IdentityCreationRequestCreatedResponse>;

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

@@ -1,4 +1,4 @@
-import { Future, GroupIdentity, GroupMembers, Identity, IdentityQuery, IResolvedIdentity, ItemQueryResult, ResolvedUserIdentity, UserIdentity, GuidValue, UserIdentityQuery } from "@omnia/fx-models";
+import { Future, GroupIdentity, GroupMembers, Identity, IdentityQuery, IResolvedIdentity, ItemQueryResult, ResolvedUserIdentity, UserIdentity, guid, UserIdentityQuery } from "@omnia/fx-models";
 export declare class IdentityService {
     private httpClient;
     private baseUrl;
@@ -21,7 +21,7 @@ export declare class IdentityService {
     getGroupsMembers: (groups: GroupIdentity[]) => Future<{
         [groupIdentityUid: string]: GroupMembers;
     }>;
-    getIdentitiesWithProviderIdentities: (providerId: GuidValue, userIds: GuidValue[]) => Future<{
+    getIdentitiesWithProviderIdentities: (providerId: guid, userIds: guid[]) => Future<{
         [userIdentityUid: string]: Identity;
     }>;
 }

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

@@ -1,17 +1,17 @@
-import { GuidValue, IdentityPropertySyncBinding, IdentityPropertySyncBindingBase, IdentityProviderLogSortColumn, IdentityProviderRunLog, IdentityProviderSettings, IdentityProviderSettingsValue, IdentityProviderSettingsBuiltInValue } from "../../models";
+import { guid, IdentityPropertySyncBinding, IdentityPropertySyncBindingBase, IdentityProviderLogSortColumn, IdentityProviderRunLog, IdentityProviderSettings, IdentityProviderSettingsValue, IdentityProviderSettingsBuiltInValue } from "../../models";
 export declare class IdentitySyncProviderService {
     private httpClient;
-    getSettings: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue) => Promise<IdentityProviderSettings<T>>;
-    saveSettingsValue: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue, settings: T) => Promise<IdentityProviderSettings<T>>;
-    forceFullSync: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue) => Promise<IdentityProviderSettings<T>>;
-    forceFullUserSync: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue) => Promise<IdentityProviderSettings<T>>;
-    activateFullLog: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue) => Promise<IdentityProviderSettings<T>>;
-    togglePause: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: GuidValue) => Promise<IdentityProviderSettings<T>>;
-    getLogs: (providerId: GuidValue, pageNr?: number, pageSize?: number, sortColumn?: IdentityProviderLogSortColumn, sortDesc?: boolean) => Promise<{
+    getSettings: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid) => Promise<IdentityProviderSettings<T>>;
+    saveSettingsValue: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid, settings: T) => Promise<IdentityProviderSettings<T>>;
+    forceFullSync: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid) => Promise<IdentityProviderSettings<T>>;
+    forceFullUserSync: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid) => Promise<IdentityProviderSettings<T>>;
+    activateFullLog: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid) => Promise<IdentityProviderSettings<T>>;
+    togglePause: <T extends IdentityProviderSettingsValue = IdentityProviderSettingsBuiltInValue>(providerId: guid) => Promise<IdentityProviderSettings<T>>;
+    getLogs: (providerId: guid, pageNr?: number, pageSize?: number, sortColumn?: IdentityProviderLogSortColumn, sortDesc?: boolean) => Promise<{
         total: number;
         value: IdentityProviderRunLog[];
     }>;
-    getAllPropertyBindings: (providerId: GuidValue) => Promise<IdentityPropertySyncBinding[]>;
+    getAllPropertyBindings: (providerId: guid) => Promise<IdentityPropertySyncBinding[]>;
     addPropertyBinding: (value: IdentityPropertySyncBindingBase) => Promise<void>;
     removePropertyBinding: (value: IdentityPropertySyncBinding) => Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { ArchiveIdentityManagementQuery, BulkImportFileValidation, BulkImportUsersTasks, Guid, GuidValue, Identity, PropertyDefinition, PropertyValueBinding, ResolvedUserIdentity, ScopeTypes, TemplateFileData, TemplateFileSettings, UserAddWithAuthInfoReponse, UserAuthenticationInformation, UserIdentity, UserIdentityAddRequest, UserManagementQuery } from "../../models";
+import { ArchiveIdentityManagementQuery, BulkImportFileValidation, BulkImportUsersTasks, guid, Identity, PropertyDefinition, PropertyValueBinding, ResolvedUserIdentity, ScopeTypes, TemplateFileData, TemplateFileSettings, UserAddWithAuthInfoReponse, UserAuthenticationInformation, UserIdentity, UserIdentityAddRequest, UserManagementQuery } from "../../models";
 export declare class UserService {
     private httpClient;
     getAll: (query: UserManagementQuery) => Promise<{
@@ -8,7 +8,7 @@ export declare class UserService {
     get: (identity: UserIdentity) => Promise<ResolvedUserIdentity>;
     add: (value: UserIdentityAddRequest) => Promise<ResolvedUserIdentity>;
     addWithAuthInfo: (value: UserIdentityAddRequest, authInfo: UserAuthenticationInformation, sendAuthSetupAsEmail: boolean, comment: string, redirectUrl: string) => Promise<UserAddWithAuthInfoReponse>;
-    update: (user: UserIdentity, userTypeId: Guid, values: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>) => Promise<ResolvedUserIdentity>;
+    update: (user: UserIdentity, userTypeId: guid, values: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>) => Promise<ResolvedUserIdentity>;
     delete: (identity: UserIdentity) => Promise<void>;
     getAllDeleted: (query: ArchiveIdentityManagementQuery) => Promise<{
         total: number;
@@ -20,7 +20,7 @@ export declare class UserService {
     uploadBulkImportUsersFile: (file: File) => Promise<void>;
     preValidateBulkImportFile: (file: File) => Promise<BulkImportFileValidation>;
     getUserImportTasks: (businessProfileId: string) => Promise<BulkImportUsersTasks[]>;
-    getUserImportTaskDetails: (id: GuidValue) => Promise<BulkImportUsersTasks>;
+    getUserImportTaskDetails: (id: guid) => Promise<BulkImportUsersTasks>;
     ensureAzureAdUserByUsername(username: string): Promise<UserIdentity>;
     changeScope: (users: Array<Identity>, scopeType: ScopeTypes, scope: string) => Promise<void>;
 }

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

@@ -1,8 +1,8 @@
-import { ResolvedUserType, UserType, GuidValue } from "../../models";
+import { ResolvedUserType, UserType, guid } from "../../models";
 export declare class UserTypeService {
     private httpClient;
     getAll: () => Promise<UserType[]>;
-    inUse: (userTypeId: GuidValue) => Promise<boolean>;
+    inUse: (userTypeId: guid) => Promise<boolean>;
     resolve: (userTypes: UserType[]) => Promise<ResolvedUserType[]>;
     addOrUpdate: (resolvedUserType: ResolvedUserType) => Promise<ResolvedUserType>;
     reorder: (userTypes: UserType[]) => Promise<UserType[]>;

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

@@ -1,4 +1,4 @@
-import { PermissionBinding, GuidValue, SecurityContextParamRegistrationHandler, IMessageBusTopicSubscription, RoleResourceEvaluator, RolePermissionEvaluator, RolePermissionSettingWithContextParam } from "../../models";
+import { PermissionBinding, guid, SecurityContextParamRegistrationHandler, IMessageBusTopicSubscription, RoleResourceEvaluator, RolePermissionEvaluator, RolePermissionSettingWithContextParam } from "../../models";
 export declare class PermissionService {
     private securityService;
     private omniaContext;
@@ -14,8 +14,8 @@ export declare class PermissionService {
     private loadRulePromise;
     private get contextChangedMsgBus();
     constructor();
-    registerResourceEvaluator(roleId: GuidValue, evaluator: RoleResourceEvaluator): void;
-    registerPermissionEvaluator(roleId: GuidValue, evaluator: RolePermissionEvaluator): void;
+    registerResourceEvaluator(roleId: guid, evaluator: RoleResourceEvaluator): void;
+    registerPermissionEvaluator(roleId: guid, evaluator: RolePermissionEvaluator): void;
     ensureContextParam(key: string): SecurityContextParamRegistrationHandler;
     get onPermissionContextChanged(): IMessageBusTopicSubscription<void>;
     getPermissionBindings(roleIds: Array<string>, contextParams?: {
@@ -23,15 +23,15 @@ export declare class PermissionService {
     }): Promise<{
         [roleId: string]: PermissionBinding[];
     }>;
-    hasPermissionForRole(roleId: GuidValue, contextParams?: {
+    hasPermissionForRole(roleId: guid, contextParams?: {
         [key: string]: string | number;
     }): Promise<boolean>;
-    hasPermissionForRoles(roleIds: GuidValue[], contextParams?: {
+    hasPermissionForRoles(roleIds: guid[], contextParams?: {
         [key: string]: string | number;
     }): Promise<boolean>;
     addOrUpdatePermissionBindings(rolePermissionSettingWithParam: RolePermissionSettingWithContextParam, contextParams?: {
         [key: string]: string | number;
-    }, serviceId?: GuidValue): Promise<void>;
+    }, serviceId?: guid): Promise<void>;
     clearCache(): void;
     private getMergedContextParams;
     private getContextHash;

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

@@ -1,17 +1,17 @@
-import { EnterprisePropertyCategory, EnterprisePropertyDataTypeIds, EnterprisePropertyDefinition, PropertyConfiguration, PropertyDefinition, PropertyDefinitionId } from "../../models";
+import { EnterprisePropertyCategory, EnterprisePropertyDataTypeId, EnterprisePropertyDefinition, PropertyConfiguration, PropertyDefinition, PropertyDefinitionId } from "../../models";
 import { ServiceContainerContext } from "../../core";
 import { OmniaContext } from "../../contexts";
 import { EnterprisePropertyStore } from "../../stores/EnterprisePropertyStore";
 import { MultilingualStore } from "../../stores/MultilingualStore";
 import { EnterprisePropertyCategoryStore } from "../../stores/EnterprisePropertyCategoryStore";
 declare class EnterprisePropertyToPropertyDefinitionMap {
-    readonly enterprisePropertyDataTypeId: EnterprisePropertyDataTypeIds;
+    readonly enterprisePropertyDataTypeId: EnterprisePropertyDataTypeId;
     readonly propertyDefintionId: PropertyDefinitionId;
-    constructor(propDefinitionCtor: new () => PropertyDefinition<any, any, any>, enterprisePropertyDataTypeId: EnterprisePropertyDataTypeIds);
+    constructor(propDefinitionCtor: new () => PropertyDefinition<any, any, any>, enterprisePropertyDataTypeId: EnterprisePropertyDataTypeId);
 }
 export declare class EnterprisePropertiesProvider {
     static enterprisePropertyDataTypeToPropertyDefinition: Array<EnterprisePropertyToPropertyDefinitionMap>;
-    id: import("@omnia/fx-models").GuidValue;
+    id: import("@omnia/fx-models").guid;
     title: string;
     omniaContext: OmniaContext;
     enterprisePropertyStore: EnterprisePropertyStore;

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/BusinessProfilePropertyBindingProvider.d.ts

@@ -1,9 +1,9 @@
-import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+import { guid, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
 export declare class BusinessProfilePropertyBindingProvider implements IPropertyBindingProvider {
-    id: Guid;
+    id: guid;
     private static bindingConfigs;
     private localizationStore;
-    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindingById(bindingId: guid): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
     getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
     getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
 }

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/ExtendedEnterprisePropertyBindingProvider.d.ts

@@ -1,8 +1,8 @@
-import { GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, PropertyDisplaySettingsBase, IPropertyBindingProvider } from "../../../../models";
+import { guid, PropertyBinding, PropertyConfiguration, PropertyDefinition, PropertyDisplaySettingsBase, IPropertyBindingProvider } from "../../../../models";
 export declare class ExtendedEnterprisePropertiesPropertyBindingProvider implements IPropertyBindingProvider {
-    id: import("@omnia/fx-models").Guid;
+    id: guid;
     private enterprisePropertyStore;
-    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindingById(bindingId: guid): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
     getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
     getBindingsIncludeDeleted(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
     getConfiguration<TPropertyDefintion extends PropertyDefinition<any, PropertyDisplaySettingsBase, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/IdentityPropertyBindingProvider.d.ts

@@ -1,9 +1,9 @@
-import { Guid, GuidValue, IdentityTypes, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+import { guid, IdentityTypes, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
 export declare class IdentityPropertyBindingProvider implements IPropertyBindingProvider {
-    id: Guid;
+    id: guid;
     private static bindingConfigs;
     private localizationStore;
-    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindingById(bindingId: guid): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
     getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
     getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
     getBindingForIdentityType(type: IdentityTypes): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/UserPropertyBindingProvider.d.ts

@@ -1,9 +1,9 @@
-import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+import { guid, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
 export declare class UserPropertyBindingProvider implements IPropertyBindingProvider {
-    id: Guid;
+    id: guid;
     private static bindingConfigs;
     private localizationStore;
-    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindingById(bindingId: guid): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
     getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
     getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
 }

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertiesService.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceProperty, DataSourcePropertyDisplayInformation, GuidValue, PropertyDataSourceId, PropertyDefinition, PropertyValue, PropertyValuePrimitiveConverter, UserIdentity } from "../../../models";
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, guid, PropertyDefinition, PropertyValue, PropertyValuePrimitiveConverter, UserIdentity } from "../../../models";
 import { OmniaContext } from "../../../contexts";
 import { DataSourcePropertyDefinitionHandler } from "./DataSourcePropertyDefinitionHandler";
 import { IDataSourcePropertyCreator } from "./DataSourcePropertyProvider";
@@ -34,7 +34,7 @@ export declare class DataSourcePropertiesService {
     private externalChangeUserContextTrigger;
     private isChangeUserContextTrigger;
     getDataSources(): Promise<Array<{
-        sourceId: PropertyDataSourceId;
+        sourceId: guid;
         dataSourceTitle: string;
     }>>;
     isEqual(dataSourceProperty1: DataSourceProperty, dataSourceProperty2: DataSourceProperty): boolean;
@@ -48,7 +48,7 @@ export declare class DataSourcePropertiesService {
     addOnBeforeExternalWritebackHandler(writebackPreparationFunc: () => Promise<void>): void;
     registerExternalWritebackTrigger(onWriteBackPendingListener: () => void, getExist?: boolean): IWritebackTrigger;
     registerExternalChangeUserContextTrigger(onChangeUserContextListener: () => void): IChangeUserContextTrigger;
-    getProperties(datasourceId: PropertyDataSourceId): Promise<Array<DataSourceProperty>>;
+    getProperties(datasourceId: guid): Promise<Array<DataSourceProperty>>;
     updatePropertyValue(writeRequest: WritebackRequest): Promise<WritebackResult>;
     /**
      * Getting more than one possible creator for a given data source property means a selection must be made as several converters/creators could be used to create the desired propertydefinition, e.g. using ui component
@@ -78,7 +78,7 @@ export declare class DataSourcePropertiesService {
      * @param dataSourceId
      * @returns creator or undefined/null for not supported
      */
-    getDataSourcePropertyCreator(dataSourceId: GuidValue): Promise<IDataSourcePropertyCreator>;
+    getDataSourcePropertyCreator(dataSourceId: guid): Promise<IDataSourcePropertyCreator>;
     /**
      * Todo add something like this that a datasource can return if it supports creating datasourceproperties, i.e. graph But does this need more than from string, i.e. like separat creator manifest from datasource?
      * string is quite basic/ugly but migt not need anthing more now atleast

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyDefinitionHandler.d.ts

@@ -1,5 +1,5 @@
-import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDefinition, PropertyValueType, PropertyDefinitionId } from "../../../models";
-export type DataSourcePropertyDefintionHandlerId = GuidValue;
+import { DataSourceProperty, guid, PropertyConfiguration, PropertyDefinition, PropertyValueType, PropertyDefinitionId } from "../../../models";
+export type DataSourcePropertyDefintionHandlerId = guid;
 /**
  *
  * A plugin module for handling the different property definitions/values that can be created from the data source properties

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyProvider.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceProperty, DataSourcePropertyDisplayInformation, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition, PropertyDefinitionId, UserIdentity } from "../../../models";
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, PropertyConfiguration, guid, PropertyDefinition, PropertyDefinitionId, UserIdentity } from "../../../models";
 import { WritebackResult } from "./DataSourcePropertiesService";
 export interface IDataSourcePropertyCreator {
     createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
@@ -7,7 +7,7 @@ export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends
     readonly currentUser: UserIdentity;
     readonly isImpersonatedUser: boolean;
     abstract readonly title: string;
-    abstract readonly id: PropertyDataSourceId;
+    abstract readonly id: guid;
     abstract supportsWriteback2(properties: Array<TDataSourceProperty>): Promise<Array<{
         property: TDataSourceProperty;
         supportsWriteBack: boolean;