@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/mocks/auth-mocks/groupsActions.mocks.js

@@ -0,0 +1,234 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { GroupsStateKeys } from '../../auth';
+import { delay } from '../../helpers';
+import { buildGroupsActions } from '../../auth/GroupsState';
+import { allGroupsDummy } from '../dummy';
+import { GroupManagedByEnum } from '@frontegg/rest-api';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildGroupsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setGroupsState', 'resetUsersGroupsState', 'setUsersGroupsLoader', 'setUsersGroupsError']);
+  mockedActions.loadGroups = async () => {
+    const key = GroupsStateKeys.GET_GROUPS;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    const groups = allGroupsDummy;
+    mockedActions.setGroupsState({
+      groups
+    });
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.createGroup = async payload => {
+    var _payload$callback;
+    const key = GroupsStateKeys.CREATE_GROUP;
+    const {
+      groups
+    } = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: [_extends({}, payload, {
+        id: `${payload.name}ID`,
+        managedBy: GroupManagedByEnum.FRONTEGG
+      }), ...(groups != null ? groups : [])]
+    });
+    payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.updateGroup = async payload => {
+    var _state$groups, _payload$name2, _payload$color, _payload$description, _payload$callback2;
+    const key = GroupsStateKeys.UPDATE_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups = state.groups) == null ? void 0 : _state$groups.map(group => {
+        var _payload$name;
+        return group.id === payload.groupId ? _extends({}, payload, {
+          id: payload.groupId,
+          name: (_payload$name = payload == null ? void 0 : payload.name) != null ? _payload$name : '',
+          managedBy: GroupManagedByEnum.FRONTEGG
+        }) : group;
+      }),
+      selectedGroup: _extends({}, state == null ? void 0 : state.selectedGroup, {
+        name: (_payload$name2 = payload == null ? void 0 : payload.name) != null ? _payload$name2 : '',
+        color: (_payload$color = payload == null ? void 0 : payload.color) != null ? _payload$color : '',
+        description: (_payload$description = payload == null ? void 0 : payload.description) != null ? _payload$description : ''
+      })
+    });
+    payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.deleteGroup = async payload => {
+    var _state$groups2, _payload$callback3;
+    const key = GroupsStateKeys.DELETE_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups2 = state.groups) == null ? void 0 : _state$groups2.filter(group => group.id !== payload.groupId)
+    });
+    payload == null ? void 0 : (_payload$callback3 = payload.callback) == null ? void 0 : _payload$callback3.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.addRolesToGroup = async payload => {
+    var _state$groups3, _payload$callback4;
+    const key = GroupsStateKeys.ADD_ROLES_TO_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups3 = state.groups) == null ? void 0 : _state$groups3.map(group => {
+        var _group$roles;
+        return group.id === payload.groupId ? _extends({}, group, {
+          roles: [...((_group$roles = group == null ? void 0 : group.roles) != null ? _group$roles : []), ...payload.roleIds.map(role => ({
+            id: role,
+            name: role
+          }))]
+        }) : group;
+      })
+    });
+    payload == null ? void 0 : (_payload$callback4 = payload.callback) == null ? void 0 : _payload$callback4.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.deleteRolesFromGroup = async payload => {
+    var _state$groups4, _payload$callback5;
+    const key = GroupsStateKeys.DELETE_ROLES_FROM_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups4 = state.groups) == null ? void 0 : _state$groups4.map(group => {
+        var _group$roles2;
+        return group.id === payload.groupId ? _extends({}, group, {
+          roles: group == null ? void 0 : (_group$roles2 = group.roles) == null ? void 0 : _group$roles2.filter(role => !payload.roleIds.includes(role.id))
+        }) : group;
+      })
+    });
+    payload == null ? void 0 : (_payload$callback5 = payload.callback) == null ? void 0 : _payload$callback5.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.addUsersToGroup = async payload => {
+    var _state$groups5, _payload$callback6;
+    const key = GroupsStateKeys.ADD_USERS_TO_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups5 = state.groups) == null ? void 0 : _state$groups5.map(group => {
+        var _group$users;
+        return group.id === payload.groupId ? _extends({}, group, {
+          users: [...((_group$users = group == null ? void 0 : group.users) != null ? _group$users : []), ...payload.userIds.map(user => ({
+            id: user,
+            name: user
+          }))]
+        }) : group;
+      })
+    });
+    payload == null ? void 0 : (_payload$callback6 = payload.callback) == null ? void 0 : _payload$callback6.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.deleteUsersFromGroup = async payload => {
+    var _state$groups6, _payload$callback7;
+    const key = GroupsStateKeys.DELETE_USERS_FROM_GROUP;
+    const state = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    await delay(500);
+    mockedActions.setGroupsState({
+      groups: state == null ? void 0 : (_state$groups6 = state.groups) == null ? void 0 : _state$groups6.map(group => {
+        var _group$users2;
+        return group.id === payload.groupId ? _extends({}, group, {
+          users: group == null ? void 0 : (_group$users2 = group.users) == null ? void 0 : _group$users2.filter(user => !payload.userIds.includes(user.id))
+        }) : group;
+      })
+    });
+    payload == null ? void 0 : (_payload$callback7 = payload.callback) == null ? void 0 : _payload$callback7.call(payload, true);
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.getGroupConfiguration = async () => {
+    const key = GroupsStateKeys.GET_GROUP_CONFIGURATION;
+    const {
+      groupsConfiguration
+    } = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    if (groupsConfiguration) {
+      mockedActions.setGroupsState({
+        groupsConfiguration: _extends({}, groupsConfiguration)
+      });
+    }
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.updateGroupConfiguration = async payload => {
+    const key = GroupsStateKeys.UPDATE_GROUP_CONFIGURATION;
+    const {
+      groupsConfiguration
+    } = store.auth.groupsState;
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: true
+    });
+    if (groupsConfiguration) {
+      mockedActions.setGroupsState({
+        groupsConfiguration: _extends({}, groupsConfiguration, payload)
+      });
+    }
+    mockedActions.setUsersGroupsLoader({
+      key,
+      value: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/impersonateActions.mocks.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setImpersonateState: (state: Partial<import("../..").ImpersonateState>) => void;
+    resetImpersonateState: () => void;
+    impersonate: (_payload: import("../../interfaces").WithCallback<import("../..").IImpersonatePayload, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/impersonateActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildImpersonateActions } from '../../auth/ImpersonateState';
+export default ((store, api, actions) => {
+  const originalActions = buildImpersonateActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setImpersonateState', 'resetImpersonateState']);
+});

package/mocks/auth-mocks/index.d.ts

@@ -0,0 +1,6 @@
+import { AuthActions, AuthStateActions } from '../../auth';
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+export declare const buildAuthActions: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    authActions: AuthActions;
+    authStateActions: AuthStateActions;
+};

package/mocks/auth-mocks/index.js

@@ -0,0 +1,130 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import buildAcceptInvitationActions from './acceptInvitationActions.mocks';
+import buildAccountSettingsActions from './accountSettingsActions.mocks';
+import buildActivateAccountActions from './activateAccountActions.mocks';
+import buildAllAccountsActions from './allAccountsActions.mocks';
+/* contains reducers only no need to mock */
+import { buildAllAccountsDialogActions } from '../../auth/MSP';
+import buildApiTokensActions from './apiTokensActions.mocks';
+import buildApplicationsActions from './applicationsActions.mocks';
+import buildCustomLoginActions from './customLoginActions.mocks';
+import buildEntitlementsActions from './entitlementsActions.mocks';
+import buildForgotPasswordActions from './forgotPasswordActions.mocks';
+import buildGroupsActions from './groupsActions.mocks';
+/* contains reducers only no need to mock */
+import { buildGroupsDialogsActions } from '../../auth/GroupsDialogsState';
+import buildImpersonateActions from './impersonateActions.mocks';
+import buildLoginActions from './loginActions.mocks';
+import buildMfaActions from './mfaActions.mocks';
+import buildPasskeysActions from './passkeysActions.mocks';
+import buildProfileActions from './profileActions.mocks';
+import buildProvisioningActions from './provisioningActions.mocks';
+import buildResetPhoneNumberActions from './resetPhoneNumberActions.mocks';
+import buildRolesActions from './rolesActions.mocks';
+import buildRestrictionsActions from './security/restrictionsActions.mocks';
+import buildSecurityCenterActions from './security/securityCenterActions.mocks';
+import buildSecurityPolicyActions from './security/securityPolicyActions.mocks';
+import buildSessionsPolicyActions from './security/sessionsPolicyActions.mocks';
+import buildSessionsActions from './sessionsActions.mocks';
+import buildSignUpActions from './signUpActions.mocks';
+import buildSmsActions from './smsActions.mocks';
+import buildSocialLoginActions from './socialLoginActions.mocks';
+import buildSsoActions from './ssoActions.mocks';
+import buildStepUpActions from './stepUpActions.mocks';
+import buildTeamActions from './teamActions.mocks';
+import buildTenantsActions from './tenantsActions.mocks';
+import { isProxy } from '../../helpers';
+export const buildAuthActions = (store, api, actions) => {
+  const acceptInvitationActions = buildAcceptInvitationActions(store, api, actions);
+  const accountSettingsActions = buildAccountSettingsActions(store, api, actions);
+  const activateAccountActions = buildActivateAccountActions(store, api, actions);
+  const allAccountsActions = buildAllAccountsActions(store, api, actions);
+  const allAccountsDialogActions = buildAllAccountsDialogActions(store, api, actions);
+  const apiTokensActions = buildApiTokensActions(store, api, actions);
+  const applicationsActions = buildApplicationsActions(store, api, actions);
+  const customLoginActions = buildCustomLoginActions(store, api, actions);
+  const entitlementsActions = buildEntitlementsActions(store, api, actions);
+  const forgotPasswordActions = buildForgotPasswordActions(store, api, actions);
+  const groupsActions = buildGroupsActions(store, api, actions);
+  const groupsDialogsActions = buildGroupsDialogsActions(store, api, actions);
+  const impersonateActions = buildImpersonateActions(store, api, actions);
+  const loginActions = buildLoginActions(store, api, actions);
+  const mfaActions = buildMfaActions(store, api, actions);
+  const passkeysActions = buildPasskeysActions(store, api, actions);
+  const profileActions = buildProfileActions(store, api, actions);
+  const provisioningActions = buildProvisioningActions(store, api, actions);
+  const resetPhoneNumberActions = buildResetPhoneNumberActions(store, api, actions);
+  const restrictionsActions = buildRestrictionsActions(store, api, actions);
+  const rolesActions = buildRolesActions(store, api, actions);
+  const securityCenterActions = buildSecurityCenterActions(store, api, actions);
+  const securityPolicyActions = buildSecurityPolicyActions(store, api, actions);
+  const sessionsActions = buildSessionsActions(store, api, actions);
+  const sessionsPolicyActions = buildSessionsPolicyActions(store, api, actions);
+  const signUpActions = buildSignUpActions(store, api, actions);
+  const smsActions = buildSmsActions(store, api, actions);
+  const socialLoginActions = buildSocialLoginActions(store, api, actions);
+  const ssoActions = buildSsoActions(store, api, actions);
+  const stepUpActions = buildStepUpActions(store, api, actions);
+  const teamActions = buildTeamActions(store, api, actions);
+  const tenantsActions = buildTenantsActions(store, api, actions);
+  const authStateActions = {
+    acceptInvitationActions,
+    accountSettingsActions,
+    activateAccountActions,
+    allAccountsActions,
+    allAccountsDialogActions,
+    apiTokensActions,
+    applicationsActions,
+    customLoginActions,
+    entitlementsActions,
+    forgotPasswordActions,
+    groupsActions,
+    groupsDialogsActions,
+    impersonateActions,
+    loginActions,
+    mfaActions,
+    passkeysActions,
+    profileActions,
+    provisioningActions,
+    resetPhoneNumberActions,
+    restrictionsActions,
+    rolesActions,
+    securityCenterActions,
+    securityPolicyActions,
+    sessionsActions,
+    sessionsPolicyActions,
+    signUpActions,
+    smsActions,
+    socialLoginActions,
+    ssoActions,
+    stepUpActions,
+    teamActions,
+    tenantsActions
+  };
+  const setAuthState = state => {
+    Object.keys(state).forEach(key => {
+      if (isProxy(store.auth[key])) {
+        Object.assign(store.auth[key], state[key]);
+      } else {
+        store.auth[key] = state[key];
+      }
+    });
+  };
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  const resetAuthState = () => {};
+  const setUser = user => {
+    setAuthState({
+      user
+    });
+  };
+  const authActions = _extends({
+    setState: setAuthState,
+    setAuthState,
+    resetAuthState,
+    setUser
+  }, acceptInvitationActions, accountSettingsActions, activateAccountActions, allAccountsActions, allAccountsDialogActions, apiTokensActions, applicationsActions, customLoginActions, entitlementsActions, forgotPasswordActions, groupsActions, groupsDialogsActions, impersonateActions, loginActions, mfaActions, passkeysActions, profileActions, provisioningActions, resetPhoneNumberActions, restrictionsActions, rolesActions, securityCenterActions, securityPolicyActions, sessionsActions, sessionsPolicyActions, signUpActions, smsActions, socialLoginActions, ssoActions, stepUpActions, teamActions, tenantsActions);
+  return {
+    authActions,
+    authStateActions
+  };
+};

package/mocks/auth-mocks/loginActions.mocks.d.ts

@@ -0,0 +1,77 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    preVerifyMFAWebAuthn: ({ callback, deviceId, ...payload }: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, import("../..").IPreVerifyMFAWebAuthNForLoginResponse>, setLoadingAction: import("../..").SetLoadingAction) => Promise<void>;
+    verifyMFAWebAuthn: ({ callback, deviceId, ...payload }: import("../..").IVerifyMFAWebAuthnPayload, setLoadingAction: import("../..").SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    preVerifyMFAWebAuthnForLogin: (payload: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, import("../..").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForLogin: (payload: import("../..").IVerifyMFAWebAuthnPayload) => Promise<void>;
+    preVerifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, boolean>, setLoadingAction: import("../..").SetLoadingAction) => Promise<void>;
+    verifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>, boolean>, setLoadingAction: import("../..").SetLoadingAction, isStepUp?: boolean) => Promise<void>;
+    preVerifyMFASMSForLogin: (payload: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, boolean>) => Promise<void>;
+    verifyMFASMSForLogin: (payload: WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>, boolean>) => Promise<void>;
+    preVerifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA, boolean>, setLoadingAction?: import("../..").SetLoadingAction | undefined) => Promise<void>;
+    verifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode, boolean>, setLoadingAction?: import("../..").SetLoadingAction | undefined) => Promise<void>;
+    preVerifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA, boolean>) => Promise<void>;
+    verifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode, boolean>) => Promise<void>;
+    mfaWithAuthenticator: ({ callback, ...loginWithMfaPayload }: WithCallback<import("@frontegg/rest-api").ILoginWithMfa, boolean>, setLoadingAction: import("../..").SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    loginWithMfa: (payload: WithCallback<import("@frontegg/rest-api").ILoginWithMfa, boolean>) => Promise<void>;
+    getMfaRequiredState: (user: any) => Promise<Partial<import("../..").AuthState> & {
+        mfaState: Partial<import("../..").MFAState>;
+        loginState: Partial<import("../..").LoginState>;
+    }>;
+    postHandleVerifyMFAResponseForStepUp: () => Promise<void>;
+    postHandleVerifyMFAResponseForLogin: (isAuthenticated: boolean) => Promise<void>;
+    handleVerifyMFAResponse: (payload: import("@frontegg/rest-api").ILoginResponseV3, isStepUp?: boolean) => Promise<void>;
+    getFeatureFlags: (flags: string[]) => Promise<boolean[]>;
+    afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: import("../..").AfterAuthNavigationUtilOptions) => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<import("../..").AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning"> | undefined) => Promise<void>;
+    afterStepUpAuthNavigation: () => Promise<void>;
+    __afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: import("@frontegg/rest-api").ILoginResponseV3, additionalUpdate?: Partial<import("../..").AuthState>) => void;
+    requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+    requestHostedLoginAuthorizeV2: (payload?: {
+        additionalParams?: Record<string, string> | undefined;
+        shouldRedirectToLogin?: boolean | undefined;
+        firstTime?: boolean | undefined;
+        loginDirectAction?: import("../..").LoginDirectAction | undefined;
+    } | undefined) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+    __requestHostedLoginSilentAuthorize: () => Promise<void>;
+    handleHostedLoginCallback: (payload: import("../..").HostedLoginCallback) => Promise<void>;
+    setLoginState: (state: Partial<import("../..").LoginState>) => void;
+    resetLoginState: () => void;
+    requestAuthorize: (firstTime?: boolean | undefined) => Promise<void>;
+    requestAuthorizeSSR: (payload: import("../..").FronteggNextJSSession) => Promise<void>;
+    preLogin: (payload: WithCallback<import("@frontegg/rest-api").IPreLogin & {
+        recaptchaToken?: string | undefined;
+        invitationToken?: string | undefined;
+    }, void>) => Promise<void>;
+    postLogin: (payload: import("@frontegg/rest-api").IPostLogin) => Promise<void>;
+    login: (payload: WithCallback<import("@frontegg/rest-api").ILogin, boolean>) => Promise<void>;
+    logout: (payload?: (() => void) | undefined) => Promise<void>;
+    silentLogout: (payload?: WithCallback<{
+        callbackTimeout?: number | undefined;
+    }, boolean> | undefined) => Promise<void>;
+    recoverMfa: (payload: import("../..").IRecoverMFATokenPayload) => Promise<void>;
+    quickSmsPasswordlessPreLogin: (_payload: WithCallback<import("../..").IQuickSmsPasswordlessPreLoginPayload, boolean>) => Promise<void>;
+    changePhoneNumberWithVerification: (_payload: WithCallback<import("@frontegg/rest-api").IChangePhoneNumberWithVerification, boolean>) => Promise<void>;
+    verifyChangePhoneNumber: (_payload: WithCallback<import("@frontegg/rest-api").IVerifyChangePhoneNumber, boolean>) => Promise<void>;
+    passwordlessPreLogin: (_payload: WithCallback<import("@frontegg/rest-api").IPasswordlessPreLogin, void>) => Promise<void>;
+    passwordlessPostLogin: (_payload: WithCallback<import("../..").IPasswordlessPostLoginPayload, boolean>) => Promise<void>;
+    verifyInviteToken: (payload: import("@frontegg/rest-api").IVerifyInviteToken) => Promise<void>;
+    webAuthnPrelogin: (payload: WithCallback<import("@frontegg/rest-api").IWebAuthnPreLogin, import("@frontegg/rest-api").IWebAuthnPreLoginResponse | null>) => Promise<void>;
+    webAuthnPostLogin: (payload: import("../..").IWebAuthnPostLoginPayload) => Promise<void>;
+    webAuthnCreateNewDeviceSession: (payload: {
+        callback?: import("../../interfaces").CallbackMethod<import("@frontegg/rest-api").ICreateNewDeviceSessionResponse | null> | undefined;
+    }) => Promise<void>;
+    webAuthnVerifyNewDeviceSession: (payload: import("../..").IVerifyNewWebAuthnDevicePayload) => Promise<void>;
+    getUserIP: (payload: WithCallback<object, boolean>) => Promise<void>;
+    preEnrollMFAWebAuthnForLogin: (_payload: WithCallback<import("@frontegg/rest-api").IPreEnrollMFA, import("../..").IPreEnrollMFAWebAuthNForLoginResponse>) => Promise<void>;
+    enrollMFAWebAuthnForLogin: (_payload: import("../..").IEnrollMFAWebAuthnPayload) => Promise<void>;
+    enrollMFAAuthenticatorAppForLogin: (_payload: WithCallback<import("@frontegg/rest-api").IEnrollMFAAuthenticatorApp, boolean>) => Promise<void>;
+    preEnrollMFASMSForLogin: (_payload: WithCallback<import("@frontegg/rest-api").IPreEnrollMFASMS, boolean>) => Promise<void>;
+    enrollMFASMSForLogin: (_payload: WithCallback<import("@frontegg/rest-api").IEnrollMFASMS, boolean>) => Promise<void>;
+    handleEnrollMFAResponse: (payload: import("@frontegg/rest-api").ILoginResponseV3) => Promise<void>;
+    resetBreachedPassword: (payload: import("@frontegg/rest-api").IForgotPassword) => Promise<void>;
+    refreshTokenForSocialLogins: () => Promise<void>;
+    __refreshToken: () => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/loginActions.mocks.js

