@omnia/fx 8.0.213-dev → 8.0.215-dev

package/internal-do-not-import-from-here/ux/admin/usermanagement/shared/UserManagementConstants.d.ts

@@ -0,0 +1,133 @@
+import { guid } from "@omnia/fx-models";
+export declare const UserManagementBladeIds: {
+    home: guid;
+    users: {
+        default: guid;
+        detail: guid;
+        authentication: guid;
+        bulkImport: guid;
+    };
+    groups: {
+        listing: guid;
+        detail: guid;
+        groupUserDetail: guid;
+    };
+    dynamicgroups: {
+        listing: guid;
+        detail: guid;
+    };
+    usertypes: {
+        listing: guid;
+        layoutbuilder: guid;
+        detail: guid;
+    };
+    userproperties: {
+        listing: guid;
+        detail: guid;
+    };
+    synchronization: {
+        listing: guid;
+        settings: guid;
+        logs: guid;
+        omniaSearchUserLogs: string;
+    };
+    authentication: {
+        settings: guid;
+    };
+    LoginLog: {
+        listing: guid;
+    };
+};
+export declare const BusinessProfileUserManagementBladeIds: {
+    home: guid;
+    users: {
+        listing: guid;
+        detail: guid;
+        authentication: guid;
+        bulkImport: guid;
+    };
+    groups: {
+        listing: guid;
+        detail: guid;
+        groupUserDetail: guid;
+    };
+    authentication: guid;
+    loginscreen: guid;
+    selfService: {
+        default: guid;
+        detail: guid;
+        edit: guid;
+    };
+};
+export declare const UserManagementDestinations: {
+    home: guid[];
+    users: {
+        listing: guid[];
+        detail: guid[];
+        authentication: guid[];
+        bulkImport: guid[];
+    };
+    groups: {
+        listing: guid[];
+        detail: guid[];
+        groupUserDetail: guid[];
+    };
+    dynamicgroups: {
+        listing: guid[];
+        detail: guid[];
+    };
+    usertypes: {
+        listing: guid[];
+        layoutbuilder: guid[];
+        detail: guid[];
+    };
+    userproperties: {
+        listing: guid[];
+        detail: guid[];
+    };
+    synchronization: {
+        listing: guid[];
+        settings: guid[];
+        logs: guid[];
+        omniaSearchUserLogs: string[];
+    };
+    authentication: {
+        settings: guid[];
+    };
+    loginlog: {
+        listing: guid[];
+    };
+};
+export declare const BusinessProfileUserManagementDestinations: {
+    home: guid[];
+    users: {
+        listing: guid[];
+        detail: guid[];
+        authentication: guid[];
+        bulkImport: guid[];
+    };
+    groups: {
+        listing: guid[];
+        detail: guid[];
+        groupUserDetail: guid[];
+    };
+    authentication: guid[];
+    loginscreen: guid[];
+    identityCreationRequest: {
+        settings: guid[];
+        userTypeRequestDetail: guid[];
+        userTypeRequestPropertyEdit: guid[];
+    };
+};
+export declare const UserManagementConstants: {
+    TenantUserManagementNodeKey: string;
+    BusinessProfileUserManagementNodeKey: string;
+    UserDataSynchronizationProvider: {
+        UserAndGroupMembership: string;
+        UserDetails: string;
+    };
+    SynchronizationProvider: {
+        MicrosoftGraph: string;
+        SharepointUserProfiles: string;
+    };
+};

package/internal-do-not-import-from-here/ux/admin/usermanagement/shared/UserManagementHelper.d.ts

