@omnia/fx 7.5.1-dev → 7.5.1

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

@@ -0,0 +1,13 @@
+import { IPagedResult, IPagedSearchResult, IPagedSearchResultToken, ISearchResult, IndexedDocument, NextPagedSearchRequest, PagedBatchSearchRequest, PagedSearchRequest, SearchRequest } from "../models";
+export declare class OmniaSearchService {
+    private httpClientOmniaSearch;
+    private baseUrl;
+    constructor();
+    multipleSearch: <TIndexedDocument extends IndexedDocument>(searchQueryRequest: PagedBatchSearchRequest, cancelRequest?: (cancelToken: any) => void) => Promise<IPagedSearchResult<TIndexedDocument>[]>;
+    search: <TIndexedDocument extends IndexedDocument>(searchRequest: SearchRequest) => Promise<ISearchResult<TIndexedDocument>>;
+    searchPaged: <TIndexedDocument extends IndexedDocument>(searchRequest: PagedSearchRequest) => Promise<IPagedResult<IPagedSearchResult<TIndexedDocument>, IPagedSearchResultToken>>;
+    searchPagedNext: <TIndexedDocument extends IndexedDocument>(nextRequest: NextPagedSearchRequest) => Promise<IPagedResult<IPagedSearchResult<TIndexedDocument>, IPagedSearchResultToken>>;
+    private mappingSearchResult;
+    private mappingSearchPagedResult;
+    private mappingSearchPagedNextResult;
+}

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

@@ -0,0 +1,7 @@
+import { PagedOmniaSearchResult, SearchUserIdentity, SearchUserQuery } from "../models";
+export declare class OmniaSearchUserService {
+    private httpClientOmniaSearch;
+    private baseUrl;
+    constructor();
+    searchPaged: (searchRequest: SearchUserQuery) => Promise<PagedOmniaSearchResult<SearchUserIdentity>>;
+}

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

@@ -0,0 +1,11 @@
+import { ReindexOmniaSearchUser, ReindexOmniaSearchUserLogSortColumn } from "../models";
+export declare class ReindexOmniaSearchUserService {
+    private httpClient;
+    private baseUrl;
+    constructor();
+    triggerReindexOmniaSearchUser: () => Promise<void>;
+    getLogs: (pageNr?: number, pageSize?: number, sortColumn?: ReindexOmniaSearchUserLogSortColumn, sortDesc?: boolean) => Promise<{
+        total: number;
+        value: ReindexOmniaSearchUser[];
+    }>;
+}

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

@@ -1,5 +1,5 @@
 import { OmniaContext } from "../contexts";
