@omnia/fx 7.1.553-dev → 7.5.0

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

@@ -0,0 +1,35 @@
+import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDefinition, PropertyValueType, PropertyDefinitionId } from "../../../models";
+export type DataSourcePropertyDefintionHandlerId = GuidValue;
+/**
+ *
+ * A plugin module for handling the different property definitions/values that can be created from the data source properties
+ *
+ * */
+export declare abstract class DataSourcePropertyDefinitionHandler<TPropertyDefinition extends PropertyDefinition<any, any, any>, TDataSourceProperty extends DataSourceProperty, DataSourceReadDataType, DataSourceWriteBackType> {
+    /**
+     * A unique constant id for this converter
+     * */
+    abstract readonly Id: DataSourcePropertyDefintionHandlerId;
+    /**
+     * Handler title, will be used if more than one handler exists for any given propertyDefinition
+     * E.g "Ticks to DateTimeProperty", and one other handler nemed "String to DateTimeProperty", i.e "TDataSourceData To TPropertyDefinition" or so.
+     * */
+    abstract readonly title: string;
+    /**
+     * The property defintion this handler is intended to handle
+     * */
+    readonly propertyDefintionId: PropertyDefinitionId;
+    /**
+     * The ctor for the definition which this handler is defined for, only used to link with definitionId in a typesafe way
+     * */
+    constructor(propertyDefinitionCtor: new () => TPropertyDefinition);
+    propertyConfiguration?: PropertyConfiguration<TPropertyDefinition>;
+    /**
+     * This method should convert from the data source value to PropertyValue matching the TPropertyDefinition
+     * */
+    abstract propertyValueCreator(dataSourceProperty: TDataSourceProperty, valueFromSource: DataSourceReadDataType, propertyconfiguration?: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyValueType<TPropertyDefinition>>;
+    /**
+     * This method should convert from PropertyValue matching the TPropertyDefinition to the write back data type expected for data source to be able to writeback
+     * */
+    abstract propertyWriteBackDataCreator(dataSourceProperty: TDataSourceProperty, propertyValue: PropertyValueType<TPropertyDefinition>): Promise<DataSourceWriteBackType>;
+}

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

@@ -0,0 +1,55 @@
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition, PropertyDefinitionId, UserIdentity } from "../../../models";
+import { WritebackResult } from "./DataSourcePropertiesService";
+export interface IDataSourcePropertyCreator {
+    createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
+}
+export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends DataSourceProperty> {
+    readonly currentUser: UserIdentity;
+    readonly isImpersonatedUser: boolean;
+    abstract readonly title: string;
+    abstract readonly id: PropertyDataSourceId;
+    abstract supportsWriteback2(properties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        supportsWriteBack: boolean;
+    }>>;
+    abstract writeback(properties: Array<{
+        dataSourceProperty: TDataSourceProperty;
+        valueToWriteback: any;
+    }>): Promise<Array<WritebackResult>>;
+    /**
+     * 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
+     * */
+    abstract getProperties(): Promise<Array<TDataSourceProperty>>;
+    /**
+     * Returns the property configuration that should be used when representing this property, if the propertyconfiguration is not know by the source return null
+     * */
+    abstract getPropertyConfiguration(property: TDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, any, any>>>;
+    /**
+     * Returns the property definition id that should be used for representing this property, if the propertydefinition is not know by the source return undefined, selection among source property creators can be made explicitly
+     * */
+    abstract getPropertyDefinition(property: TDataSourceProperty): Promise<PropertyDefinitionId>;
+    /**
+     * Get the value for datasource properties, the returned data type TDataSourceData must have a matching DataSourcePropertyDefinitionHandler<any,any,TDataSourceData>
+     * I.e. so a handler exists that can create property values from the source value type
+     * */
+    abstract getPropertyValues(properties: Array<TDataSourceProperty>): Promise<Array<{
+        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/services/properties/datasource/TestDataSourceService.d.ts

@@ -0,0 +1,6 @@
+import { DataSourcePropertiesService } from "./DataSourcePropertiesService";
+export declare class TestDataSourcePropertiesService {
+    dataSourcePropertiesService: DataSourcePropertiesService;
+    constructor();
+    runTest(): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export * from "./DataSourcePropertyProvider";
+export * from "./DataSourcePropertyDefinitionHandler";
+export * from "./DataSourcePropertiesService";
+export * from "./TestDataSourceService";

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

@@ -0,0 +1,3 @@
+export * from "./bindings";
+export * from "./datasource";
+export * from "./EnterprisePropertiesProvider";

package/internal-do-not-import-from-here/shared/http/Bring.d.ts

@@ -35,7 +35,7 @@ export declare class BringBuilder {
      * @return {*}
      * @memberof BringBuilder
      */
-    withJsonApiSupport(): this;
+    withJsonApiSupport(): BringBuilder;
     /**
      * Creates the Bring instance with the configuration options
      *

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

@@ -13,12 +13,19 @@ export interface OmniaSharedBootstrapData {
      */
     tokenKey?: OmniaToken;
     tokenRef: GuidValue;
+    identity: string;
     licenses: Array<Guid>;
     hubDev?: boolean;
     realtimeDevPort?: string;
     tenant: TenantIdentifier;
     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/shared/models/Tokens.d.ts

@@ -6,8 +6,9 @@ export interface OmniaToken {
     expires: number;
     forDevIntent: boolean;
 }
-export interface OmniaTokenRefWithTenant {
+export interface OmniaTokenRef {
     tenantId: GuidValue;
+    identityId: string;
     tokenRef: GuidValue;
     localDev: boolean;
 }

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/AppNamingPolicyStore.d.ts

@@ -12,7 +12,7 @@ export declare class AppNamingPolicyStore extends Store {
     actions: {
         ensureLoad: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue) => void, (result: void, appDefinitionId: GuidValue) => void, (failureReason: any, appDefinitionId: GuidValue) => void, (appDefinitionId: GuidValue) => Promise<void>>;
         ensureLoadById: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue) => void, (result: void, appDefinitionId: GuidValue) => void, (failureReason: any, appDefinitionId: GuidValue) => void, (appDefinitionId: GuidValue) => Promise<void>>;
-        add: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (result: void, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (failureReason: any, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => Promise<void>>;
+        add: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (result: AppNamingPolicy, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (failureReason: any, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => Promise<AppNamingPolicy>>;
         update: import("./Store").StoreAction<unknown, (policy: AppNamingPolicy) => void, (result: void, policy: AppNamingPolicy) => void, (failureReason: any, policy: AppNamingPolicy) => void, (policy: AppNamingPolicy) => Promise<void>>;
         delete: import("./Store").StoreAction<unknown, (policy: AppNamingPolicy) => void, (result: void, policy: AppNamingPolicy) => void, (failureReason: any, policy: AppNamingPolicy) => void, (policy: AppNamingPolicy) => 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,14 +10,17 @@ 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<{
-        [serviceIdKey: string]: EnterprisePropertyColumnMapping[];
+        [serviceIdWithTableKey: string]: EnterprisePropertyColumnMapping[];
     }>;
+    enterprisePropertyDefinitionsDeleted: import("./Store").StoreState<EnterprisePropertyDefinition[]>;
     getters: {
         enterprisePropertyDefinitionsByIndexedTypes: (indexTypes: Array<PropertyIndexedType>) => EnterprisePropertyDefinition[];
         enterprisePropertyDefinitions: () => EnterprisePropertyDefinition[];
+        extenedEnterprisePropertyDefinitionsDeleted: () => EnterprisePropertyDefinition[];
         enterprisePropertyDefinitionsGroupByCategory: () => {
             [categoryId: string]: EnterprisePropertyDefinition[];
         };
@@ -42,7 +45,8 @@ 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, () => 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>>;
@@ -54,6 +58,7 @@ export declare class EnterprisePropertyStore extends Store {
         addQueryableProperties: import("./Store").StoreAction<unknown, (serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (result: void, serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (failureReason: any, serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => Promise<void>>;
     };
     private ensureUniqueMultilingualTitle;
+    private getServiceIdWithTableKey;
     onActivated(): void;
     onDisposing(): void;
 }

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 "@omnia/fx-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/IdentitySyncProviderStore.d.ts

@@ -13,6 +13,7 @@ export declare class IdentitySyncProviderStore extends Store {
             ended?: Date;
             status: import("@omnia/fx-models").IdentityProviderRunStatus;
             fullSyncOnNextRun: boolean;
+            fullUserSyncOnNextRun: boolean;
             fullLogOnNextRun: boolean;
             togglePauseOnNextRun: boolean;
             setupComplete: boolean;
@@ -33,7 +34,7 @@ export declare class IdentitySyncProviderStore extends Store {
             total: number;
             value: import("@omnia/fx-models").IdentityProviderRunLog[];
         }>>;
-        getSyncPropertyBindings: import("./Store").StoreAction<unknown, (providerId: GuidValue) => void, (result: IdentityPropertySyncBinding[], providerId: GuidValue) => void, (failureReason: any, providerId: GuidValue) => void, (providerId: GuidValue) => Promise<IdentityPropertySyncBinding[]>>;
+        getSyncPropertyBindings: import("./Store").StoreAction<unknown, (providerId: GuidValue, refesh?: boolean) => void, (result: IdentityPropertySyncBinding[], providerId: GuidValue, refesh?: boolean) => void, (failureReason: any, providerId: GuidValue, refesh?: boolean) => void, (providerId: GuidValue, refesh?: boolean) => Promise<IdentityPropertySyncBinding[]>>;
         addSyncPropertyBinding: import("./Store").StoreAction<unknown, (value: IdentityPropertySyncBindingBase) => void, (result: void, value: IdentityPropertySyncBindingBase) => void, (failureReason: any, value: IdentityPropertySyncBindingBase) => void, (value: IdentityPropertySyncBindingBase) => Promise<void>>;
         removeSyncPropertyBinding: import("./Store").StoreAction<unknown, (value: IdentityPropertySyncBinding) => void, (result: void, value: IdentityPropertySyncBinding) => void, (failureReason: any, value: IdentityPropertySyncBinding) => void, (value: IdentityPropertySyncBinding) => Promise<void>>;
     };

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;

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

@@ -19,10 +19,10 @@ export interface StateMutationLog {
 export interface StateActionLog {
     func: any;
 }
-type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
-type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
-type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
-type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
+export type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
+export type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
+export type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
+export type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
 export declare class StoreLogger {
     private _logState;
     enabled: boolean;
@@ -148,4 +148,3 @@ export declare class StoreMutation<T extends Function, CommitFunc extends Functi
     onCommiting(fn: T): IMessageBusSubscriptionHandler;
     onCommited(fn: T): IMessageBusSubscriptionHandler;
 }
-export {};

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

@@ -3,21 +3,17 @@ import { Store } from "./Store";
 import dayjs from "dayjs";
 export declare class TimeZoneStore extends Store {
     private timeZoneService;
-    private omniaContext;
     private localTimeZoneId;
     private timeZoneUnits;
     private loadTimeZoneCollectionPromise;
-    private loadCurrenTimeZoneSettingsPromise;
-    private currentUser;
-    private currentTimeZone;
     getters: {
         localTimeZoneId: () => string;
         timeZones: () => TimeZoneUnit[];
         convertToCurrentUserTimeZone: (utcDatetime: string) => dayjs.Dayjs;
+        convertToTimeZone: (utcDatetime: string, timezone: string) => dayjs.Dayjs;
     };
     actions: {
         ensureTimeZones: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
-        ensureLoadedCurrentTimeZoneSettings: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
     };
     protected onActivated(): void;
 }

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

@@ -1,4 +1,4 @@
-import { GroupIdentity, IdentityPropertyBinding, IdentityProperty, ResolvedUserIdentity, UserIdentity, GuidValue, Identity } from "@omnia/fx-models";
+import { GroupIdentity, GuidValue, Identity, IdentityProperty, UserIdentityPropertyDefinition, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
 import { MediaPickerService, UserPresenceStatus } from "../services";
 import { Store } from "./Store";
 export declare class UserIdentityStore extends Store {
@@ -21,8 +21,12 @@ export declare class UserIdentityStore extends Store {
         getUserImageUrl: (user: ResolvedUserIdentity, imageRatioId?: number, scalingId?: number) => string;
     };
     actions: {
-        addUserProperty: import("./Store").StoreAction<unknown, (property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (result: void, property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (failureReason: any, property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (property: IdentityPropertyBinding) => Promise<void>>;
+        addUserProperty: import("./Store").StoreAction<unknown, (property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (result: void, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (failureReason: any, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (property: PropertyBinding<PropertyDefinition<any, any, any>>) => Promise<void>>;
+        createUserProperty: import("./Store").StoreAction<unknown, (property: UserIdentityPropertyDefinition) => void, (result: void, property: UserIdentityPropertyDefinition) => void, (failureReason: any, property: UserIdentityPropertyDefinition) => void, (property: UserIdentityPropertyDefinition) => Promise<void>>;
         removeUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        updateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        terminateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        restoreUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
         ensureLoadUserProperties: import("./Store").StoreAction<unknown, () => void, (result: IdentityProperty[]) => void, (failureReason: any) => void, () => Promise<IdentityProperty[]>>;
         resolveUsersIdentity: import("./Store").StoreAction<unknown, (users: UserIdentity[]) => void, (result: {
             [uid: string]: ResolvedUserIdentity;

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

@@ -0,0 +1,42 @@
+import { Future, GuidValue, IResolvedIdentity, Identity, IdentityQuery, ItemQueryResult, UserIdentityQuery } from "@omnia/fx-models";
+import { IdentityService } from "../services";
+import { IIdentityPickerStore, IdentityStore } from "./IdentityStore";
+import { Store } from "./Store";
+export declare class UserTypeIdentityStore extends Store {
+    private identityService;
+    private identityStore;
+    private userTypeIdentitiesState;
+    getters: {
+        createIdentityPickerStore: (userType: GuidValue) => UserTypeIdentityPickerStore;
+        getIdentitiesOfUserType: (userType: GuidValue) => ItemQueryResult<IResolvedIdentity>;
+    };
+    actions: {
+        resolveIdentities: import("./Store").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, userTypeId: GuidValue) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery, userTypeId: GuidValue) => void, (failureReason: any, query: IdentityQuery, userTypeId: GuidValue) => void, (query: IdentityQuery, userTypeId: GuidValue) => Future<ItemQueryResult<IResolvedIdentity>>>;
+        ensureUserTypeIdentities: import("./Store").StoreAction<unknown, (query: UserIdentityQuery, userType: GuidValue) => void, (result: ItemQueryResult<IResolvedIdentity>, query: UserIdentityQuery, userType: GuidValue) => void, (failureReason: any, query: UserIdentityQuery, userType: GuidValue) => void, (query: UserIdentityQuery, userType: GuidValue) => Promise<ItemQueryResult<IResolvedIdentity>>>;
+    };
+    protected onActivated(): void;
+}
+export declare class UserTypeIdentityPickerStore extends Store implements IIdentityPickerStore {
+    private userTypeIdentityStore;
+    private identityStore;
+    private identityService;
+    private userType;
+    constructor(userTypeIdentityStore: UserTypeIdentityStore, identityStore: IdentityStore, identityService: IdentityService, userType: GuidValue);
+    getters: {
+        getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
+    };
+    actions: {
+        resolveIdentities: import("./Store").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: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>>;
+    };
+    protected onActivated(): void;
+}

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

@@ -13,6 +13,7 @@ export declare class VersionedLayoutStore extends Store {
         getLatestRef: (dataIdentifier: IVersionedDataIdentifier) => LatestReferenceResponse;
         getAppScopedLayoutWithDefinition: <Definition extends VersionedLayoutDefinition>(appInstanceId: GuidValue, definition: new () => Definition) => VersionedLayout[];
         getTenantScopedLayoutWithDefinition: <Definition_1 extends VersionedLayoutDefinition>(definition: new () => Definition_1) => VersionedLayout[];
+        getBusinessProfileScopedLayoutWithDefinition: <Definition_2 extends VersionedLayoutDefinition>(businessProfileId: GuidValue, definition: new () => Definition_2) => VersionedLayout[];
     };
     mutations: {
         addOrUpdateLayouts: import("./Store").StoreMutation<(...versionedLayouts: VersionedLayout[]) => void, (...args: VersionedLayout[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
@@ -27,6 +28,8 @@ export declare class VersionedLayoutStore extends Store {
         ensureLoadDefinition: import("./Store").StoreAction<unknown, (version: IVersionReference) => void, (result: void, version: IVersionReference) => void, (failureReason: any, version: IVersionReference) => void, (version: IVersionReference) => Promise<void>>;
         ensureLoadDefinitionWithParentLayout: import("./Store").StoreAction<unknown, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (result: Layout, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (failureReason: any, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => Promise<Layout>>;
         ensureLoadDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, useCache?: unknown) => void, (result: DisplayBreakpointVersionedAlternateLayoutMapping, versionedLayout: VersionedLayout, useCache?: unknown) => void, (failureReason: any, versionedLayout: VersionedLayout, useCache?: unknown) => void, (versionedLayout: VersionedLayout, useCache?: unknown) => Promise<DisplayBreakpointVersionedAlternateLayoutMapping>>;
+        ensureLoadByProfileAndTypeId: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (result: void, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (failureReason: any, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => Promise<void>>;
+        ensureLoadByTypeIds: import("./Store").StoreAction<unknown, (layoutTypeIds: GuidValue[]) => void, (result: void, layoutTypeIds: GuidValue[]) => void, (failureReason: any, layoutTypeIds: GuidValue[]) => void, (layoutTypeIds: GuidValue[]) => Promise<void>>;
         setDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (result: void, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (failureReason: any, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => Promise<void>>;
         createAppScoped: import("./Store").StoreAction<unknown, (appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
@@ -35,6 +38,13 @@ export declare class VersionedLayoutStore extends Store {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
         }>>;
+        createBusinessProfileScoped: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
+            versionedLayout: VersionedLayout;
+            checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
+        }, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
+            versionedLayout: VersionedLayout;
+            checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
+        }>>;
         createTenantScoped: import("./Store").StoreAction<unknown, (definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;

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

@@ -40,3 +40,6 @@ export * from "./PromotedTagStore";
 export * from "./DynamicGroupStore";
 export * from "./ConnectedTenantStore";
 export * from "./DefineStore";
+export * from "./AiSettingsStore";
+export * from "./LinkReferencesStore";
+export * from "./UserTypeIdentityStore";

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

@@ -56,6 +56,7 @@ export * from "./filepickerprovider/mycomputerprovider";
 export * from "./filterengine";
 export * from "./use";
 export * from "./tag";
+export * from "./datetimefilterquery";
 export * from "./TokenBasedRouter";
 export * from "./StyleFlow";
 export * from "./UxCoreTypings";
@@ -71,6 +72,9 @@ export * from "./AnchorLink";
 export * from "./LayoutFileContext";
 export * from "./AppRollupFilterEngineContext";
 export * from "./SidePanelContext";
+export * from "./ScrollHelper";
+export * from "./ListViewComponentBase";
+export * from "./identities/loc/localize";
 export { OmniaTheming } from "./OmniaTheming";
 export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } from "./directives";
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";

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

@@ -0,0 +1,6 @@
+import { VueComponentBase } from "./VueComponentBase";
+export declare class ListViewComponentBase extends VueComponentBase {
+    constructor();
+    created(): void;
+    mounted(): void;
+}

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

@@ -0,0 +1,28 @@
+export declare class StickyElementHelper {
+    constructor();
+    private blockElement;
+    private componentElm;
+    private stickyElmScrollableParent;
+    private scrollCallback;
+    private parentScrollOffset;
+    private lastScrollTop;
+    private paddingTop;
+    private isSticky;
+    private selector;
+    private elementWidth;
+    private bgColor;
+    private previousStyle;
+    private previousColumnStyle;
+    private static FILTER_CLASS;
+    private tableColumnWidth;
+    private applyStickyStyle;
+    private tableColumnStyle;
+    private stickyMenu;
+    private tableColumn;
+    registerStickyElement(componentElm: Element, selector: string): void;
+    checkSticky(elm: Element): void;
+    private getTopFilterHeight;
+    private getTableColumnWidth;
+    private getStickyElement;
+    getBackground(element: any): any;
+}