@@ -0,0 +1,310 @@
+import { EmailPropertyDefinition, EnterprisePropertyViewModel, guid, IdentityProperty, ImagePropertyDefinition, LanguagePropertyDefinition, PropertyBinding, TextPropertyDefinition } from "@omnia/fx-models";
+import { UserProfileInfoType, UserProfileProperty, UserProfileSection, UserType } from "./UserManagementTempModel";
+export type PropertyViewModel = {
+    identityProperty: IdentityProperty;
+    title: string;
+    allowToDelete: boolean;
+    allowToEdit: boolean;
+    isDeleting?: boolean;
+    errorMessage?: string;
+    isDeleted?: boolean;
+};
+export type UserTypePropertyFormSettingsViewModel = {
+    title: string;
+    identityProperty: IdentityProperty;
+    errorMessage?: string;
+};
+export declare enum UserDetailMode {
+    CreationRequest = 0,
+    User = 1
+}
+export interface IUserPropertiesBladeProps {
+}
+export declare class UserManagementHelper {
+    static SmoothingUserProfileProperties(userProfileProperties: Array<UserProfileSection>): Array<UserProfileSection & UserProfileProperty>;
+    static ChewUserProfileProperties(userProfileProperties: Array<UserProfileSection & UserProfileProperty>): Array<UserProfileSection>;
+    static GetType(item: any): UserProfileInfoType;
+    static transformUserPropertyModel(title: string, internalName?: string, builtIn?: boolean, id?: guid): EnterprisePropertyViewModel;
+    static transformUserTypeModel(title: string, builtIn?: boolean): UserType;
+    static mockUserProperyData(): Array<EnterprisePropertyViewModel>;
+    static mockUserTypeData(): Array<UserType>;
+    static builtInPropertyBindings: {
+        user: {
+            displayName: PropertyBinding<TextPropertyDefinition>;
+            username: PropertyBinding<TextPropertyDefinition>;
+            image: PropertyBinding<ImagePropertyDefinition>;
+            email: PropertyBinding<EmailPropertyDefinition>;
+            preferredLanguage: PropertyBinding<LanguagePropertyDefinition>;
+            uiLanguage: PropertyBinding<LanguagePropertyDefinition>;
+        };
+    };
+    static getBuiltinProperties(identityProperties: Array<IdentityProperty>): PropertyViewModel[];
+    static useUserPropertyStore(props: IUserPropertiesBladeProps): {
+        state: {
+            items: {
+                isDeleting: boolean;
+                definitionTitle: string;
+                id: guid;
+                internalName: string;
+                title: {
+                    isMultilingualString: true;
+                    "ar-sa"?: string;
+                    "bg-bg"?: string;
+                    "ca-es"?: string;
+                    "zh-tw"?: string;
+                    "cs-cz"?: string;
+                    "da-dk"?: string;
+                    "de-de"?: string;
+                    "el-gr"?: string;
+                    "en-us"?: string;
+                    "fi-fi"?: string;
+                    "fr-fr"?: string;
+                    "he-il"?: string;
+                    "hu-hu"?: string;
+                    "is-is"?: string;
+                    "it-it"?: string;
+                    "ja-jp"?: string;
+                    "ko-kr"?: string;
+                    "nl-nl"?: string;
+                    "nb-no"?: string;
+                    "pl-pl"?: string;
+                    "pt-br"?: string;
+                    "ro-ro"?: string;
+                    "ru-ru"?: string;
+                    "hr-hr"?: string;
+                    "sk-sk"?: string;
+                    "sq-al"?: string;
+                    "sv-se"?: string;
+                    "th-th"?: string;
+                    "tr-tr"?: string;
+                    "ur-pk"?: string;
+                    "id-id"?: string;
+                    "uk-ua"?: string;
+                    "be-by"?: string;
+                    "sl-si"?: string;
+                    "et-ee"?: string;
+                    "lv-lv"?: string;
+                    "lt-lt"?: string;
+                    "fa-ir"?: string;
+                    "vi-vn"?: string;
+                    "hy-am"?: string;
+                    "eu-es"?: string;
+                    "mk-mk"?: string;
+                    "af-za"?: string;
+                    "ka-ge"?: string;
+                    "fo-fo"?: string;
+                    "hi-in"?: string;
+                    "ms-my"?: string;
+                    "kk-kz"?: string;
+                    "ky-kg"?: string;
+                    "sw-ke"?: string;
+                    "tt-ru"?: string;
+                    "pa-in"?: string;
+                    "gu-in"?: string;
+                    "ta-in"?: string;
+                    "te-in"?: string;
+                    "kn-in"?: string;
+                    "mr-in"?: string;
+                    "sa-in"?: string;
+                    "mn-mn"?: string;
+                    "gl-es"?: string;
+                    "dv-mv"?: string;
+                    "ar-iq"?: string;
+                    "zh-cn"?: string;
+                    "de-ch"?: string;
+                    "en-gb"?: string;
+                    "es-mx"?: string;
+                    "fr-be"?: string;
+                    "it-ch"?: string;
+                    "nl-be"?: string;
+                    "nn-no"?: string;
+                    "pt-pt"?: string;
+                    "sv-fi"?: string;
+                    "ms-bn"?: string;
+                    "ar-eg"?: string;
+                    "zh-hk"?: string;
+                    "de-at"?: string;
+                    "en-au"?: string;
+                    "en-es"?: string;
+                    "fr-ca"?: string;
+                    "ar-ly"?: string;
+                    "zh-sg"?: string;
+                    "de-lu"?: string;
+                    "en-ca"?: string;
+                    "es-gt"?: string;
+                    "fr-ch"?: string;
+                    "ar-dz"?: string;
+                    "zh-mo"?: string;
+                    "de-li"?: string;
+                    "en-nz"?: string;
+                    "es-cr"?: string;
+                    "fr-lu"?: string;
+                    "ar-ma"?: string;
+                    "en-ie"?: string;
+                    "es-pa"?: string;
+                    "fr-mc"?: string;
+                    "ar-tn"?: string;
+                    "en-za"?: string;
+                    "es-do"?: string;
+                    "ar-om"?: string;
+                    "en-jm"?: string;
+                    "es-ve"?: string;
+                    "ar-ye"?: string;
+                    "es-co"?: string;
+                    "ar-sy"?: string;
+                    "en-bz"?: string;
+                    "es-pe"?: string;
+                    "ar-jo"?: string;
+                    "en-tt"?: string;
+                    "es-ar"?: string;
+                    "ar-lb"?: string;
+                    "en-zw"?: string;
+                    "es-ec"?: string;
+                    "ar-kw"?: string;
+                    "en-ph"?: string;
+                    "es-cl"?: string;
+                    "ar-ae"?: string;
+                    "es-uy"?: string;
+                    "ar-bh"?: string;
+                    "es-py"?: string;
+                    "ar-qa"?: string;
+                    "es-bo"?: string;
+                    "es-sv"?: string;
+                    "es-hn"?: string;
+                    "es-pr"?: string;
+                    "zu-za"?: string;
+                    "xh-za"?: string;
+                    "fy-nl"?: string;
+                    "tn-za"?: string;
+                    "se-se"?: string;
+                    "se-fi"?: string;
+                    "cy-gb"?: string;
+                    "hr-ba"?: string;
+                    "mi-nz"?: string;
+                    "ga-ie"?: string;
+                    "rm-ch"?: string;
+                    "lb-lu"?: string;
+                    "ns-za"?: string;
+                    "se-no"?: string;
+                    "mt-mt"?: string;
+                };
+                enterprisePropertyDataTypeId: guid;
+                settings: import("@omnia/fx-models").EnterprisePropertySettings;
+                spSearchable: boolean;
+                msSearchable?: boolean;
+                builtIn: boolean;
+                managedPropertySettings?: {
+                    managedProperty: string;
+                    retrievableManagedProperty?: string;
+                    refinableManagedProeprty?: string;
+                    queryableManagedProperty?: string;
+                    sortableManagedProperty?: string;
+                    retrievable: boolean;
+                    refinable: boolean;
+                    queryable: boolean;
+                    sortable: boolean;
+                };
+                msSearchPropertySettings?: {
+                    managedProperty: string;
+                    retrievableManagedProperty?: string;
+                    refinableManagedProeprty?: string;
+                    queryableManagedProperty?: string;
+                    sortableManagedProperty?: string;
+                    retrievable: boolean;
+                    refinable: boolean;
+                    queryable: boolean;
+                    sortable: boolean;
+                };
+                enterprisePropertyDataType: {
+                    id: guid;
+                    title: string;
+                    uiOptions: {
+                        settingsElementName?: string;
+                        editModeElementName: string;
+                        displayModeElementName?: string;
+                        valueDefinitionElementName?: string;
+                    };
+                    valuePropertyPaths: string[];
+                    indexedType: import("@omnia/fx-models").PropertyIndexedType;
+                    omniaSearchable: boolean;
+                    spSearchable: boolean;
+                    msSearchable?: boolean;
+                };
+                enterprisePropertyCategoryId?: guid;
+                multilingualTitle: string;
+                uniqueMultilingualTitle: string;
+                deletedAt?: {
+                    toString: () => string;
+                    toDateString: () => string;
+                    toTimeString: () => string;
+                    toLocaleString: {
+                        (): string;
+                        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+                        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+                    };
+                    toLocaleDateString: {
+                        (): string;
+                        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+                        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+                    };
+                    toLocaleTimeString: {
+                        (): string;
+                        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+                        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+                    };
+                    valueOf: () => number;
+                    getTime: () => number;
+                    getFullYear: () => number;
+                    getUTCFullYear: () => number;
+                    getMonth: () => number;
+                    getUTCMonth: () => number;
+                    getDate: () => number;
+                    getUTCDate: () => number;
+                    getDay: () => number;
+                    getUTCDay: () => number;
+                    getHours: () => number;
+                    getUTCHours: () => number;
+                    getMinutes: () => number;
+                    getUTCMinutes: () => number;
+                    getSeconds: () => number;
+                    getUTCSeconds: () => number;
+                    getMilliseconds: () => number;
+                    getUTCMilliseconds: () => number;
+                    getTimezoneOffset: () => number;
+                    setTime: (time: number) => number;
+                    setMilliseconds: (ms: number) => number;
+                    setUTCMilliseconds: (ms: number) => number;
+                    setSeconds: (sec: number, ms?: number) => number;
+                    setUTCSeconds: (sec: number, ms?: number) => number;
+                    setMinutes: (min: number, sec?: number, ms?: number) => number;
+                    setUTCMinutes: (min: number, sec?: number, ms?: number) => number;
+                    setHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+                    setUTCHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+                    setDate: (date: number) => number;
+                    setUTCDate: (date: number) => number;
+                    setMonth: (month: number, date?: number) => number;
+                    setUTCMonth: (month: number, date?: number) => number;
+                    setFullYear: (year: number, month?: number, date?: number) => number;
+                    setUTCFullYear: (year: number, month?: number, date?: number) => number;
+                    toUTCString: () => string;
+                    toISOString: () => string;
+                    toJSON: (key?: any) => string;
+                    [Symbol.toPrimitive]: {
+                        (hint: "default"): string;
+                        (hint: "string"): string;
+                        (hint: "number"): number;
+                        (hint: string): string | number;
+                    };
+                };
+            }[];
+            isLoading: {
+                items: boolean;
+            };
+            isDeleting: {
+                [enterprisePropertyId: string]: boolean;
+            };
+        };
+        getProperty: () => void;
+        removeProperty: (item: EnterprisePropertyViewModel) => void;
+    };
+}

