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

package/auth/LoginState/actions/mfaRequiredState.actions.d.ts

@@ -0,0 +1,11 @@
+import { LoginState } from '../interfaces';
+import { MFAState } from '../../MfaState/interfaces';
+import { AuthState, User } from '../../interfaces';
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    getMfaRequiredState: (user: User | any) => Promise<Partial<AuthState> & {
+        mfaState: Partial<MFAState>;
+        loginState: Partial<LoginState>;
+    }>;
+};
+export default _default;

package/auth/LoginState/actions/mfaRequiredState.actions.js

@@ -0,0 +1,63 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { getMfaStepForEnrolledUsers, getMfaStepForNotEnrolledUsers } from '../helpers';
+import { LoginStep, LoginFlow } from '../interfaces';
+import { deepClone } from '../../../helpers';
+import { initialState as mfaInitialState } from '../../MfaState/state';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const getMfaRequiredState = async user => {
+    let step = LoginStep.loginWithTwoFactor;
+    const mfaState = deepClone(mfaInitialState);
+    const loginState = store.auth.loginState;
+    const {
+      isAllowedToRemember,
+      mfaDeviceExpiration
+    } = await api.auth.checkIfAllowToRememberMfaDevice(user.mfaToken);
+    const isEnrolled = !(user.hasOwnProperty('mfaEnrolled') && !user.mfaEnrolled);
+    if (isEnrolled) {
+      Object.assign(mfaState, {
+        mfaDevices: user.mfaDevices,
+        step: getMfaStepForEnrolledUsers(user.mfaDevices)
+      });
+    } else {
+      Object.assign(mfaState, {
+        step: getMfaStepForNotEnrolledUsers(user.mfaStrategies),
+        qrCode: user.qrCode,
+        recoveryCode: user.recoveryCode,
+        loading: false,
+        mfaToken: user.mfaToken,
+        mfaStrategies: user.mfaStrategies
+      });
+      step = LoginStep.forceTwoFactor;
+    }
+    let quickLoginState = {};
+    const quickLoginToRegister = localStorage.getItem('register-quick-login');
+    if (quickLoginToRegister) {
+      quickLoginState = {
+        quickLoginToRegister,
+        flow: LoginFlow.RegisterQuickLogin
+      };
+    }
+    return {
+      user: undefined,
+      isAuthenticated: false,
+      mfaState,
+      loginState: _extends({}, loginState, quickLoginState, {
+        mfaToken: user.mfaToken,
+        mfaRequired: user.mfaRequired,
+        loading: false,
+        error: undefined,
+        step,
+        tenantsLoading: true,
+        email: user.userEmail,
+        tenants: [],
+        allowRememberMfaDevice: isAllowedToRemember,
+        mfaDeviceExpiration,
+        isBreachedPassword: user.isBreachedPassword
+      })
+    };
+  };
+  return {
+    getMfaRequiredState
+  };
+});

package/auth/LoginState/actions/mfaWithAuthenticator.actions.d.ts

@@ -0,0 +1,8 @@
+import { ILoginWithMfa } from '@frontegg/rest-api';
+import { SetLoadingAction } from '../interfaces';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    mfaWithAuthenticator: ({ callback, ...loginWithMfaPayload }: WithCallback<ILoginWithMfa>, setLoadingAction: SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    loginWithMfa: (payload: WithCallback<ILoginWithMfa>) => Promise<void>;
+};
+export default _default;

package/auth/LoginState/actions/mfaWithAuthenticator.actions.js