-import { GuidValue, OmniaRole, PermissionBinding, RolePermissionSettingWithContextParam, AzurePermissionResource, AuthenticationSettings } from "../models";
+import { GuidValue, OmniaRole, PermissionBinding, RolePermissionSettingWithContextParam, AzurePermissionResource, AuthenticationSettings, AuthenticationConfiguration } from "../models";
 export declare class SecurityService {
     private serviceContainerContext;
     omniaContext: OmniaContext;
@@ -16,6 +16,9 @@ export declare class SecurityService {
     getTenantRequiredAzureAdPermissions: () => Promise<AzurePermissionResource[]>;
     getConsentUrl: (redirectUrl: string) => Promise<string>;
     getAuthenticationSettings: () => Promise<AuthenticationSettings>;
-    saveAuthenticationSettings: (settings: AuthenticationSettings) => Promise<void>;
+    getAuthenticationSettingsByUserTypeId: (userTypeId: GuidValue) => Promise<AuthenticationSettings>;
+    saveAuthenticationSettings: (authConfig: AuthenticationConfiguration) => Promise<void>;
+    validateAzureAdPermissionsSynced: (permissionIds: Array<string>) => Promise<boolean>;
+    syncAzureAdPermissions: () => Promise<void>;
     private createHttpClientFromServiceId;
 }

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

@@ -17,6 +17,7 @@ export declare class VersionedLayoutService {
     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>;
     createTenantScopedLayout: (definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<VersionedLayoutCreationResponse>;
     createAlternateLayout: (versionedLayout: VersionedLayout, title: string, definition: VersionedLayoutDefinition) => Promise<VersionedAlternateLayoutCreationResponse>;
     deleteLayout: (layout: VersionedLayout) => Promise<void>;
@@ -33,6 +34,8 @@ export declare class VersionedLayoutService {
     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[]>;
     getTenantLayouts: () => Promise<VersionedLayout[]>;
     getLayoutVersionInformation: (dataIdentifier: IVersionedDataIdentifier) => Promise<IVersionInformation[]>;
     setDisplayBreakpointAlternateLayoutMapping: (versionedLayoutId: VersionedLayoutId, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => Promise<void>;

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

@@ -1,11 +1,11 @@
-import { ResolvedDynamicGroupIdentity, DynamicGroupIdentity, UserType, Future, GuidValue, TextPropertyValue, MultilingualTextPropertyValue } from "../../models";
+import { ResolvedDynamicGroupIdentity, DynamicGroupIdentity, UserType, Future, GuidValue, TextPropertyValue, MultilingualTextPropertyValue, DynamicGroupRuleSet } from "../../models";
 export declare class DynamicGroupService {
     private httpClient;
     private apiManagementBase;
     private apiIdentityBase;
     getAll: () => Future<ResolvedDynamicGroupIdentity[]>;
-    resolveUserTypes: (dynamicgroups: DynamicGroupIdentity[]) => Future<{
-        [uid: string]: UserType[];
+    resolveRuleSets: (dynamicgroups: DynamicGroupIdentity[]) => Future<{
+        [uid: string]: DynamicGroupRuleSet;
     }>;
     addOrUpdate: (addOrUpdateRequest: DynamicGroupIdentityAddOrUpdateRequest) => Future<ResolvedDynamicGroupIdentity>;
     reorder: (dynamicGroups: DynamicGroupIdentity[]) => Future<ResolvedDynamicGroupIdentity[]>;

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

@@ -1,7 +1,7 @@
-import { GuidValue, ResolvedGroupIdentity, GroupSortColumn, GroupIdentity, GroupIdentityAddOrUpdateRequest, Identity, GroupMembershipUpdateRequest, ArchiveSortColumn } from "../../models";
+import { ResolvedGroupIdentity, GroupIdentity, GroupIdentityAddOrUpdateRequest, Identity, GroupMembershipUpdateRequest, GroupManagementQuery, ArchiveIdentityManagementQuery } from "../../models";
 export declare class GroupService {
     private httpClient;
-    getAll: (searchText?: string, groupTypeId?: GuidValue, providerId?: GuidValue, pageNr?: number, pageSize?: number, sortColumn?: GroupSortColumn, sortDesc?: boolean) => Promise<{
+    getAll: (query: GroupManagementQuery) => Promise<{
         total: number;
         value: ResolvedGroupIdentity[];
     }>;
@@ -10,7 +10,7 @@ export declare class GroupService {
     delete: (identity: GroupIdentity) => Promise<void>;
     addMembers: (value: GroupMembershipUpdateRequest) => Promise<Identity[]>;
     removeMembers: (value: GroupMembershipUpdateRequest) => Promise<Identity[]>;
-    getAllDeleted: (searchText?: string, providerId?: GuidValue, pageNr?: number, pageSize?: number, sortColumn?: ArchiveSortColumn, sortDesc?: boolean) => Promise<{
+    getAllDeleted: (query: ArchiveIdentityManagementQuery) => Promise<{
         total: number;
         value: ResolvedGroupIdentity[];
     }>;

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

@@ -0,0 +1,7 @@
+import { Identity, ResetAccountRequest, UserAuthenticationInformation } from "../../models";
+export declare class IdentityAuthenticationService {
+    private httpClient;
+    updateAuthInfo: (userIdentity: Identity, authinfo: UserAuthenticationInformation, sendAuthSetupLinkByEmail?: boolean, sendAccountStatusChangedEmail?: boolean) => Promise<string>;
+    getAuthInfo: (userIdentity: Identity) => Promise<UserAuthenticationInformation>;
+    resetUserAuthentication: (userIdentity: Identity, resetAccountRequest: ResetAccountRequest) => Promise<string>;
+}

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

@@ -0,0 +1,8 @@
+import { Future, IdentityCreationRequest, IdentityCreationRequestApproval, IdentityCreationRequestQuery, IdentityCreationRequestQueryResult, IdentityCreationRequestUpdate } from "@omnia/fx-models";
+export declare class IdentityCreationRequestService {
+    private httpClient;
+    private baseRoute;
+    query: (identityCreationRequestQuery: IdentityCreationRequestQuery) => Future<IdentityCreationRequestQueryResult>;
+    approveOrRejectIdentityCreationRequest: (request: IdentityCreationRequestApproval) => Future<IdentityCreationRequest>;
+    update: (request: IdentityCreationRequestUpdate) => Future<IdentityCreationRequest>;
+}

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

@@ -0,0 +1,9 @@
+import { Future, GuidValue, IdentityCreationRequest, IdentityCreationRequestConfirmEmailResult, IdentityCreationRequestCreatedResponse, IdentityEmailConfirmationRequest, ResolvedIdentityCreationRequestSettings } from "@omnia/fx-models";
+export declare class IdentitySelfServiceService {
+    private httpClient;
+    private baseRoute;
+    resolveSettings: (businessProfileId: GuidValue) => 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,8 +1,10 @@
-import { Future, GroupIdentity, GroupMembers, Identity, IdentityQuery, IResolvedIdentity, ItemQueryResult, ResolvedUserIdentity, UserIdentity, GuidValue } from "@omnia/fx-models";
+import { Future, GroupIdentity, GroupMembers, Identity, IdentityQuery, IResolvedIdentity, ItemQueryResult, ResolvedUserIdentity, UserIdentity, GuidValue, UserIdentityQuery } from "@omnia/fx-models";
 export declare class IdentityService {
     private httpClient;
     private baseUrl;
     query(query: IdentityQuery): Future<ItemQueryResult<IResolvedIdentity>>;
+    queryUsers(query: UserIdentityQuery): Future<ItemQueryResult<IResolvedIdentity>>;
+    getSpecialIdentities(): Future<IResolvedIdentity[]>;
     resolveIdentities(identites: Identity[]): Future<{
         [uid: string]: IResolvedIdentity;
     }>;

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

@@ -1,4 +1,4 @@
-import { FontAwesomeIcon, Future, IdentityProperty, ResolvedUserIdentity, LanguagePropertyValue, PropertyBinding, PropertyDefinition, EnterprisePropertyDefinition } from "@omnia/fx-models";
+import { FontAwesomeIcon, Future, IdentityProperty, ResolvedUserIdentity, LanguagePropertyValue, PropertyBinding, PropertyDefinition, UserIdentityPropertyDefinition } from "@omnia/fx-models";
 export declare class UserPresenceStatus {
     private availability;
     private activity;
@@ -16,8 +16,9 @@ export declare class UserIdentityService {
     }>;
     getUserProperties(): Future<IdentityProperty[]>;
     addUserProperty(property: PropertyBinding<PropertyDefinition<any, any, any>>): Future<IdentityProperty>;
-    createUserProperty(property: EnterprisePropertyDefinition): Future<IdentityProperty>;
+    createUserProperty(property: UserIdentityPropertyDefinition): Future<IdentityProperty>;
     removeUserProperty(identityProperty: IdentityProperty): Future<void>;
+    updateUserProperty(identityProperty: IdentityProperty): Future<void>;
     terminateUserProperty(identityProperty: IdentityProperty): Future<void>;
     restoreIdentityProperty(identityProperty: IdentityProperty): Future<IdentityProperty>;
     setUiLanguageAsync(uiLanguage: LanguagePropertyValue): Future<ResolvedUserIdentity>;

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

@@ -1,18 +1,25 @@
-import { GuidValue, ResolvedUserIdentity, UserIdentity, UserIdentityAddRequest, UserSortColumn, PropertyValueBinding, PropertyDefinition, ArchiveSortColumn, Guid } from "../../models";
+import { ResolvedUserIdentity, UserIdentity, UserIdentityAddRequest, PropertyValueBinding, PropertyDefinition, Guid, UserManagementQuery, ArchiveIdentityManagementQuery, TemplateFileSettings, TemplateFileData, BulkImportFileValidation, BulkImportUsersTasks, GuidValue, UserAuthenticationInformation, UserAddWithAuthInfoReponse } from "../../models";
 export declare class UserService {
     private httpClient;
-    getAll: (searchText?: string, userTypeId?: GuidValue, providerId?: GuidValue, pageNr?: number, pageSize?: number, sortColumn?: UserSortColumn, sortDesc?: boolean) => Promise<{
+    getAll: (query: UserManagementQuery) => Promise<{
         total: number;
         value: ResolvedUserIdentity[];
     }>;
     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>;
     delete: (identity: UserIdentity) => Promise<void>;
-    getAllDeleted: (searchText?: string, providerId?: GuidValue, pageNr?: number, pageSize?: number, sortColumn?: ArchiveSortColumn, sortDesc?: boolean) => Promise<{
+    getAllDeleted: (query: ArchiveIdentityManagementQuery) => Promise<{
         total: number;
         value: ResolvedUserIdentity[];
     }>;
     restore: (identity: UserIdentity) => Promise<void>;
     purge: (identity: UserIdentity) => Promise<void>;
+    getBulkImportTemplateFileData: (templateFileSettings: TemplateFileSettings) => Promise<TemplateFileData>;
+    uploadBulkImportUsersFile: (file: File) => Promise<void>;
+    preValidateBulkImportFile: (file: File) => Promise<BulkImportFileValidation>;
+    getUserImportTasks: (ownerId: string) => Promise<BulkImportUsersTasks[]>;
+    getUserImportTaskDetails: (id: GuidValue) => Promise<BulkImportUsersTasks>;
+    ensureAzureAdUserByUsername(username: string): Promise<UserIdentity>;
 }

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

@@ -1,7 +1,8 @@
-import { ResolvedUserType, UserType } from "../../models";
+import { ResolvedUserType, UserType, GuidValue } from "../../models";
 export declare class UserTypeService {
     private httpClient;
     getAll: () => Promise<UserType[]>;
+    inUse: (userTypeId: GuidValue) => 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/identities/index.d.ts

@@ -6,3 +6,6 @@ export * from "./IdentitySyncProviderService";
 export * from "./UserService";
 export * from "./GroupService";
 export * from "./DynamicGroupService";
+export * from "./IdentityCreationRequestService";
+export * from "./IdentityAuthenticationService";
+export * from "./IdentitySelfServiceService";

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

@@ -41,3 +41,11 @@ export * from "./TenantPreSetupService";
 export * from "./ConnectedTenantService";
 export * from "./properties";
 export * from "./AzureOpenAIService";
+export * from "./AiSettingsService";
+export * from "./OmniaSearchService";
+export * from "./LoginLogService";
+export * from "./LinkStatusService";
+export * from "./AzureAdGroupService";
+export * from "./OmniaSearchUserService";
+export * from "./ReindexOmniaSearchUserService";
+export * from "./FeatureService";

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

@@ -1,14 +1,9 @@
 import { PropertyBinding, PropertyBindingId, PropertyConfiguration, PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType, PropertyValue } from "../../../models";
-export interface IPropertyBindingProvider {
-    getBindingById(bindingId: PropertyBindingId): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
-    getBindings(): Promise<Array<PropertyBinding<PropertyDefinition<PropertyValue, any, any>>>>;
-    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
-}
 export declare class PropertyBindingService {
-    private extendedEnterprisePropertiesPropertyBindingProvider;
-    private identityPropertyBindingProvider;
-    private get plugedInBindingProviders();
+    private serviceContainerContext;
+    private plugedInBindingProviders;
     private allBindings;
+    constructor();
     getBindingById(bindingId: PropertyBindingId): Promise<PropertyBinding<PropertyDefinition<PropertyValue, any, any>>>;
     getConfiguration<TPropertyDefinition extends PropertyDefinition<PropertyValue, any, any>>(bindingId: PropertyBindingId): Promise<PropertyConfiguration<TPropertyDefinition>>;
     getDisplaySettings<TPropertyDefinition extends PropertyDefinition<PropertyValue, any, any>>(bindingId: PropertyBindingId): Promise<PropertyDisplaySettingsType<TPropertyDefinition>>;

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

@@ -0,0 +1,9 @@
+import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+export declare class BusinessProfilePropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
+    private static bindingConfigs;
+    private localizationService;
+    getBindingById(bindingId: GuidValue): 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/{providers → bindingProviders}/ExtendedEnterprisePropertyBindingProvider.d.ts

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

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

@@ -1,6 +1,6 @@
-import { GuidValue, IdentityTypes, PropertyBinding, PropertyConfiguration, PropertyDefinition } from "../../../../models";
-import { IPropertyBindingProvider } from "../PropertyBindingService";
+import { Guid, GuidValue, IdentityTypes, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
 export declare class IdentityPropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
     private static bindingConfigs;
     private localizationService;
     getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;

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

@@ -0,0 +1,9 @@
+import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+export declare class UserPropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
+    private static bindingConfigs;
+    private localizationService;
+    getBindingById(bindingId: GuidValue): 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/{providers → bindingProviders}/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./ExtendedEnterprisePropertyBindingProvider";
 export * from "./IdentityPropertyBindingProvider";
+export * from "./UserPropertyBindingProvider";
+export * from "./BusinessProfilePropertyBindingProvider";

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

@@ -1,2 +1,2 @@
-export * from "./providers";
 export * from "./PropertyBindingService";
+export * from "./bindingProviders";

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

@@ -1,7 +1,7 @@
-import { DataSourceProperty, DataSourcePropertyDisplayInformation, GuidValue, PropertyDataSourceId, PropertyDefinition, PropertyValue, UserIdentity } from "../../../models";
-import { IDataSourcePropertyCreator } from "./DataSourcePropertyProvider";
-import { DataSourcePropertyDefinitionHandler } from "./DataSourcePropertyDefinitionHandler";
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, GuidValue, PropertyDataSourceId, PropertyDefinition, PropertyValue, PropertyValuePrimitiveConverter, UserIdentity } from "../../../models";
 import { OmniaContext } from "../../../contexts";
+import { DataSourcePropertyDefinitionHandler } from "./DataSourcePropertyDefinitionHandler";
+import { IDataSourcePropertyCreator } from "./DataSourcePropertyProvider";
 export declare enum WriteBackStatus {
     WrittenOk = 0,
     ConversionError = 1,
@@ -32,10 +32,13 @@ export declare class DataSourcePropertiesService {
     omniaContext: OmniaContext;
     private externalWritebackTrigger;
     private externalChangeUserContextTrigger;
+    private isChangeUserContextTrigger;
     getDataSources(): Promise<Array<{
         sourceId: PropertyDataSourceId;
         dataSourceTitle: string;
     }>>;
+    isEqual(dataSourceProperty1: DataSourceProperty, dataSourceProperty2: DataSourceProperty): boolean;
+    isEqualAsync(dataSourceProperty1: DataSourceProperty, dataSourceProperty2: DataSourceProperty): Promise<boolean>;
     getSpecificUser(): UserIdentity;
     setSpecificUser(specificUser: UserIdentity): void;
     changeUserContext(user: UserIdentity): void;
@@ -46,6 +49,7 @@ export declare class DataSourcePropertiesService {
     registerExternalWritebackTrigger(onWriteBackPendingListener: () => void, getExist?: boolean): IWritebackTrigger;
     registerExternalChangeUserContextTrigger(onChangeUserContextListener: () => void): IChangeUserContextTrigger;
     getProperties(datasourceId: PropertyDataSourceId): 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
      * Each DataSourcePropertyDefinitionHandler has it own unique id, which can be used to persist the choice of the selection, note a persisted selection could point to a handler no longer provided by the system
@@ -60,6 +64,7 @@ export declare class DataSourcePropertiesService {
         valueFromSource: any;
         dataSourceProperty: DataSourceProperty;
     }>>;
+    getPropertyValuePrimitiveConverter(propertyValueCreator: DataSourcePropertyDefinitionHandler<PropertyDefinition<PropertyValue, any, any>, DataSourceProperty, any, any>): Promise<PropertyValuePrimitiveConverter>;
     supportsWriteback(dataSourceProperties: Array<DataSourceProperty>): Promise<Array<{
         property: DataSourceProperty;
         supportsWriteBack: boolean;

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

@@ -17,12 +17,11 @@ export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends
         valueToWriteback: any;
     }>): Promise<Array<WritebackResult>>;
     /**
-     * Get the current display information for a data source property, this is resolved from a data source property, as this information migth relay on system/source data that change over time
-     * */
-    abstract getPropertyDisplayInformation(dataSourceProperties: Array<TDataSourceProperty>): Promise<Array<{
-        property: TDataSourceProperty;
-        displayInformation: DataSourcePropertyDisplayInformation;
-    }>>;
+     * Should compare the properties 1 and 2 and return true if they match, on property values
+     * @param dataSourceProperty1 DataSourceProperty 1
+     * @param dataSourceProperty2 DataSourceProperty 2
+     */
+    abstract isEqual(dataSourceProperty1: DataSourceProperty, dataSourceProperty2: DataSourceProperty): boolean;
     /**
      * Get all the properties supported by this data source, this is the @type {TDataSourceProperty} is extended to represent the information within a data source to identify a data source property
      * */
@@ -43,6 +42,13 @@ export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends
         valueFromSource: any;
         dataSourceProperty: TDataSourceProperty;
     }>>;
+    /**
+     * Get the current display information for a data source property, this is resolved from a data source property, as this information migth relay on system/source data that change over time
+     * */
+    abstract getPropertyDisplayInformation(dataSourceProperties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        displayInformation: DataSourcePropertyDisplayInformation;
+    }>>;
 }
 export declare abstract class DynamicPropertyDataSource<TDataSourceProperty extends DataSourceProperty> extends PropertyDataSourceBase<TDataSourceProperty> implements IDataSourcePropertyCreator {
     abstract createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;

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

@@ -21,6 +21,11 @@ export interface OmniaSharedBootstrapData {
     servingMode?: boolean;
     serviceDnsMapping: OmniaServiceToDnsMapping;
     authDisabled?: boolean;
+    analytics: OmniaAnalytics;
+}
+export interface OmniaAnalytics {
+    paq: any[];
+    enabled: boolean;
 }
 export interface OmniaServiceToDnsMapping {
     [serviceId: string]: string;

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

@@ -0,0 +1,36 @@
+import { AiSettings } from "../models";
+import { GuidValue } from "../shared";
+import { Store } from "./Store";
+export declare class AiSettingsStore extends Store {
+    private settings;
+    private readonly tenantKey;
+    private currentSetting;
+    private aiSettingService;
+    constructor();
+    onActivated(): void;
+    onDisposing(): void;
+    private generateSettingKey;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        getSettingsByType: (type: string, businessProfileId?: GuidValue) => AiSettings[];
+        currentEditing: () => AiSettings;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        settingsByType: import("./Store").StoreMutation<(newState: Array<AiSettings>, type: string, businessProfileId?: GuidValue) => void, (newState: AiSettings[], type: string, businessProfileId?: GuidValue) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        currentEditing: import("./Store").StoreMutation<(newState: AiSettings) => void, (newState: AiSettings) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        loadSettingsByType: import("./Store").StoreAction<unknown, (type: string, businessProfileId?: GuidValue) => void, (result: AiSettings[], type: string, businessProfileId?: GuidValue) => void, (failureReason: any, type: string, businessProfileId?: GuidValue) => void, (type: string, businessProfileId?: GuidValue) => Promise<AiSettings[]>>;
+        updateSetting: import("./Store").StoreAction<unknown, (model: AiSettings) => void, (result: AiSettings, model: AiSettings) => void, (failureReason: any, model: AiSettings) => void, (model: AiSettings) => Promise<AiSettings>>;
+        addSetting: import("./Store").StoreAction<unknown, (model: AiSettings) => void, (result: AiSettings, model: AiSettings) => void, (failureReason: any, model: AiSettings) => void, (model: AiSettings) => Promise<AiSettings>>;
+        removeSetting: import("./Store").StoreAction<unknown, (id: number) => void, (result: void, id: number) => void, (failureReason: any, id: number) => void, (id: number) => Promise<void>>;
+    };
+}

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

@@ -1,11 +1,14 @@
+import { OmniaContext } from "../contexts";
 import { GuidValue, AzureAdDefaultUserProperties, AdProperty } from "../models";
 import { Store } from "./Store";
 export declare class AzureAdUserStore extends Store {
     private azureAdService;
+    omniaCtx: OmniaContext;
     private resolvePropertiesValuePromises;
     private resolvePropertiesInfoPromise;
     private resolveSyncPropertiesInfoPromise;
     private defaultSelectUserProperties;
+    private isOmniaUser;
     actions: {
         getUserPropertiesValue: import("./Store").StoreAction<unknown, (id: GuidValue, selectMoreProperties?: string[]) => void, (result: AzureAdDefaultUserProperties, id: GuidValue, selectMoreProperties?: string[]) => void, (failureReason: any, id: GuidValue, selectMoreProperties?: string[]) => void, <T extends AzureAdDefaultUserProperties = AzureAdDefaultUserProperties>(id: GuidValue, selectMoreProperties?: string[]) => Promise<T>>;
         getUserPropertiesMetadata: import("./Store").StoreAction<unknown, () => void, (result: string[]) => void, (failureReason: any) => void, () => Promise<string[]>>;

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

@@ -3,6 +3,7 @@ import { DynamicGroupIdentityAddOrUpdateRequest } from "../services";
 import { Store } from "./Store";
 export declare class DynamicGroupStore extends Store {
     private dynamicGroupService;
+    private userTypeStore;
     private loadAllDynamicGroupsPromise;
     private resolvedDynamicGroups;
     private resolvedUserTypes;

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

@@ -10,6 +10,7 @@ export declare class EnterprisePropertyStore extends Store {
     private ensuredLoadDataPromise;
     private ensuredQueryablePropertiesLoadedPromise;
     private editingProperty;
+    private ensureLoadExtendedEnterprisePropertiesPromise;
     enterprisePropertyDefinitions: import("./Store").StoreState<EnterprisePropertyDefinition[]>;
     enterprisePropertyDataTypes: import("./Store").StoreState<EnterprisePropertyDataType[]>;
     computedPropertyMapping: import("./Store").StoreState<{
@@ -45,6 +46,7 @@ export declare class EnterprisePropertyStore extends Store {
     actions: {
         refresh: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
         ensureLoadData: import("./Store").StoreAction<unknown, (forceReload?: boolean) => void, (result: boolean, forceReload?: boolean) => void, (failureReason: any, forceReload?: boolean) => void, (forceReload?: boolean) => Promise<boolean>>;
+        ensureLoadExtendedEnterpriseProperties: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
         addEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         updateEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         removeEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterprisePropertyId: GuidValue) => void, (result: boolean, enterprisePropertyId: GuidValue) => void, (failureReason: any, enterprisePropertyId: GuidValue) => void, (enterprisePropertyId: GuidValue) => Promise<boolean>>;

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

@@ -6,8 +6,10 @@ export declare class GroupIdentityStore extends Store {
     private loadDynamicGroupsPromise;
     private loadGroupTypesPromise;
     private dynamicGroupsState;
+    private groupTypes;
     getters: {
         getDynamicGroups: () => ResolvedDynamicGroupIdentity[];
+        groupTypes: () => GroupType[];
     };
     actions: {
         ensureLoadDynamicGroups: import("./Store").StoreAction<unknown, () => void, (result: ResolvedDynamicGroupIdentity[]) => void, (failureReason: any) => void, () => Promise<ResolvedDynamicGroupIdentity[]>>;

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

@@ -1,9 +1,21 @@
-import { Future, Identity, IdentityQuery, IResolvedIdentity } from "../models";
-import { Store } from "./Store";
-export declare class IdentityStore extends Store {
+import { Future, IResolvedIdentity, Identity, IdentityQuery, ItemQueryResult } from "../models";
+import { Store, StoreAction, MapActionOnDispatching, MapActionOnDispatched, MapActionOnFailure } from "./Store";
+type QueryActionDispatcher = (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>;
+type ResolveIdentitiesActionDispatcher = (identities: Identity[]) => Promise<{
+    [uid: string]: IResolvedIdentity;
+}>;
+export interface IIdentityPickerStore {
+    getters: {
+        getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
+    };
+    actions: {
+        query: StoreAction<unknown, MapActionOnDispatching<QueryActionDispatcher>, MapActionOnDispatched<QueryActionDispatcher>, MapActionOnFailure<QueryActionDispatcher>, QueryActionDispatcher>;
+        resolveIdentities: StoreAction<unknown, MapActionOnDispatching<ResolveIdentitiesActionDispatcher>, MapActionOnDispatched<ResolveIdentitiesActionDispatcher>, MapActionOnFailure<ResolveIdentitiesActionDispatcher>, ResolveIdentitiesActionDispatcher>;
+    };
+}
+export declare class IdentityStore extends Store implements IIdentityPickerStore {
     private identityService;
     private identitiesState;
-    private dynamicGroupsState;
     getters: {
         getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
         getResolvedIdentities: () => IResolvedIdentity[];
@@ -12,12 +24,13 @@ export declare class IdentityStore extends Store {
         addOrUpdateResolvedIdentities: (resolvedIdentities: IResolvedIdentity[]) => void;
     };
     actions: {
-        resolveIdentities: import("./Store").StoreAction<unknown, (identities: Identity[]) => void, (result: {
+        resolveIdentities: StoreAction<unknown, (identities: Identity[]) => void, (result: {
             [uid: string]: IResolvedIdentity;
         }, identities: Identity[]) => void, (failureReason: any, identities: Identity[]) => void, (identities: Identity[]) => Promise<{
             [uid: string]: IResolvedIdentity;
         }>>;
-        query: import("./Store").StoreAction<unknown, (query: IdentityQuery) => void, (result: import("@omnia/fx-models").ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<import("@omnia/fx-models").ItemQueryResult<IResolvedIdentity>>>;
+        query: StoreAction<unknown, (query: IdentityQuery) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>>;
     };
     protected onActivated(): void;
 }
+export {};

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

@@ -0,0 +1,23 @@
+import { Store } from "./Store";
+export interface OrderedUrl {
+    order: number;
+    url: string;
+}
+export declare class LinkReferencesStore extends Store {
+    private previousUrlsStack;
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        previousUrl: () => OrderedUrl;
+        fullHistory: () => OrderedUrl[];
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        push: import("./Store").StoreMutation<(newState: string) => void, (newState: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+}

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

@@ -1,4 +1,4 @@
-import { OrgTreeUser, UserInformation, TenantPeopleInformation, UserIdentity } from "../models";
+import { OrgTreeUser, UserInformation, TenantPeopleInformation, UserIdentity, ResolvedUserIdentity } from "../models";
 import { Store } from "./Store";
 import { ProfileCardService } from "../services/ProfileCardService";
 import { LocalizationService } from "../services/LocalizationService";
@@ -14,6 +14,8 @@ export declare class ProfileCardStore extends Store {
     userInformation: import("./Store").StoreState<{
         [uid: string]: UserInformation;
     }>;
+    userInProfile: import("./Store").StoreState<UserIdentity>;
+    userInProfileResolved: import("./Store").StoreState<ResolvedUserIdentity>;
     private enablePeopleInformation;
     private profileCardDialogTabs;
     tenantPeopleInfomation: import("./Store").StoreState<TenantPeopleInformation>;
@@ -23,15 +25,18 @@ export declare class ProfileCardStore extends Store {
         getEnablePeopleInformation: () => boolean;
         getProfileCardDialogTabs: () => Array<string>;
         getTenantPeopleInformationModel: () => TenantPeopleInformation;
+        getResolvedUserInProfile: () => ResolvedUserIdentity;
     };
     mutations: {
         setEnablePeopleInformation: import("./Store").StoreMutation<(value: boolean) => void, (value: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         setProfieCardDialogTabs: import("./Store").StoreMutation<(tabs: string[]) => void, (tabs: string[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         setTenantPeopleInformation: import("./Store").StoreMutation<(value: TenantPeopleInformation) => void, (value: TenantPeopleInformation) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setUserInProfile: import("./Store").StoreMutation<(user: UserIdentity) => void, (user: UserIdentity) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
         loadUser: import("./Store").StoreAction<unknown, (user: UserIdentity) => void, (result: OrgTreeUser, user: UserIdentity) => void, (failureReason: any, user: UserIdentity) => void, (user: UserIdentity) => Promise<OrgTreeUser>>;
         loadUserProperties: import("./Store").StoreAction<unknown, (user: UserIdentity, refresh?: boolean) => void, (result: UserInformation, user: UserIdentity, refresh?: boolean) => void, (failureReason: any, user: UserIdentity, refresh?: boolean) => void, (user: UserIdentity, refresh?: boolean) => Promise<UserInformation>>;
+        loadUserInProfile: import("./Store").StoreAction<unknown, () => void, (result: ResolvedUserIdentity) => void, (failureReason: any) => void, () => Promise<ResolvedUserIdentity>>;
     };
     onActivated(): void;
     onDisposing(): void;