package/internal-do-not-import-from-here/ux/admin/usermanagement/shared/UserManagementStyles.css.d.ts

@@ -0,0 +1,15 @@
+import { types } from "typestyle";
+import { ITheming } from "@omnia/fx/ux";
+export declare const UserManagementStyles: {
+    alignOrderList?: types.NestedCSSProperties;
+    avatar?: types.NestedCSSProperties;
+    tableRowNotSelected?: types.NestedCSSProperties;
+    descriptionWrap?: types.NestedCSSProperties;
+    table?: types.NestedCSSProperties;
+    headerDialogStyles: (theming: ITheming) => types.NestedCSSProperties;
+};
+export declare const UserListingStyles: {
+    usernameCol: (isTenant: boolean) => string;
+    userTypeCol: (isTenant: boolean) => string;
+    whiteSpaceNoWrap: string;
+};

package/internal-do-not-import-from-here/ux/admin/usermanagement/shared/UserManagementTempModel.d.ts

@@ -0,0 +1,56 @@
+import { guid, IIcon, IdentityCreationRequestSettings, MultilingualString, PropertyBinding, PropertyDefinition, UserRequestFormSetting, EnterprisePropertyViewModel } from "@omnia/fx-models";
+export declare enum UserProfileInfoType {
+    Section = 0,
+    Property = 1
+}
+export interface UserDataSynchronizationProvider {
+    id: guid;
+    title: string;
+    providers: Array<SynchronizationProvider>;
+}
+export interface SynchronizationProvider {
+    id: guid;
+    title: string;
+    lastRun: string;
+    timeToComplete: string;
+    status: string;
+    userIdentityMappings: Array<UserIdentityMapping>;
+}
+export interface UserIdentityMapping {
+    userProperty: EnterprisePropertyViewModel;
+    syncProperty: string;
+}
+export interface UserType {
+    id: guid;
+    title: MultilingualString;
+    multilingualTitle: string;
+    builtIn: boolean;
+    showInAddUserForm: boolean;
+    applyToSyncedUsers: boolean;
+    userProfileProperties: Array<UserProfileSection>;
+    syncUserProperties: Array<SyncUserProperty>;
+}
+export interface UserProfileSection {
+    id?: guid;
+    title?: MultilingualString;
+    properties?: Array<UserProfileProperty>;
+}
+export interface UserProfileProperty {
+    property?: EnterprisePropertyViewModel;
+    icon?: IIcon;
+    allowUserToEdit?: boolean;
+}
+export interface SyncUserProperty {
+    userProperty: EnterprisePropertyViewModel;
+    syncProperty: {
+        title: string;
+    };
+}
+export type ExtendedPropertiesRegistrationViewModel = {
+    title: string;
+    property: PropertyBinding<PropertyDefinition<any, any, any>>;
+};
+export type UserTypeState = {
+    userType: UserRequestFormSetting;
+    settings: IdentityCreationRequestSettings;
+};