@@ -0,0 +1,137 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["callback"];
+import { LoginFlow, LoginStep } from '../interfaces';
+import { errorHandler } from '../../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @param tenants
+   * @param isAuthenticated
+   * @param isStepUp
+   * @returns additional update object for the afterAuthenticationStateUpdate saga as part of MFA auth with authenticator app
+   * @private
+   */
+  async function __buildPostAuthStateUpdate(tenants, isAuthenticated, isStepUp) {
+    const loginState = store.auth.loginState;
+    let additionalUpdate = {};
+    if (!isStepUp) {
+      const step = loginState.flow === LoginFlow.Login ? LoginStep.success : loginState.step;
+      additionalUpdate = {
+        loginState: {
+          flow: loginState.flow,
+          quickLoginToRegister: loginState.quickLoginToRegister,
+          loading: false,
+          step,
+          error: undefined,
+          tenants
+        }
+      };
+    }
+    return _extends({}, additionalUpdate, {
+      isAuthenticated
+    });
+  }
+
+  /**
+   * Handle after MFA authentication with authenticator app for login
+   * @private
+   */
+  async function __postLoginMfaAuthenticator(isAuthenticated, callback) {
+    const loginState = store.auth.loginState;
+    if (loginState.flow !== LoginFlow.Login) return;
+    const [securityCenterLoginFlows] = await actions.getFeatureFlags(['security-center-show-login-flows']);
+    if (securityCenterLoginFlows && loginState.isBreachedPassword && !isAuthenticated) {
+      actions.setLoginState({
+        step: LoginStep.breachedPassword,
+        loading: false
+      });
+    } else {
+      const shouldShowPrompt = await actions.__shouldShowPromptPasskeys();
+      if (shouldShowPrompt) {
+        actions.setLoginState({
+          step: LoginStep.promptPasskeys,
+          loading: false
+        });
+      } else {
+        await actions.afterAuthNavigation();
+      }
+    }
+    callback == null ? void 0 : callback(true);
+  }
+
+  /**
+   * Handle after MFA authentication with authenticator app for step up
+   * @private
+   */
+  async function __postStepUpMfaAuthenticator(callback) {
+    await actions.afterStepUpAuthNavigation();
+    callback == null ? void 0 : callback(true);
+  }
+
+  /**
+   * Utility function to handle MFA authentication with authenticator app
+   * @param payload MFA with authenticator action payload
+   * @param setLoadingAction set loading action
+   * @param isStepUp true if this is a step-up authentication
+   * @returns
+   */
+  const mfaWithAuthenticator = async (_ref, setLoadingAction, isStepUp) => {
+    let {
+        callback
+      } = _ref,
+      loginWithMfaPayload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    setLoadingAction({
+      loading: true,
+      error: undefined
+    });
+    try {
+      const {
+        user,
+        tenants = [],
+        activeTenant
+      } = await api.auth.loginWithMfaV2(loginWithMfaPayload);
+      const isAuthenticated = !!user.accessToken;
+      const additionalUpdate = await __buildPostAuthStateUpdate(tenants, isAuthenticated, isStepUp);
+      await actions.__afterAuthenticationStateUpdate({
+        user,
+        tenants,
+        activeTenant
+      }, additionalUpdate);
+      if (user.id) {
+        localStorage.setItem('userId', user.id);
+      }
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      if (isStepUp) {
+        return await __postStepUpMfaAuthenticator(callback);
+      }
+      return await __postLoginMfaAuthenticator(isAuthenticated, callback);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    }
+  };
+
+  /**
+   * Login with MFA with authenticator app - external saga
+   * @param payload.mfaToken
+   * @param payload.mfaDevices
+   * @param payload.rememberDevice
+   * @param payload.invitationToken
+   * @param payload.callback - The callback function to be called after the request is done
+   */
+  const loginWithMfa = async payload => {
+    return await mfaWithAuthenticator(payload, actions.setLoginState, false);
+  };
+  return {
+    mfaWithAuthenticator,
+    loginWithMfa
+  };
+});

package/auth/LoginState/actions/mfaWithEmailCode.actions.d.ts

@@ -0,0 +1,10 @@
+import { IPreVerifyMFA, IVerifyMFAEmailCode } from '@frontegg/rest-api';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { SetLoadingAction } from '../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    preVerifyMFAEmailCode: ({ callback, ...payload }: WithCallback<IPreVerifyMFA>, setLoadingAction?: SetLoadingAction | undefined) => Promise<void>;
+    verifyMFAEmailCode: ({ callback, ...payload }: WithCallback<IVerifyMFAEmailCode>, setLoadingAction?: SetLoadingAction | undefined) => Promise<void>;
+    preVerifyMFAEmailCodeForLogin: (payload: WithCallback<IPreVerifyMFA>) => Promise<void>;
+    verifyMFAEmailCodeForLogin: (payload: WithCallback<IVerifyMFAEmailCode>) => Promise<void>;
+};
+export default _default;

package/auth/LoginState/actions/mfaWithEmailCode.actions.js