@@ -0,0 +1,39 @@
+import { buildLoginActions } from '../../auth/LoginState';
+import { dummyIps, userDemo } from '../dummy';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const originalActions = buildLoginActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setLoginState', 'resetLoginState', 'afterAuthNavigation']);
+  mockedActions.requestAuthorize = async firstTime => {
+    if (firstTime) {
+      actions.setAuthState({
+        isLoading: true
+      });
+    }
+    const user = userDemo;
+    await actions.loadTenants();
+    actions.setAuthState({
+      user,
+      isAuthenticated: true,
+      isLoading: false
+    });
+  };
+  mockedActions.getUserIP = async payload => {
+    const {
+      callback
+    } = payload;
+    try {
+      const {
+        ip
+      } = dummyIps[0];
+      await actions.setAuthState({
+        userIp: ip
+      });
+      callback == null ? void 0 : callback(true, ip);
+    } catch (e) {
+      callback == null ? void 0 : callback(false, e);
+    }
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/mfaActions.mocks.d.ts

@@ -0,0 +1,29 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { MFAState, WithDeviceId } from '../../auth';
+import type { IDisableMfa, ILoginWithMfa, IVerifyMfa } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setMfaState: (state: Partial<MFAState>) => void;
+    resetMfaState: () => void;
+    getMFADevices: () => Promise<void>;
+    getMFAStrategies: () => Promise<void>;
+    enrollMfa: () => Promise<void>;
+    verifyMfa: (_payload: WithCallback<IVerifyMfa, string | undefined>) => Promise<void>;
+    verifyMfaAfterForce: (_payload: WithCallback<ILoginWithMfa, string | undefined>) => Promise<void>;
+    disableMfa: (payload: WithCallback<IDisableMfa, boolean>) => Promise<void>;
+    preDisableMfaSms: (_payload: WithCallback<{
+        deviceId: string;
+    }, boolean>) => Promise<void>;
+    disableMfaSms: (_payload: WithCallback<WithDeviceId<import("@frontegg/rest-api").IDisableMFASMS>, boolean>) => Promise<void>;
+    preEnrollMfaSms: (payload: WithCallback<Pick<import("@frontegg/rest-api").IPreEnrollMFASMS, "phoneNumber">, boolean>) => Promise<void>;
+    enrollMfaSms: (_payload: WithCallback<Pick<import("@frontegg/rest-api").IEnrollMFASMS, "otcToken" | "code">, string | undefined>) => Promise<void>;
+    preEnrollMfaWebAuthn: (payload: {
+        callback?: import("../../interfaces").CallbackMethod<import("../../auth").IPreEnrollMFAWebAuthNForLoginResponse> | undefined;
+    }) => Promise<void>;
+    enrollMfaWebAuthn: (_payload: import("../../auth").IUserEnrollMFAWebAuthnPayload) => Promise<void>;
+    preDisableMfaWebAuthn: (_payload: WithCallback<{
+        deviceId: string;
+    }, import("../../auth").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    disableMfaWebAuthn: (_payload: import("../../auth").IDisableMFAWebAuthnPayload) => Promise<void>;
+    __getMfaStateAfterEnroll: (res: import("@frontegg/rest-api").IVerifyMfaResponse) => Promise<MFAState>;
+};
+export default _default;