package/internal-do-not-import-from-here/ux/admin/usermanagement/shared/UserQueryStore.d.ts

@@ -0,0 +1,151 @@
+import { ArchiveIdentityManagementQuery, ArchiveSortColumn, BoolFilter, LanguageTags, PropertyDefinition, PropertyValueBinding, ResolvedUserIdentity, ScopeTypes, UserAuthenticationInformation, UserIdentity, UserIdentityAddRequest, UserManagementQuery, UserSortColumn, guid } from "@omnia/fx-models";
+import { SortItem } from "@omnia/fx/ux";
+export declare const useUserQueryStore: () => {
+    state: {
+        searchText: string;
+        userTypeId: guid;
+        providerId: guid;
+        pageNr: number;
+        sortItem: SortItem[];
+        sortColumn: UserSortColumn | ArchiveSortColumn;
+        sortDesc: boolean;
+        disabled: BoolFilter;
+        timeValid: BoolFilter;
+        scope: string[];
+        scopeType: ScopeTypes;
+        itemsPerPage: number;
+    };
+    actions: {
+        onDispatching: {
+            queryUsers: {
+                subscribe(fn: (options?: {
+                    queryType: "active" | "deleted";
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            getUser: {
+                subscribe(fn: (userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addUser: {
+                subscribe(fn: (user: UserIdentityAddRequest, withAuthInfo?: {
+                    authInfo: UserAuthenticationInformation;
+                    sendAuthSetupAsEmail: boolean;
+                    comment: string;
+                    redirectUrl: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateUser: {
+                subscribe(fn: (user: UserIdentity, dataToUpdate: {
+                    userTypeId: guid;
+                    properties: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deleteUser: {
+                subscribe(fn: (userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            restoreUser: {
+                subscribe(fn: (userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            purgeUser: {
+                subscribe(fn: (userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            queryUsers: {
+                subscribe(fn: (result: void, options?: {
+                    queryType: "active" | "deleted";
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            getUser: {
+                subscribe(fn: (result: ResolvedUserIdentity, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addUser: {
+                subscribe(fn: (result: ResolvedUserIdentity | import("@omnia/fx-models").UserAddWithAuthInfoReponse, user: UserIdentityAddRequest, withAuthInfo?: {
+                    authInfo: UserAuthenticationInformation;
+                    sendAuthSetupAsEmail: boolean;
+                    comment: string;
+                    redirectUrl: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateUser: {
+                subscribe(fn: (result: void, user: UserIdentity, dataToUpdate: {
+                    userTypeId: guid;
+                    properties: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deleteUser: {
+                subscribe(fn: (result: void, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            restoreUser: {
+                subscribe(fn: (result: void, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            purgeUser: {
+                subscribe(fn: (result: void, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            queryUsers: {
+                subscribe(fn: (failureReason: any, options?: {
+                    queryType: "active" | "deleted";
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            getUser: {
+                subscribe(fn: (failureReason: any, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addUser: {
+                subscribe(fn: (failureReason: any, user: UserIdentityAddRequest, withAuthInfo?: {
+                    authInfo: UserAuthenticationInformation;
+                    sendAuthSetupAsEmail: boolean;
+                    comment: string;
+                    redirectUrl: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            updateUser: {
+                subscribe(fn: (failureReason: any, user: UserIdentity, dataToUpdate: {
+                    userTypeId: guid;
+                    properties: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            deleteUser: {
+                subscribe(fn: (failureReason: any, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            restoreUser: {
+                subscribe(fn: (failureReason: any, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            purgeUser: {
+                subscribe(fn: (failureReason: any, userIdentity: UserIdentity) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        queryUsers: (options?: {
+            queryType: "active" | "deleted";
+        }) => Promise<void>;
+        getUser: (userIdentity: UserIdentity) => Promise<ResolvedUserIdentity>;
+        addUser: (user: UserIdentityAddRequest, withAuthInfo?: {
+            authInfo: UserAuthenticationInformation;
+            sendAuthSetupAsEmail: boolean;
+            comment: string;
+            redirectUrl: string;
+        }) => Promise<ResolvedUserIdentity | import("@omnia/fx-models").UserAddWithAuthInfoReponse>;
+        updateUser: (user: UserIdentity, dataToUpdate: {
+            userTypeId: guid;
+            properties: Array<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
+        }) => Promise<void>;
+        deleteUser: (userIdentity: UserIdentity) => Promise<void>;
+        restoreUser: (userIdentity: UserIdentity) => Promise<void>;
+        purgeUser: (userIdentity: UserIdentity) => Promise<void>;
+    };
+    get: {
+        readonly query: UserManagementQuery;
+        readonly archiveQuery: ArchiveIdentityManagementQuery;
+        readonly queryResult: {
+            users: ResolvedUserIdentity[];
+            total: number;
+        };
+        readonly users: ResolvedUserIdentity[];
+        readonly total: number;
+        readonly loading: boolean;
+    };
+    mutate: {
+        uiLanguage: (value: LanguageTags | ((prev: LanguageTags) => LanguageTags)) => void;
+    };
+};

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

@@ -0,0 +1,9 @@
+export * from "./UserManagementConstants";
+export * from "./UserManagementHelper";
+export * from "./UserManagementTempModel";
+export * from "./UserManagementStyles.css";
+export * from "./UserDetailStore";
+export * from "./GroupDetailStore";
+export * from "./SelfServiceStore";
+export * from "./UserQueryStore";
+export * from "./GroupQueryStore";