@@ -0,0 +1,101 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"];
+import { MFAStep } from '../../MfaState/interfaces';
+import { errorHandler } from '../../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  /**
+   * Shared logic for MFA Email code pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFAEmailCode = async (_ref, setLoadingAction) => {
+    var _setLoadingAction;
+    let {
+        callback
+      } = _ref,
+      payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    setLoadingAction = (_setLoadingAction = setLoadingAction) != null ? _setLoadingAction : actions.setLoginState;
+    setLoadingAction({
+      loading: true,
+      error: undefined
+    });
+    try {
+      const data = await api.auth.preVerifyMFAEmailCode(payload);
+      actions.setMfaState({
+        otcToken: data.otcToken,
+        step: MFAStep.emailVerifyCode
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA Email code verify step
+   * @param payload.otcToken
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFAEmailCode = async (_ref2, setLoadingAction) => {
+    var _setLoadingAction2;
+    let {
+        callback
+      } = _ref2,
+      payload = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+    setLoadingAction = (_setLoadingAction2 = setLoadingAction) != null ? _setLoadingAction2 : actions.setLoginState;
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const data = await api.auth.verifyMFAEmailCodeV2(payload);
+      await actions.handleVerifyMFAResponse(data);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA Email login
+   * @param payload.mfaToken
+   * @param payload.callback callback function to be called after the verification is done
+   */
+  const preVerifyMFAEmailCodeForLogin = async payload => {
+    return await preVerifyMFAEmailCode(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA Email login
+   * @param payload.otcToken
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFAEmailCodeForLogin = async payload => {
+    return await verifyMFAEmailCode(payload, actions.setLoginState);
+  };
+  return {
+    preVerifyMFAEmailCode,
+    verifyMFAEmailCode,
+    preVerifyMFAEmailCodeForLogin,
+    verifyMFAEmailCodeForLogin
+  };
+});

package/auth/LoginState/actions/mfaWithSMS.actions.d.ts

@@ -0,0 +1,10 @@
+import { IPreVerifyMFA, IVerifyMFASMS } from '@frontegg/rest-api';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { WithDeviceId, SetLoadingAction } from '../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    preVerifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<WithDeviceId<IPreVerifyMFA>>, setLoadingAction: SetLoadingAction) => Promise<void>;
+    verifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<WithDeviceId<IVerifyMFASMS>>, setLoadingAction: SetLoadingAction, isStepUp?: boolean) => Promise<void>;
+    preVerifyMFASMSForLogin: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>>) => Promise<void>;
+    verifyMFASMSForLogin: (payload: WithCallback<WithDeviceId<IVerifyMFASMS>>) => Promise<void>;
+};
+export default _default;

package/auth/LoginState/actions/mfaWithSMS.actions.js

@@ -0,0 +1,108 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback", "deviceId"],
+  _excluded2 = ["callback", "deviceId"];
+import { MFAStep } from '../../MfaState/interfaces';
+import { errorHandler } from '../../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Shared logic for MFA SMS pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFASMS = async (_ref, setLoadingAction) => {
+    let {
+        callback,
+        deviceId
+      } = _ref,
+      payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    setLoadingAction({
+      loading: false,
+      error: undefined
+    });
+    try {
+      const data = await api.auth.preVerifyMFASMSForLogin(deviceId, payload);
+      actions.setMfaState({
+        otcToken: data.otcToken,
+        step: MFAStep.smsVerifyCode,
+        phoneNumber: data.phoneNumber
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA SMS verify step
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.otcToken
+   * @param payload.code 6 digits code input by the user
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   * @param isStepUp true when it's step up flow
+   */
+  const verifyMFASMS = async (_ref2, setLoadingAction, isStepUp = false) => {
+    let {
+        callback,
+        deviceId
+      } = _ref2,
+      payload = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const data = await api.auth.verifyMFASMSForLoginV2(deviceId, payload);
+      await actions.handleVerifyMFAResponse(data, isStepUp);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA SMS login
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFASMSForLogin = async payload => {
+    return await preVerifyMFASMS(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA SMS login
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.otcToken
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFASMSForLogin = async payload => {
+    return await verifyMFASMS(payload, actions.setLoginState, false);
+  };
+  return {
+    preVerifyMFASMS,
+    verifyMFASMS,
+    preVerifyMFASMSForLogin,
+    verifyMFASMSForLogin
+  };
+});

package/auth/LoginState/actions/mfaWithWebAuthn.actions.d.ts

@@ -0,0 +1,10 @@
+import { IPreVerifyMFA } from '@frontegg/rest-api';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { WithDeviceId, IPreVerifyMFAWebAuthNForLoginResponse, SetLoadingAction, IVerifyMFAWebAuthnPayload } from '../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    preVerifyMFAWebAuthn: ({ callback, deviceId, ...payload }: WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>, setLoadingAction: SetLoadingAction) => Promise<void>;
+    verifyMFAWebAuthn: ({ callback, deviceId, ...payload }: IVerifyMFAWebAuthnPayload, setLoadingAction: SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    preVerifyMFAWebAuthnForLogin: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForLogin: (payload: IVerifyMFAWebAuthnPayload) => Promise<void>;
+};
+export default _default;

package/auth/LoginState/actions/mfaWithWebAuthn.actions.js

@@ -0,0 +1,119 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback", "deviceId"],
+  _excluded2 = ["callback", "deviceId"];
+import { base64urlDecode, errorHandler, publicKeyCredentialToJSON } from '../../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Shared logic for MFA Webauthn pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFAWebAuthn = async (_ref, setLoadingAction) => {
+    let {
+        callback,
+        deviceId
+      } = _ref,
+      payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      var _data$options$allowCr;
+      const data = await api.auth.preVerifyMFAWebAuthnForLogin(deviceId, payload);
+      const options = _extends({}, data.options, {
+        challenge: base64urlDecode(data.options.challenge),
+        allowCredentials: (_data$options$allowCr = data.options.allowCredentials) == null ? void 0 : _data$options$allowCr.map(credentials => _extends({}, credentials, {
+          id: base64urlDecode(credentials.id)
+        }))
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback({
+        options,
+        webauthnToken: data.webauthnToken
+      });
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA Webauthn verify step
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.webauthnToken
+   * @param payload.mfaToken
+   * @param payload.publicKey public key object from browser navigator credentials
+   * @param payload.code 6 digits code input by the user
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   * @param isStepUp true when it's step up flow
+   */
+  const verifyMFAWebAuthn = async (_ref2, setLoadingAction, isStepUp) => {
+    let {
+        callback,
+        deviceId
+      } = _ref2,
+      payload = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const publicKey = publicKeyCredentialToJSON(payload.publicKey);
+      const data = await api.auth.verifyMFAWebAuthnForLoginV2(deviceId, _extends({}, payload, {
+        options: publicKey
+      }));
+      await actions.handleVerifyMFAResponse(data, isStepUp);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA Webauthn login
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAWebAuthnForLogin = async payload => {
+    return await preVerifyMFAWebAuthn(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA Webauthn login
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.webauthnToken
+   * @param payload.mfaToken
+   * @param payload.publicKey public key object from browser navigator credentials
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFAWebAuthnForLogin = async payload => {
+    return await verifyMFAWebAuthn(payload, actions.setLoginState, false);
+  };
+  return {
+    preVerifyMFAWebAuthn,
+    verifyMFAWebAuthn,
+    preVerifyMFAWebAuthnForLogin,
+    verifyMFAWebAuthnForLogin
+  };
+});

package/auth/LoginState/consts.d.ts

@@ -1,26 +1,10 @@
 /**
-  @notice these file is used inside next js middleware
-  middleware file in next js runs inside edge runtime
-  using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
-  please don't import from redux or from other files that import from redux
-*/
+ * @notice these file is used inside Next.js middleware  file in Next.js runs inside edge runtime
+ * using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
+ * please don't import from redux or from other files that import from redux
+ */
 import { AuthStrategyEnum } from '@frontegg/rest-api';
 import { LoginStep } from './interfaces';
+import { AuthPageRoutes } from '../interfaces';
 export declare const authStrategyLoginStepMap: Record<Exclude<AuthStrategyEnum, AuthStrategyEnum.NoLocalAuthentication>, LoginStep>;
-export declare const defaultFronteggRoutes: {
-    authenticatedUrl: string;
-    loginUrl: string;
-    logoutUrl: string;
-    activateUrl: string;
-    impersonationUrl: string;
-    acceptInvitationUrl: string;
-    forgetPasswordUrl: string;
-    resetPhoneNumberUrl: string;
-    resetPasswordUrl: string;
-    socialLoginCallbackUrl: string;
-    signUpUrl: string;
-    oidcRedirectUrl: string;
-    samlCallbackUrl: string;
-    magicLinkCallbackUrl: string;
-    hostedLoginRedirectUrl: string;
-};
+export declare const defaultFronteggRoutes: AuthPageRoutes;

package/auth/LoginState/consts.js

@@ -1,9 +1,8 @@
 /**
-  @notice these file is used inside next js middleware 
-  middleware file in next js runs inside edge runtime
-  using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
-  please don't import from redux or from other files that import from redux 
-*/
+ * @notice these file is used inside Next.js middleware  file in Next.js runs inside edge runtime
+ * using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
+ * please don't import from redux or from other files that import from redux
+ */
 import { AuthStrategyEnum } from '@frontegg/rest-api';
 import { LoginStep } from './interfaces';
 export const authStrategyLoginStepMap = {
@@ -17,6 +16,7 @@ export const authStrategyLoginStepMap = {
 export const defaultFronteggRoutes = {
   authenticatedUrl: '/',
   loginUrl: '/account/login',
+  stepUpUrl: '/account/step-up',
   logoutUrl: '/account/logout',
   activateUrl: '/account/activate',
   impersonationUrl: '/account/impersonate',
@@ -29,5 +29,6 @@ export const defaultFronteggRoutes = {
   oidcRedirectUrl: '/account/oidc/callback',
   samlCallbackUrl: '/account/saml/callback',
   magicLinkCallbackUrl: '/account/login/magic-link',
-  hostedLoginRedirectUrl: '/oauth/callback'
+  hostedLoginRedirectUrl: '/oauth/callback',
+  openAppUrl: '/account/redirect'
 };