@omnia/fx 7.5.7-preview → 7.5.7

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

@@ -7,3 +7,5 @@ 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

@@ -43,4 +43,9 @@ 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/datasource/DataSourcePropertiesService.d.ts

@@ -1,7 +1,7 @@
 import { DataSourceProperty, DataSourcePropertyDisplayInformation, GuidValue, PropertyDataSourceId, PropertyDefinition, PropertyValue, PropertyValuePrimitiveConverter, UserIdentity } from "../../../models";
-import { IDataSourcePropertyCreator } from "./DataSourcePropertyProvider";
-import { DataSourcePropertyDefinitionHandler } from "./DataSourcePropertyDefinitionHandler";
 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

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

@@ -16,6 +16,12 @@ export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends
         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
      * */

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<{

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

@@ -4,7 +4,6 @@ type QueryActionDispatcher = (query: IdentityQuery) => Future<ItemQueryResult<IR
 type ResolveIdentitiesActionDispatcher = (identities: Identity[]) => Promise<{
     [uid: string]: IResolvedIdentity;
 }>;
-type SpecialIdentitiesActionDispatcher = () => Future<Array<IResolvedIdentity>>;
 export interface IIdentityPickerStore {
     getters: {
         getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
@@ -12,14 +11,11 @@ export interface IIdentityPickerStore {
     actions: {
         query: StoreAction<unknown, MapActionOnDispatching<QueryActionDispatcher>, MapActionOnDispatched<QueryActionDispatcher>, MapActionOnFailure<QueryActionDispatcher>, QueryActionDispatcher>;
         resolveIdentities: StoreAction<unknown, MapActionOnDispatching<ResolveIdentitiesActionDispatcher>, MapActionOnDispatched<ResolveIdentitiesActionDispatcher>, MapActionOnFailure<ResolveIdentitiesActionDispatcher>, ResolveIdentitiesActionDispatcher>;
-        ensureSpecialIdentities: StoreAction<unknown, MapActionOnDispatching<SpecialIdentitiesActionDispatcher>, MapActionOnDispatched<SpecialIdentitiesActionDispatcher>, MapActionOnFailure<SpecialIdentitiesActionDispatcher>, SpecialIdentitiesActionDispatcher>;
     };
 }
 export declare class IdentityStore extends Store implements IIdentityPickerStore {
     private identityService;
     private identitiesState;
-    private dynamicGroupsState;
-    private loadSpecialIdentitiesPromise;
     getters: {
         getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
         getResolvedIdentities: () => IResolvedIdentity[];
@@ -34,7 +30,6 @@ export declare class IdentityStore extends Store implements IIdentityPickerStore
             [uid: string]: IResolvedIdentity;
         }>>;
         query: StoreAction<unknown, (query: IdentityQuery) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>>;
-        ensureSpecialIdentities: StoreAction<unknown, () => void, (result: IResolvedIdentity[]) => void, (failureReason: any) => void, () => Future<IResolvedIdentity[]>>;
     };
     protected onActivated(): void;
 }

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/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

@@ -29,6 +29,7 @@ export declare class VersionedLayoutStore extends Store {
         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;

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

@@ -42,3 +42,4 @@ 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,7 +56,7 @@ export * from "./filepickerprovider/mycomputerprovider";
 export * from "./filterengine";
 export * from "./use";
 export * from "./tag";
-export * from "./statuscoderenderer";
+export * from "./datetimefilterquery";
 export * from "./TokenBasedRouter";
 export * from "./StyleFlow";
 export * from "./UxCoreTypings";
@@ -74,6 +74,7 @@ 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/UxModels.d.ts

@@ -215,6 +215,8 @@ export interface OmniaUxLocalization {
             UnexpectedError: string;
             InvalidSiteUrl: string;
             InvalidUrlExistingAppInstance: string;
+            SiteCollectionAdministratorsPermissionMissing: string;
+            UnableToSetSiteSelectedPermission: string;
         };
         RequestedBy: string;
         RequestedAt: string;
@@ -276,13 +278,14 @@ export interface OmniaUxLocalization {
                 };
             };
             AuthEmails: {
-                LoginMagicLink: {
+                LoginWithMagicLink: {
                     Subject: string;
                     Body: string;
                 };
-                OnBoardingLink: {
+                OnboardingLink: {
                     Subject: string;
                     Body: string;
+                    BodyWithApprovalComment: string;
                 };
                 ResetPassword: {
                     Subject: string;
@@ -292,9 +295,17 @@ export interface OmniaUxLocalization {
                     Subject: string;
                     Body: string;
                 };
+                InformDisabledAccountEmail: {
+                    Subject: string;
+                    Body: string;
+                };
+                InformEnabledAccountEmail: {
+                    Subject: string;
+                    Body: string;
+                };
             };
             IdentityCreationRequestEmails: {
-                NotifiedIdentities: {
+                NotifyIdentities: {
                     Subject: string;
                     Body: string;
                 };
@@ -419,6 +430,9 @@ export interface OmniaUxLocalization {
             FixedValue: string;
             CurrentPage: string;
             User: string;
+            TargetedUser: string;
+            CurrentUser: string;
+            SelectedUser: string;
         };
         BooleanFilterOption: {
             Yes: string;
@@ -432,6 +446,7 @@ export interface OmniaUxLocalization {
             FixedHeader: string;
             FixedFilterArea: string;
         };
+        UserProperty: string;
     };
     EnterpriseGlossary: {
         EnterpriseGlossaryPicker: string;
@@ -461,6 +476,11 @@ export interface OmniaUxLocalization {
             Language: string;
             MultilingualText: string;
             Tags: string;
+            UserType: string;
+            PublishingApp: string;
+            BusinessProfile: string;
+            PageCollection: string;
+            PageType: string;
         };
         Users: {
             Username: string;
@@ -498,7 +518,10 @@ export interface OmniaUxLocalization {
             };
             TermSet: {
                 TextOnly: string;
-                MultiValue: string;
+                MultiValueTitle: string;
+            };
+            Identity: {
+                MultiValueTitle: string;
             };
             InternalName: string;
             InternalNameInvalidMessage: string;
@@ -685,6 +708,11 @@ export interface OmniaUxLocalization {
             Title: string;
             ConsentInformation: string;
         };
+        AnonymousAccessSetup: {
+            Category: string;
+            Description: string;
+            Title: string;
+        };
     };
     AuditLog: {
         Title: string;
@@ -769,6 +797,7 @@ export interface OmniaUxLocalization {
                     NoDefault: string;
                     CurrentUser: string;
                     PickedUser: string;
+                    SelectedUser: string;
                 };
                 FilterRenderType: {
                     Label: string;
@@ -1289,7 +1318,12 @@ export interface OmniaUxLocalization {
             By: string;
         };
     };
-    SignIn: {
+    UserTypeLayout: {
+        Private: string;
+        Public: string;
+        UserPickerLabel: string;
+    };
+    AuthenticationBlock: {
         Title: string;
         Decsription: string;
     };
@@ -1330,7 +1364,7 @@ export interface OmniaUxLocalization {
             NullOmniaAuthSettings: string;
             OneOrMoreOmniaAuthUnavailable: string;
             AtLeastOneAuthProvider: string;
-            NullEmptyOnBoardingSettings: string;
+            NullEmptyOnboardingSettings: string;
             OmniaAuthSettingsHaveDifferentProvidersLength: string;
         };
     };

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

@@ -3,5 +3,6 @@ export declare class AppContextProvider {
     private omniaContext;
     private omniaContextProvider;
     private appService;
+    private internalAppContext;
     updateContextByAppInstanceId(id: GuidValue): Promise<void>;
 }

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

@@ -1,13 +1,6 @@
-import { DataSourceProperty, Guid, PropertyConfiguration, PropertyDefinition, PropertyDataSourceId, DataSourcePropertyDisplayInformation, GuidValue, PropertyDefinitionId, PropertyDisplaySettingsBase, PropertySetupBase } from "@omnia/fx-models";
+import { Guid, PropertyConfiguration, PropertyDefinition, DataSourcePropertyDisplayInformation, PropertyDefinitionId, PropertyDisplaySettingsBase, PropertySetupBase, AppDataSourceProperty } from "@omnia/fx-models";
 import { EnterprisePropertyStore, MultilingualStore } from "@omnia/fx/stores";
 import { LocalizationService, PropertyDataSourceBase, WritebackResult, EnterprisePropertiesProvider, PropertyBindingService } from "@omnia/fx/services";
-export declare class AppDataSourceProperty extends DataSourceProperty {
-    readonly enterprisePropertyDefinitionId?: GuidValue;
-    readonly builtInId?: GuidValue;
-    readonly builtInInternalName?: string;
-    constructor(dataSourceId: PropertyDataSourceId, enterprisePropertyDefinitionId?: GuidValue, builtInId?: GuidValue, builtInInternalName?: string);
-    isEqual: (property: AppDataSourceProperty) => boolean;
-}
 export declare class AppPropertiesProvider extends PropertyDataSourceBase<AppDataSourceProperty> {
     id: Guid;
     title: string;
@@ -18,6 +11,7 @@ export declare class AppPropertiesProvider extends PropertyDataSourceBase<AppDat
     localizationService: LocalizationService;
     propertyBindingService: PropertyBindingService;
     private static builtInProperties;
+    isEqual: (dataSourceProperty1: AppDataSourceProperty, dataSourceProperty2: AppDataSourceProperty) => boolean;
     getProperties(): Promise<Array<AppDataSourceProperty>>;
     getPropertyConfiguration(property: AppDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, PropertyDisplaySettingsBase, any, PropertySetupBase>>>;
     getPropertyDefinition(property: AppDataSourceProperty): Promise<PropertyDefinitionId>;

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/MainRenderer.d.ts

@@ -64,10 +64,7 @@ export declare class MainRenderer extends VueComponentBase<MainRendererProps> {
     private generateFilters;
     private getHasValueFilterItems;
     private checkIfFilterItemHasValue;
-    private getDatePropFilterValue;
     private getTaxonomyFilterTermIds;
-    private generateFromDateFilter;
-    generateToDateFilter(to: Date, filterOnDateTime?: boolean): string;
     private generateTaxonomyFilter;
     private executeGetData;
     private nextPage;

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

@@ -9,6 +9,7 @@ export declare class AuthenticationChecker extends Vue implements IWebComponentI
     sharePointContext: SharePointContext;
     private httpClient;
     loc: AuthenticationCheckerLocalization.locInterface;
+    authValidationApi: string;
     omniaUrl: string;
     foundOtherError: boolean;
     foundErrorStatus401: boolean;
@@ -17,5 +18,6 @@ export declare class AuthenticationChecker extends Vue implements IWebComponentI
     private body;
     mounted(): void;
     init(): void;
+    validateAuthStatus(enableCircuitBreaker?: () => void): void;
     render(): VueTsxSupport.JSX.Element;
 }

package/internal-do-not-import-from-here/ux/authsetup/AuthSetup.css.d.ts

@@ -2,7 +2,7 @@ import { Breakpoint } from "@omnia/fx-models";
 import { types } from "typestyle";
 export declare const AuthSetupStyles: {
     main: (breakPoint: Breakpoint) => types.NestedCSSProperties;
-    container: (breakPoint: Breakpoint) => types.NestedCSSProperties;
+    container: () => types.NestedCSSProperties;
     passwordContainer: types.NestedCSSProperties;
     securityText: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/authsetup/loc/localize.d.ts

@@ -31,7 +31,7 @@ export declare module AuthSetupLocalization {
         Welcome: string;
         WelcomeMessage: string;
         Next: string;
-        DoneMessage: string;
+        SuccessMessage: string;
         Error: string;
     }
 }

package/internal-do-not-import-from-here/ux/datetimefilterquery/DateTimeFilterQuery.css.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    minContentWidth: {
+        width: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,19 @@
+import { DatePeriodPropFilterValue } from "@omnia/fx/models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    filterValue: DatePeriodPropFilterValue;
+    onChange: (filterValue: DatePeriodPropFilterValue) => void;
+}, "filterValue">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        filterValue: DatePeriodPropFilterValue;
+        onChange: (filterValue: DatePeriodPropFilterValue) => void;
+    }, "filterValue">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    filterValue: DatePeriodPropFilterValue;
+    onChange: (filterValue: DatePeriodPropFilterValue) => void;
+}, "filterValue">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        filterValue: DatePeriodPropFilterValue;
+        onChange: (filterValue: DatePeriodPropFilterValue) => void;
+    }, "filterValue">;
+});
+export default _default;

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

@@ -0,0 +1 @@
+export * from "./shared";

package/internal-do-not-import-from-here/ux/datetimefilterquery/loc/localize.d.ts

@@ -0,0 +1,16 @@
+export declare module DateTimeFilterQueryLocalization {
+    const namespace = "Omnia.Ux.DateTimeFilterQuery";
+    interface locInterface {
+        DatePeriods: {
+            OneWeekFromToday: string;
+            TwoWeeksFromToday: string;
+            OneMonthFromToday: string;
+            EarlierThanToday: string;
+            LaterThanToday: string;
+            Custom: string;
+            Today: string;
+            From: string;
+            To: string;
+        };
+    }
+}

package/internal-do-not-import-from-here/ux/datetimefilterquery/shared/DateTimeFilterQueryHelper.d.ts

@@ -0,0 +1,7 @@
+import { DatePeriodPropFilterValue, DatePropFilterValue, DatePropertyFilterCustomValue } from "@omnia/fx/models";
+export declare class DateTimeFilterQueryHelper {
+    static getDateFilterValue(filterValue: DatePeriodPropFilterValue): DatePropFilterValue;
+    private static generateFromDateFilter;
+    private static generateToDateFilter;
+    static parseDateFilterCustomToDateValue(value: DatePropertyFilterCustomValue): Date;
+}

package/internal-do-not-import-from-here/ux/datetimefilterquery/shared/index.d.ts

@@ -0,0 +1 @@
+export * from "./DateTimeFilterQueryHelper";

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

@@ -26,6 +26,7 @@ export declare class DateTimePicker extends VueComponentBase implements IWebComp
     private omniaContext;
     locDateTimePicker: DateTimePickerLocalization.locInterface;
     private subscriptionHandler;
+    private timeFormatValues;
     private styles;
     private date;
     private time;
@@ -41,7 +42,7 @@ export declare class DateTimePicker extends VueComponentBase implements IWebComp
     onValueBindChanged(newValue: string): void;
     created(): void;
     mounted(): void;
-    getTimeFormatAsString(timeFormat: TimeFormats): "HH:mm" | "hh:mm A";
+    getTimeFormatAsString(timeFormat: TimeFormats): string;
     init(): void;
     getDisplayText(model: string): string;
     prepareData(): void;

package/internal-do-not-import-from-here/ux/enterpriseproperties/display/personfield/PersonFieldDisplay.d.ts

@@ -1,25 +1,25 @@
 import { IWebComponentInstance } from "../../../../../fx";
 import { IPersonFieldDisplay } from "./IPersonFieldDisplay";
-import { type EnterprisePropertiesPersonDisplaySettings, Identity, IResolvedIdentity } from "../../../../models";
+import { type EnterprisePropertiesPersonDisplaySettings, Identity } from "../../../../models";
 import "./PersonFieldDisplay.css";
 import { type EnterprisePropertyDefinition } from "../../../../models";
 import { OmniaTheming, VueComponentBase } from "../../..";
+import { IdentitiesLocalization } from "../../../identities/loc/localize";
 export declare class PersonFieldDisplayComponent extends VueComponentBase implements IWebComponentInstance, IPersonFieldDisplay {
     settings: EnterprisePropertiesPersonDisplaySettings;
     valueBind: Identity[];
     property: EnterprisePropertyDefinition;
     wrapWithParentContent: (internalName: string, propertyContent: JSX.Element) => JSX.Element;
     omniaTheming: OmniaTheming;
-    private userIdentityStore;
+    private omniaContext;
     private identityStore;
+    private userIdentityStore;
     private multilingualTextsStore;
+    identityLoc: IdentitiesLocalization.locInterface;
     private personFieldDisplayClasses;
     private isLoading;
-    hasResolvedValue: boolean;
-    resolvedIdentities: {
-        [uid: string]: IResolvedIdentity;
-    };
-    uids: string[];
+    private identifiers;
+    private resolvedIdentities;
     onInputValueChanged(newValue: any, oldValue: any): void;
     created(): void;
     mounted(): void;

package/internal-do-not-import-from-here/ux/enterpriseproperties/picker/EnterprisePropertyPicker.d.ts

@@ -1,5 +1,5 @@
 import { IWebComponentInstance } from "../../..";
-import { EnterprisePropertyDefinition, ExternalPropertySelectionItem } from "../../../models";
+import { GuidValue, EnterprisePropertyDefinition, ExternalPropertySelectionItem } from "../../../models";
 import { IEnterprisePropertyPicker } from "./IEnterprisePropertyPicker";
 import { VueComponentBase, IValidator } from "../..";
 import "./EnterprisePropertyPickerStyles.css";
@@ -12,6 +12,7 @@ export declare class EnterprisePropertyPicker extends VueComponentBase implement
     label: string;
     disabled: boolean;
     multiple: boolean;
+    excludedPropertyTypeIds?: GuidValue[];
     onChange: (propertyInternalName: string | Array<string>) => void;
     filled: boolean;
     hideDetails: boolean;

package/internal-do-not-import-from-here/ux/enterpriseproperties/picker/IEnterprisePropertyPicker.d.ts

@@ -1,5 +1,5 @@
 import { TsxAllowUnknowProperties, IValidator } from "../..";
-import { EnterprisePropertyDefinition, ExternalPropertySelectionItem } from "../../../models";
+import { EnterprisePropertyDefinition, ExternalPropertySelectionItem, GuidValue } from "../../../models";
 export interface IEnterprisePropertyPickerProperties {
     label?: string;
     disabled?: boolean;
@@ -14,6 +14,7 @@ export interface IEnterprisePropertyPicker extends IEnterprisePropertyPickerProp
     externalPropertyItems?: Array<ExternalPropertySelectionItem>;
     onChange: (propertyInternalName: string | Array<string>) => void;
     requiredWithValidator?: IValidator;
+    excludedPropertyTypeIds?: GuidValue[];
 }
 declare global {
     namespace VueTsxSupport.JSX {