@frontegg/rest-api 3.1.74-alpha.9437937621 → 3.1.74

package/auth/index.js

@@ -3,947 +3,766 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 const _excluded = ["type"],
       _excluded2 = ["type"],
       _excluded3 = ["type"];
+import { getTenants } from "../tenants";
 export * from "./secutiry-poilicy";
 export * from "./enums";
 export { FRONTEGG_SEPARATE_TABS_BY_TENANT } from "./constants";
 export { setTabTenantInSessionStorage, getTabTenantFromSessionStorage, getCurrentUserTenantsFunction, removeTabTenantFromSessionStorage } from './utils';
 import { urls } from "../constants";
+import { ContextHolder } from "../ContextHolder";
+import { Delete, Get, Patch, Post, Put } from "../fetch";
 import { jwtDecode } from "../jwt";
 import { LOAD_AUTHORIZATION_FF } from './interfaces';
+import { loadEntitlementsV2 } from '../entitlements';
 import { ADMIN_PORTAL_ENTITLEMENTS_FF } from '../entitlements/interfaces';
 import { FeatureFlags } from "../feature-flags";
 import { executeConditionalPromise, getCurrentUserTenantsFunction, getTabTenantFromSessionStorage, setTabTenantInSessionStorage } from "./utils";
-import { TenantsApi } from "../tenants";
-import { BaseApiClient } from '../BaseApiClient';
-import { EntitlementsApi } from '../entitlements';
-import { ContextHolder } from '../ContextHolder';
-import { SecurityPolicyApi } from './secutiry-poilicy';
-export class AuthenticationApi extends BaseApiClient {
-  constructor(appName) {
-    super(appName);
-    this.tenantsApi = new TenantsApi(this.appName);
-    this.entitlementsApi = new EntitlementsApi(this.appName);
-    this.securityPolicy = new SecurityPolicyApi(this.appName);
-
-    this.generateLoginResponse = async loginResponse => {
-      if (!loginResponse.accessToken) {
-        return loginResponse;
-      }
-
-      const contextHolder = ContextHolder.for(this.appName);
-      contextHolder.setAccessToken(loginResponse.accessToken);
-      const me = await this.getMeAndEntitlements();
-      const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
-
-      const user = _extends({}, loginResponse, decodedContent, me);
-
-      contextHolder.setUser(user);
-      return user;
-    };
-
-    this.generateLoginResponseV2 = async loginResponse => {
-      if (!loginResponse.accessToken) {
-        return {
-          user: loginResponse
-        };
-      }
-
-      const contextHolder = ContextHolder.for(this.appName);
-      contextHolder.setAccessToken(loginResponse.accessToken);
-      const [me, tenants] = await Promise.all([this.getMeAndEntitlements(), this.tenantsApi.getTenants()]);
-      const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
-
-      const user = _extends({}, loginResponse, decodedContent, me);
-
-      contextHolder.setUser(user);
-      return {
-        user,
-        tenants
-      };
-    };
-
-    this.generateLoginResponseV3 = async loginResponse => {
-      const {
-        accessToken
-      } = loginResponse;
-
-      if (!accessToken) {
-        return {
-          user: loginResponse
-        };
-      }
-
-      const contextHolder = ContextHolder.for(this.appName);
-      contextHolder.setAccessToken(accessToken);
-      const [me, currentUserTenants] = await Promise.all([this.getMeAndEntitlements(), getCurrentUserTenantsFunction(this.appName)()]);
-      const decodedContent = accessToken ? jwtDecode(accessToken) : {};
-
-      const user = _extends({}, loginResponse, decodedContent, me);
-
-      if (contextHolder.isSessionPerTenantEnabled()) {
-        setTabTenantInSessionStorage(user.tenantId);
-      }
-
-      contextHolder.setUser(user);
-      return {
-        user,
-        tenants: currentUserTenants.tenants,
-        activeTenant: currentUserTenants.activeTenant
-      };
-    };
-
-    this.generateLoginResponseFromOAuthResponse = async oauthResponse => {
-      const contextHolder = ContextHolder.for(this.appName);
-      contextHolder.setAccessToken(oauthResponse.id_token);
-      const me = await this.getMeAndEntitlements();
-      const decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
-
-      const user = _extends({
-        mfaRequired: false,
-        accessToken: oauthResponse.id_token,
-        refreshToken: oauthResponse.refresh_token
-      }, decodedContent, me, {
-        expiresIn: oauthResponse.expires_in || 300
-      });
-
-      contextHolder.setUser(user);
-      return user;
-    };
-
-    this.generateLoginResponseFromOAuthResponseV2 = async oauthResponse => {
-      const contextHolder = ContextHolder.for(this.appName);
-      contextHolder.setAccessToken(oauthResponse.id_token);
-      const [me, currentUserTenants] = await Promise.all([this.getMeAndEntitlements(), getCurrentUserTenantsFunction(this.appName)()]);
-      const decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
-
-      const user = _extends({
-        mfaRequired: false,
-        accessToken: oauthResponse.id_token,
-        refreshToken: oauthResponse.refresh_token
-      }, decodedContent, me, {
-        expiresIn: oauthResponse.expires_in || 300
-      });
-
-      if (contextHolder.isSessionPerTenantEnabled()) {
-        setTabTenantInSessionStorage(user.tenantId);
-      }
-
-      contextHolder.setUser(user);
-      return {
-        user,
-        tenants: currentUserTenants.tenants,
-        activeTenant: currentUserTenants.activeTenant
-      };
-    };
-
-    this.preLogin = async body => {
-      try {
-        const {
-          address
-        } = await this.post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
-        return address;
-      } catch {
-        return null;
-      }
-    };
-
-    this.preLoginWithIdpType = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
-    };
-
-    this.postLogin = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/saml/postlogin`, body);
-      return this.generateLoginResponse(data);
-    };
-
-    this.oidcPostLogin = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/oidc/postlogin`, body);
-      return this.generateLoginResponse(data);
-    };
-
-    this.login = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user`, body);
-      return this.generateLoginResponse(data);
-    };
-
-    this.loginv2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.loginWithMfa = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
-      return this.generateLoginResponse(data);
-    };
-
-    this.loginWithMfaV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.activateAccount = async body => {
-      return this.post(`${urls.identity.users.v1}/activate`, body);
-    };
-
-    this.activateAccountV2 = async body => {
-      const data = await this.post(`${urls.identity.users.v1}/activate`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.getActivateAccountStrategy = async params => {
-      return this.get(`${urls.identity.users.v1}/activate/strategy`, params);
-    };
-
-    this.resendActivationEmail = async body => {
-      return this.post(`${urls.identity.users.v1}/activate/reset`, body);
-    };
-
-    this.resendInvitationEmail = async body => {
-      return this.post(`${urls.identity.users.v1}/invitation/reset`, body);
-    };
-
-    this.acceptInvitation = async body => {
-      return this.post(`${urls.identity.users.v1}/invitation/accept`, body);
-    };
-
-    this.refreshToken = async () => {
-      const tabTenantId = getTabTenantFromSessionStorage(this.appName);
-      const data = await this.post(`${urls.identity.auth.v1}/user/token/refresh`, {
-        tenantId: tabTenantId
-      });
-      return this.generateLoginResponse(data);
-    };
-
-    this.refreshTokenV2 = async () => {
-      const tabTenantId = getTabTenantFromSessionStorage(this.appName);
-      const data = await this.post(`${urls.identity.auth.v1}/user/token/refresh`, {
-        tenantId: tabTenantId
-      });
-      return this.generateLoginResponseV2(data);
-    };
-
-    this.refreshTokenV3 = async () => {
-      const tabTenantId = getTabTenantFromSessionStorage(this.appName);
-      const data = await this.post(`${urls.identity.auth.v1}/user/token/refresh`, {
-        tenantId: tabTenantId
-      });
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.logout = async () => {
-      return this.post(`${urls.identity.auth.v1}/logout`);
-    };
-
-    this.OAuthLogout = async params => {
-      return this.get(`${urls.oauth.v1}/logout`, params);
-    };
-
-    this.forgotPassword = async body => {
-      return this.post(`${urls.identity.users.v1}/passwords/reset`, body);
-    };
-
-    this.resetPassword = async body => {
-      return this.post(`${urls.identity.users.v1}/passwords/reset/verify`, body);
-    };
-
-    this.loadPasswordConfig = async params => {
-      return this.get(`${urls.identity.users.v1}/passwords/config`, params);
-    };
-
-    this.recoverMfaToken = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/recover`, body);
-    };
-
-    this.enrollMfa = async () => {
-      return this.post(`${urls.identity.users.v1}/mfa/enroll`);
-    };
-
-    this.preEnrollMFAAuthenticatorApp = async () => {
-      return this.post(`${urls.identity.users.v1}/mfa/authenticator/enroll`);
-    };
-
-    this.enrollMFAAuthenticatorApp = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/authenticator/enroll/verify`, body);
-    };
-
-    this.preEnrollMFASMS = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/sms/enroll`, body);
-    };
-
-    this.enrollMFASMS = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/sms/enroll/verify`, body);
-    };
-
-    this.preEnrollMFAWebAuthn = async () => {
-      return this.post(`${urls.identity.users.v1}/mfa/webauthn/enroll`);
-    };
-
-    this.enrollMFAWebAuthn = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/webauthn/enroll/verify`, body);
-    };
-
-    this.verifyMfa = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/enroll/verify`, body);
-    };
-
-    this.disableMfa = async body => {
-      return this.post(`${urls.identity.users.v1}/mfa/disable`, body);
-    };
-
-    this.disableMFAAuthenticatorApp = async (deviceId, body) => {
-      return this.post(`${urls.identity.users.v1}/mfa/authenticator/${deviceId}/disable/verify`, body);
-    };
-
-    this.preDisableMFASMS = async deviceId => {
-      return this.post(`${urls.identity.users.v1}/mfa/sms/${deviceId}/disable`);
-    };
-
-    this.disableMFASMS = async (deviceId, body) => {
-      return this.post(`${urls.identity.users.v1}/mfa/sms/${deviceId}/disable/verify`, body);
-    };
-
-    this.preDisableMFAWebAuthn = async deviceId => {
-      return this.post(`${urls.identity.users.v1}/mfa/webauthn/${deviceId}/disable`);
-    };
-
-    this.disableMFAWebAuthn = async (deviceId, body) => {
-      return this.post(`${urls.identity.users.v1}/mfa/webauthn/${deviceId}/disable/verify`, body);
-    };
-
-    this.getMFADevices = async () => {
-      return this.get(`${urls.identity.users.v1}/mfa/devices`);
-    };
-
-    this.preEnrollMFAAuthenticatorAppForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll`, body);
-    };
-
-    this.enrollMFAAuthenticatorAppForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll/verify`, body);
-    };
-
-    this.enrollMFAAuthenticatorAppForLoginV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.verifyMFAAuthenticatorAppForLogin = async (deviceId, body) => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/authenticator/${deviceId}/verify`, body);
-    };
-
-    this.preVerifyMFAEmailCode = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/emailcode`, body);
-    };
-
-    this.verifyMFAEmailCode = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/emailcode/verify`, body);
-    };
-
-    this.verifyMFAEmailCodeV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/emailcode/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.preEnrollMFASMSForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/sms/enroll`, body);
-    };
-
-    this.enrollMFASMSForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/sms/enroll/verify`, body);
-    };
-
-    this.enrollMFASMSForLoginV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/sms/enroll/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.preVerifyMFASMSForLogin = async (deviceId, body) => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}`, body);
-    };
-
-    this.verifyMFASMSForLogin = async (deviceId, body) => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}/verify`, body);
-    };
-
-    this.verifyMFASMSForLoginV2 = async (deviceId, body) => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.preEnrollMFAWebAuthnForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll`, body);
-    };
-
-    this.enrollMFAWebAuthnForLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll/verify`, body);
-    };
-
-    this.enrollMFAWebAuthnForLoginV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.preVerifyMFAWebAuthnForLogin = async (deviceId, body) => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}`, body);
-    };
-
-    this.verifyMFAWebAuthnForLogin = async (deviceId, body) => {
-      return this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}/verify`, body);
-    };
-
-    this.verifyMFAWebAuthnForLoginV2 = async (deviceId, body) => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}/verify`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.getSamlConfiguration = async () => {
-      return this.get(`${urls.team.sso.v1}/saml/configurations`);
-    };
-
-    this.updateSamlConfiguration = async body => {
-      return this.post(`${urls.team.sso.v1}/saml/configurations`, body);
-    };
-
-    this.getSamlVendorConfiguration = async () => {
-      return this.get(`${urls.team.sso.v1}/saml/configurations/vendor-config`);
-    };
-
-    this.updateSamlVendorMetadata = async body => {
-      return this.put(`${urls.team.sso.v1}/saml/configurations/metadata`, body);
-    };
-
-    this.validateSamlDomain = async () => {
-      return this.put(`${urls.team.sso.v1}/saml/validations/domain`);
-    };
-
-    this.getSamlRoles = async () => {
-      return this.get(`${urls.team.sso.v1}/saml/configurations/roles/default`);
-    };
-
-    this.getSamlRolesGroups = async () => {
-      return this.get(`${urls.team.sso.v2}/saml/configurations/groups`);
-    };
-
-    this.updateSamlRoles = async ({
-      roleIds
-    }) => {
-      return this.post(`${urls.team.sso.v1}/saml/configurations/roles/default`, {
-        roleIds
-      });
-    };
-
-    this.createSamlGroup = async ({
-      roleIds,
-      group
-    }) => {
-      return this.post(`${urls.team.sso.v2}/saml/configurations/groups`, {
-        group,
-        roleIds
-      });
-    };
-
-    this.updateSamlGroup = async ({
-      roleIds,
-      group,
-      id
-    }) => {
-      return this.patch(`${urls.team.sso.v2}/saml/configurations/groups/${id}`, {
-        group,
-        roleIds
-      });
-    };
-
-    this.deleteSamlGroup = async ({
-      id
-    }) => {
-      return this.delete(`${urls.team.sso.v2}/saml/configurations/groups/${id}`);
-    };
-
-    this.getOidcConfiguration = async () => {
-      return this.get(`${urls.team.sso.v1}/oidc/configurations`);
-    };
-
-    this.getSSOPublicConfiguration = async () => {
-      return this.get(`${urls.team.sso.v2}/configurations/public`);
-    };
-
-    this.getSocialLoginProviders = async () => {
-      return this.get(urls.identity.sso.v1);
-    };
-
-    this.getSocialLoginProvidersV2 = async () => {
-      return this.get(urls.identity.sso.v2);
-    };
-
-    this.getSocialLoginProvidersV2ForAuthenticatedUser = async () => {
-      return this.get(`${urls.identity.sso.v2}/authenticated`);
-    };
-
-    this.getCustomSocialLoginProvidersV1 = async () => {
-      return this.get(urls.identity.sso.custom.v1);
-    };
-
-    this.loginViaSocialLogin = async params => {
-      const queryParams = {};
-
-      if (params.code) {
-        queryParams.code = params.code;
-      }
-
-      if (params.idToken) {
-        queryParams.id_token = params.idToken;
-      }
-
-      if (params.redirectUri) {
-        queryParams.redirectUri = params.redirectUri;
-      }
-
-      if (params.codeVerifier) {
-        queryParams.code_verifier = params.codeVerifier;
-      }
-
-      if (params.state) {
-        queryParams.state = params.state;
-      }
-
-      return this.post(`${urls.identity.auth.v1}/user/sso/${params.provider}/postlogin`, {
-        metadata: params.metadata,
-        invitationToken: params.invitationToken
-      }, {
-        params: queryParams
-      });
-    };
-
-    this.getVendorConfig = async () => {
-      return this.get(`${urls.identity.configurations.v1}/public`);
-    };
-
-    this.signUpUser = async body => {
-      const {
-        shouldActivate,
-        authResponse,
-        userId,
-        tenantId
-      } = await this.post(`${urls.identity.users.v1}/signUp`, body);
-      const response = {
-        shouldActivate,
-        userId,
-        tenantId
-      };
-
-      if (!shouldActivate && authResponse) {
-        const {
-          user,
-          tenants,
-          activeTenant
-        } = await this.generateLoginResponseV3(authResponse);
-        return _extends({}, response, {
-          user,
-          tenants,
-          activeTenant
-        });
-      }
-
-      return response;
-    };
-
-    this.getCurrentUserSessions = async () => {
-      return this.get(urls.identity.users.sessions.currentUser.v1);
-    };
-
-    this.getCurrentUserSession = async () => {
-      return this.get(`${urls.identity.users.sessions.currentUser.v1}/current`);
-    };
-
-    this.revokeSessionsForUser = async userId => {
-      return this.post(`${urls.identity.users.sessions.v1}/revoke`, {
-        userId
-      });
-    };
-
-    this.getSessionConfigurations = async () => {
-      return this.get(urls.identity.users.sessions.configurations.v1);
-    };
-
-    this.createOrUpdateSessionConfigrations = async body => {
-      await this.post(urls.identity.users.sessions.configurations.v1, body);
-    };
-
-    this.deleteSessionForUser = async id => {
-      await this.delete(`${urls.identity.users.sessions.currentUser.v1}/${id}`);
-    };
-
-    this.deleteAllSessionsForUser = async () => {
-      await this.delete(`${urls.identity.users.sessions.currentUser.v1}/all`);
-    };
-
-    this.getUserAccessTokensData = async () => {
-      return this.get(urls.identity.users.accessTokens.v1);
-    };
-
-    this.getTenantAccessTokensData = async () => {
-      return this.get(urls.identity.tenants.accessTokens.v1);
-    };
-
-    this.deleteTenantAccessToken = async ({
-      id
-    }) => {
-      await this.delete(`${urls.identity.tenants.accessTokens.v1}/${id}`);
-    };
-
-    this.deleteUserAccessToken = async ({
-      id
-    }) => {
-      await this.delete(`${urls.identity.users.accessTokens.v1}/${id}`);
-    };
-
-    this.createUserAccessToken = async body => {
-      return this.post(urls.identity.users.accessTokens.v1, body);
-    };
-
-    this.createTenantAccessToken = async body => {
-      return this.post(urls.identity.tenants.accessTokens.v1, body);
-    };
-
-    this.getUserApiTokensData = async () => {
-      return this.get(urls.identity.users.apiTokens.v1);
-    };
-
-    this.getTenantApiTokensData = async () => {
-      return this.get(urls.identity.tenants.apiTokens.v1);
-    };
-
-    this.updateUserApiTokensData = async body => {
-      return this.post(urls.identity.users.apiTokens.v1, body);
-    };
-
-    this.updateTenantApiTokensData = async body => {
-      return this.post(urls.identity.tenants.apiTokens.v2, body);
-    };
-
-    this.deleteTenantApiToken = async ({
-      tokenId
-    }) => {
-      await this.delete(`${urls.identity.tenants.apiTokens.v1}/${tokenId}`);
-    };
-
-    this.deleteUserApiToken = async ({
-      tokenId
-    }) => {
-      await this.delete(`${urls.identity.users.apiTokens.v1}/${tokenId}`);
-    };
-
-    this.getUserById = async ({
-      userId
-    }) => {
-      return this.get(`${urls.identity.users.v1}/${userId}`);
-    };
-
-    this.checkIfAllowToRememberMfaDevice = async mfaToken => {
-      return this.get(`${urls.identity.configurations.v1}/mfa-policy/allow-remember-device`, {
-        mfaToken
-      });
-    };
-
-    this.passwordlessPreLogin = async _ref => {
-      let {
-        type
-      } = _ref,
-          body = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-      return this.post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/prelogin`, body);
-    };
-
-    this.passwordlessPostLoginV2 = async _ref2 => {
-      let {
-        type
-      } = _ref2,
-          body = _objectWithoutPropertiesLoose(_ref2, _excluded2);
-
-      const data = await this.post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
-      return this.generateLoginResponseV3(data);
-    };
-
-    this.passwordlessPostLogin = async _ref3 => {
-      let {
-        type
-      } = _ref3,
-          body = _objectWithoutPropertiesLoose(_ref3, _excluded3);
-
-      return this.post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
-    };
-
-    this.verifyInviteToken = async ({
-      token
-    }) => {
-      return this.post(urls.identity.tenants.invites.verify.v1, {
-        token
-      });
-    };
-
-    this.getSSOConfigurations = async () => {
-      return this.get(`${urls.team.sso.v1}/configurations`);
-    };
-
-    this.createSSOConfiguration = async body => {
-      return this.post(`${urls.team.sso.v1}/configurations`, body);
-    };
-
-    this.updateSSOConfiguration = async (ssoConfigId, body) => {
-      return this.patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}`, body);
-    };
-
-    this.deleteSSOConfiguration = async ssoConfigId => {
-      await this.delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}`);
-    };
-
-    this.createSSOConfigurationByMetadata = async body => {
-      return this.post(`${urls.team.sso.v1}/configurations/metadata`, body);
-    };
-
-    this.updateSSOConfigurationByMetadata = async (ssoConfigId, body) => {
-      return this.put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata`, body);
-    };
-
-    this.createSSOConfigurationByMetadataUrl = async body => {
-      return this.post(`${urls.team.sso.v1}/configurations/metadata-url`, body);
-    };
-
-    this.updateSSOConfigurationByMetadataUrl = async (ssoConfigId, body) => {
-      return this.put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata-url`, body);
-    };
-
-    this.createSSODomain = async (ssoConfigId, body) => {
-      return this.post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains`, body);
-    };
-
-    this.deleteSSODomain = async (ssoConfigId, domainId) => {
-      return this.delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}`);
-    };
-
-    this.validateSSODomain = async (ssoConfigId, domainId) => {
-      return this.put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
-    };
-
-    this.validateSSODomainV2 = async (ssoConfigId, domainId) => {
-      return this.put(`${urls.team.sso.v2}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
-    };
-
-    this.getSSODefaultRoles = async ssoConfigId => {
-      return this.get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`);
-    };
-
-    this.setSSODefaultRoles = async (ssoConfigId, body) => {
-      return this.put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`, body);
-    };
-
-    this.createSSOGroup = async (ssoConfigId, body) => {
-      return this.post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`, body);
-    };
-
-    this.updateSSOGroup = async (ssoConfigId, {
-      roleIds,
-      group,
-      id
-    }) => {
-      return this.patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${id}`, {
-        group,
-        roleIds
-      });
-    };
-
-    this.deleteSSOGroup = async (ssoConfigId, groupId) => {
-      return this.delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${groupId}`);
-    };
-
-    this.getSSOGroups = async ssoConfigId => {
-      return this.get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`);
-    };
-
-    this.preLoginV2 = async body => {
-      return this.post(`${urls.identity.auth.v2}/user/sso/prelogin`, body);
-    };
-
-    this.oidcPostLoginV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v2}/user/oidc/postlogin`, body);
-      return this.generateLoginResponse(data);
-    };
-
-    this.exchangeOAuthTokensV2 = async body => {
-      const data = await this.post(`${urls.oauth.v1}/token`, body);
-      return this.generateLoginResponseFromOAuthResponseV2(data);
-    };
+export async function generateLoginResponse(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return loginResponse;
+  }
 
-    this.silentOAuthRefreshTokenV2 = async () => {
-      const tabTenantId = getTabTenantFromSessionStorage(this.appName);
-      const data = await this.post(`${urls.oauth.v1}/authorize/silent`, {
-        tenantId: tabTenantId
-      });
-      return this.generateLoginResponseFromOAuthResponseV2(data);
-    };
+  ContextHolder.setAccessToken(loginResponse.accessToken);
+  const me = await getMeAndEntitlements();
+  const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
 
-    this.exchangeOAuthTokens = async body => {
-      const data = await this.post(`${urls.oauth.v1}/token`, body);
-      return this.generateLoginResponseFromOAuthResponse(data);
-    };
+  const user = _extends({}, loginResponse, decodedContent, me);
 
-    this.silentOAuthRefreshToken = async () => {
-      const tabTenantId = getTabTenantFromSessionStorage(this.appName);
-      const data = await this.post(`${urls.oauth.v1}/authorize/silent`, {
-        tenantId: tabTenantId
-      });
-      return this.generateLoginResponseFromOAuthResponse(data);
+  ContextHolder.setUser(user);
+  return user;
+}
+export async function generateLoginResponseV2(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return {
+      user: loginResponse
     };
+  }
 
-    this.resetPhoneNumber = async body => {
-      return this.post(`${urls.identity.users.v1}/phone/reset`, body);
-    };
+  ContextHolder.setAccessToken(loginResponse.accessToken);
+  const [me, tenants] = await Promise.all([getMeAndEntitlements(), getTenants()]);
+  const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
 
-    this.verifyResetPhoneNumber = async body => {
-      return this.post(`${urls.identity.users.v1}/phone/reset/verify`, body);
-    };
+  const user = _extends({}, loginResponse, decodedContent, me);
 
-    this.changePhoneNumberWithVerification = async body => {
-      return this.post(`${urls.identity.users.v1}/phone`, body);
-    };
+  ContextHolder.setUser(user);
+  return {
+    user,
+    tenants
+  };
+}
 
-    this.verifyChangePhoneNumber = async body => {
-      return this.post(`${urls.identity.users.v1}/phone/verify`, body);
-    };
+function shouldLoadEntitlements() {
+  if (!ContextHolder.shouldLoadEntitlements()) {
+    return false;
+  }
 
-    this.changePhoneNumber = async body => {
-      return this.put(`${urls.identity.users.v1}/phone/change`, body);
-    };
+  const [isEntitlementsFFOn] = FeatureFlags.getFeatureFlags([ADMIN_PORTAL_ENTITLEMENTS_FF], ContextHolder.getAppName() || '');
+  return isEntitlementsFFOn;
+}
 
-    this.webAuthnPreLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/webauthn/prelogin`, body);
-    };
+function shouldLoadMeAuthorization() {
+  const [shouldLoadAuthorization] = FeatureFlags.getFeatureFlags([LOAD_AUTHORIZATION_FF], ContextHolder.getAppName() || '');
+  return shouldLoadAuthorization;
+}
 
-    this.webAuthnPostLogin = async body => {
-      return this.post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
-    };
+export async function generateLoginResponseV3(loginResponse) {
+  const {
+    accessToken
+  } = loginResponse;
 
-    this.webAuthnPostLoginV2 = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
-      return this.generateLoginResponseV3(data);
+  if (!accessToken) {
+    return {
+      user: loginResponse
     };
+  }
 
-    this.webAuthnCreateNewDeviceSession = async () => {
-      return this.post(urls.identity.webAuthnDevices.v1);
-    };
+  ContextHolder.setAccessToken(accessToken);
+  const [me, currentUserTenants] = await Promise.all([getMeAndEntitlements(), getCurrentUserTenantsFunction()()]);
+  const decodedContent = accessToken ? jwtDecode(accessToken) : {};
 
-    this.getWebAuthnDevices = async () => {
-      return this.get(urls.identity.webAuthnDevices.v1);
-    };
+  const user = _extends({}, loginResponse, decodedContent, me);
 
-    this.deleteWebAuthnDevice = async deviceId => {
-      return this.delete(`${urls.identity.webAuthnDevices.v1}/${deviceId}`);
-    };
-
-    this.verifyNewDeviceSession = async body => {
-      return this.post(`${urls.identity.webAuthnDevices.v1}/verify`, body);
-    };
+  if (ContextHolder.isSessionPerTenantEnabled()) {
+    setTabTenantInSessionStorage(user.tenantId);
+  }
 
-    this.getVendorPublicAuthStrategiesConfig = async () => {
-      return this.get(`${urls.identity.configurations.v1}/auth/strategies/public`);
-    };
+  ContextHolder.setUser(user);
+  return {
+    user,
+    tenants: currentUserTenants.tenants,
+    activeTenant: currentUserTenants.activeTenant
+  };
+}
+export async function generateLoginResponseFromOAuthResponse(oauthResponse) {
+  ContextHolder.setAccessToken(oauthResponse.id_token);
+  const me = await getMeAndEntitlements();
+  const decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
+
+  const user = _extends({
+    mfaRequired: false,
+    accessToken: oauthResponse.id_token,
+    refreshToken: oauthResponse.refresh_token
+  }, decodedContent, me, {
+    expiresIn: oauthResponse.expires_in || 300
+  });
+
+  ContextHolder.setUser(user);
+  return user;
+}
+export async function generateLoginResponseFromOAuthResponseV2(oauthResponse) {
+  ContextHolder.setAccessToken(oauthResponse.id_token);
+  const [me, currentUserTenants] = await Promise.all([getMeAndEntitlements(), getCurrentUserTenantsFunction()()]);
+  const decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
+
+  const user = _extends({
+    mfaRequired: false,
+    accessToken: oauthResponse.id_token,
+    refreshToken: oauthResponse.refresh_token
+  }, decodedContent, me, {
+    expiresIn: oauthResponse.expires_in || 300
+  });
+
+  if (ContextHolder.isSessionPerTenantEnabled()) {
+    setTabTenantInSessionStorage(user.tenantId);
+  }
 
-    this.getPublicAuthStrategiesConfigForAuthenticatedUser = async () => {
-      return this.get(`${urls.identity.configurations.v1}/auth/strategies`);
-    };
+  ContextHolder.setUser(user);
+  return {
+    user,
+    tenants: currentUserTenants.tenants,
+    activeTenant: currentUserTenants.activeTenant
+  };
+}
+export async function preLogin(body) {
+  try {
+    const {
+      address
+    } = await Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
+    return address;
+  } catch {
+    return null;
+  }
+}
+export async function preLoginWithIdpType(body) {
+  return Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
+}
+export async function postLogin(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/saml/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function oidcPostLogin(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function login(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user`, body);
+  return generateLoginResponse(data);
+}
+export async function loginv2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user`, body);
+  return generateLoginResponseV3(data);
+}
+export async function loginWithMfa(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
+  return generateLoginResponse(data);
+}
+export async function loginWithMfaV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function activateAccount(body) {
+  return Post(`${urls.identity.users.v1}/activate`, body);
+}
+export async function activateAccountV2(body) {
+  const data = await Post(`${urls.identity.users.v1}/activate`, body);
+  return generateLoginResponseV3(data);
+}
+export async function getActivateAccountStrategy(params) {
+  return Get(`${urls.identity.users.v1}/activate/strategy`, params);
+}
+export async function resendActivationEmail(body) {
+  return Post(`${urls.identity.users.v1}/activate/reset`, body);
+}
+export async function resendInvitationEmail(body) {
+  return Post(`${urls.identity.users.v1}/invitation/reset`, body);
+}
+export async function acceptInvitation(body) {
+  return Post(`${urls.identity.users.v1}/invitation/accept`, body);
+}
+export async function refreshToken() {
+  const tabTenantId = getTabTenantFromSessionStorage();
+  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`, {
+    tenantId: tabTenantId
+  });
+  return generateLoginResponse(data);
+}
+export async function refreshTokenV2() {
+  const tabTenantId = getTabTenantFromSessionStorage();
+  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`, {
+    tenantId: tabTenantId
+  });
+  return generateLoginResponseV2(data);
+}
+export async function refreshTokenV3() {
+  const tabTenantId = getTabTenantFromSessionStorage();
+  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`, {
+    tenantId: tabTenantId
+  });
+  return generateLoginResponseV3(data);
+}
+export async function logout() {
+  return Post(`${urls.identity.auth.v1}/logout`);
+}
+export async function OAuthLogout(params) {
+  return Get(`${urls.oauth.v1}/logout`, params);
+}
+export async function forgotPassword(body) {
+  return Post(`${urls.identity.users.v1}/passwords/reset`, body);
+}
+export async function resetPassword(body) {
+  return Post(`${urls.identity.users.v1}/passwords/reset/verify`, body);
+}
+export async function loadPasswordConfig(params) {
+  return Get(`${urls.identity.users.v1}/passwords/config`, params);
+}
+export async function recoverMfaToken(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/recover`, body);
+}
+export async function enrollMfa() {
+  return Post(`${urls.identity.users.v1}/mfa/enroll`);
+}
+export async function preEnrollMFAAuthenticatorApp() {
+  return Post(`${urls.identity.users.v1}/mfa/authenticator/enroll`);
+}
+export async function enrollMFAAuthenticatorApp(body) {
+  return Post(`${urls.identity.users.v1}/mfa/authenticator/enroll/verify`, body);
+}
+export async function preEnrollMFASMS(body) {
+  return Post(`${urls.identity.users.v1}/mfa/sms/enroll`, body);
+}
+export async function enrollMFASMS(body) {
+  return Post(`${urls.identity.users.v1}/mfa/sms/enroll/verify`, body);
+}
+export async function preEnrollMFAWebAuthn() {
+  return Post(`${urls.identity.users.v1}/mfa/webauthn/enroll`);
+}
+export async function enrollMFAWebAuthn(body) {
+  return Post(`${urls.identity.users.v1}/mfa/webauthn/enroll/verify`, body);
+}
+export async function verifyMfa(body) {
+  return Post(`${urls.identity.users.v1}/mfa/enroll/verify`, body);
+}
+export async function disableMfa(body) {
+  return Post(`${urls.identity.users.v1}/mfa/disable`, body);
+}
+export async function disableMFAAuthenticatorApp(deviceId, body) {
+  return Post(`${urls.identity.users.v1}/mfa/authenticator/${deviceId}/disable/verify`, body);
+}
+export async function preDisableMFASMS(deviceId) {
+  return Post(`${urls.identity.users.v1}/mfa/sms/${deviceId}/disable`);
+}
+export async function disableMFASMS(deviceId, body) {
+  return Post(`${urls.identity.users.v1}/mfa/sms/${deviceId}/disable/verify`, body);
+}
+export async function preDisableMFAWebAuthn(deviceId) {
+  return Post(`${urls.identity.users.v1}/mfa/webauthn/${deviceId}/disable`);
+}
+export async function disableMFAWebAuthn(deviceId, body) {
+  return Post(`${urls.identity.users.v1}/mfa/webauthn/${deviceId}/disable/verify`, body);
+}
+export async function getMFADevices() {
+  return Get(`${urls.identity.users.v1}/mfa/devices`);
+}
+export async function preEnrollMFAAuthenticatorAppForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll`, body);
+}
+export async function enrollMFAAuthenticatorAppForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll/verify`, body);
+}
+export async function enrollMFAAuthenticatorAppForLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/authenticator/enroll/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function verifyMFAAuthenticatorAppForLogin(deviceId, body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/authenticator/${deviceId}/verify`, body);
+}
+export async function preVerifyMFAEmailCode(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/emailcode`, body);
+}
+export async function verifyMFAEmailCode(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/emailcode/verify`, body);
+}
+export async function verifyMFAEmailCodeV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/emailcode/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function preEnrollMFASMSForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/sms/enroll`, body);
+}
+export async function enrollMFASMSForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/sms/enroll/verify`, body);
+}
+export async function enrollMFASMSForLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/sms/enroll/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function preVerifyMFASMSForLogin(deviceId, body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}`, body);
+}
+export async function verifyMFASMSForLogin(deviceId, body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}/verify`, body);
+}
+export async function verifyMFASMSForLoginV2(deviceId, body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/sms/${deviceId}/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function preEnrollMFAWebAuthnForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll`, body);
+}
+export async function enrollMFAWebAuthnForLogin(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll/verify`, body);
+}
+export async function enrollMFAWebAuthnForLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/webauthn/enroll/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function preVerifyMFAWebAuthnForLogin(deviceId, body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}`, body);
+}
+export async function verifyMFAWebAuthnForLogin(deviceId, body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}/verify`, body);
+}
+export async function verifyMFAWebAuthnForLoginV2(deviceId, body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/webauthn/${deviceId}/verify`, body);
+  return generateLoginResponseV3(data);
+}
+export async function getSamlConfiguration() {
+  return Get(`${urls.team.sso.v1}/saml/configurations`);
+}
+export async function updateSamlConfiguration(body) {
+  return Post(`${urls.team.sso.v1}/saml/configurations`, body);
+}
+export async function getSamlVendorConfiguration() {
+  return Get(`${urls.team.sso.v1}/saml/configurations/vendor-config`);
+}
+export async function updateSamlVendorMetadata(body) {
+  return Put(`${urls.team.sso.v1}/saml/configurations/metadata`, body);
+}
+export async function validateSamlDomain() {
+  return Put(`${urls.team.sso.v1}/saml/validations/domain`);
+}
+export async function getSamlRoles() {
+  return Get(`${urls.team.sso.v1}/saml/configurations/roles/default`);
+}
+export async function getSamlRolesGroups() {
+  return Get(`${urls.team.sso.v2}/saml/configurations/groups`);
+}
+export async function updateSamlRoles({
+  roleIds
+}) {
+  return Post(`${urls.team.sso.v1}/saml/configurations/roles/default`, {
+    roleIds
+  });
+}
+export async function createSamlGroup({
+  roleIds,
+  group
+}) {
+  return Post(`${urls.team.sso.v2}/saml/configurations/groups`, {
+    group,
+    roleIds
+  });
+}
+export async function updateSamlGroup({
+  roleIds,
+  group,
+  id
+}) {
+  return Patch(`${urls.team.sso.v2}/saml/configurations/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+export async function deleteSamlGroup({
+  id
+}) {
+  return Delete(`${urls.team.sso.v2}/saml/configurations/groups/${id}`);
+}
+export async function getOidcConfiguration() {
+  return Get(`${urls.team.sso.v1}/oidc/configurations`);
+}
+export async function getSSOPublicConfiguration() {
+  return Get(`${urls.team.sso.v2}/configurations/public`);
+}
+export async function getSocialLoginProviders() {
+  return Get(urls.identity.sso.v1);
+}
+export async function getSocialLoginProvidersV2() {
+  return Get(urls.identity.sso.v2);
+}
+export async function getSocialLoginProvidersV2ForAuthenticatedUser() {
+  return Get(`${urls.identity.sso.v2}/authenticated`);
+}
+export async function getCustomSocialLoginProvidersV1() {
+  return Get(urls.identity.sso.custom.v1);
+}
+export async function loginViaSocialLogin({
+  provider,
+  code,
+  idToken,
+  redirectUri,
+  codeVerifier,
+  metadata,
+  invitationToken,
+  state
+}) {
+  const params = {};
+
+  if (code) {
+    params.code = code;
+  }
 
-    this.getMFAStrategiesConfig = async () => {
-      return this.get(`${urls.identity.configurations.v1}/mfa/strategies`);
-    };
+  if (idToken) {
+    params.id_token = idToken;
+  }
 
-    this.getUserAuthorization = async () => {
-      return this.get(`${urls.identity.users.authorization.v1}`);
-    };
+  if (redirectUri) {
+    params.redirectUri = redirectUri;
+  }
 
-    this.getMeV2 = async () => {
-      return this.get(`${urls.identity.users.v2}/me`);
-    };
+  if (codeVerifier) {
+    params.code_verifier = codeVerifier;
+  }
 
-    this.noThrowLoadEntitlements = async () => {
-      try {
-        return await this.entitlementsApi.loadEntitlementsV2();
-      } catch (e) {}
-    };
+  if (state) {
+    params.state = state;
+  }
 
-    this.getMeAndEntitlements = async () => {
-      const actions = [{
-        action: this.getMeV2,
-        shouldLoad: true
-      }, {
-        action: this.noThrowLoadEntitlements,
-        shouldLoad: this.shouldLoadEntitlements()
-      }, {
-        action: this.getUserAuthorization,
-        shouldLoad: this.shouldLoadMeAuthorization()
-      }];
-      const promises = actions.map(action => executeConditionalPromise(action));
-      const [me, entitlements, authorization] = await Promise.all(promises);
-      const tabTenant = getTabTenantFromSessionStorage(this.appName);
-
-      if (tabTenant) {
-        me.tenantId = tabTenant;
-      }
-
-      return _extends({}, me, authorization != null ? authorization : {}, {
-        entitlements
-      });
-    };
+  return Post(`${urls.identity.auth.v1}/user/sso/${provider}/postlogin`, {
+    metadata,
+    invitationToken
+  }, {
+    params
+  });
+}
+export async function getVendorConfig() {
+  return Get(`${urls.identity.configurations.v1}/public`);
+}
+export async function signUpUser(body) {
+  const {
+    shouldActivate,
+    authResponse,
+    userId,
+    tenantId
+  } = await Post(`${urls.identity.users.v1}/signUp`, body);
+  const response = {
+    shouldActivate,
+    userId,
+    tenantId
+  };
+
+  if (!shouldActivate && authResponse) {
+    const {
+      user,
+      tenants,
+      activeTenant
+    } = await generateLoginResponseV3(authResponse);
+    return _extends({}, response, {
+      user,
+      tenants,
+      activeTenant
+    });
+  }
 
-    this.generateStepupSession = async body => {
-      const data = await this.post(`${urls.identity.auth.v1}/user/step-up/generate`, body);
+  return response;
+}
+export async function getCurrentUserSessions() {
+  return Get(urls.identity.users.sessions.currentUser.v1);
+}
+export async function getCurrentUserSession() {
+  return Get(`${urls.identity.users.sessions.currentUser.v1}/current`);
+}
+export async function revokeSessionsForUser(userId) {
+  return Post(`${urls.identity.users.sessions.v1}/revoke`, {
+    userId
+  });
+}
+export async function getSessionConfigurations() {
+  return Get(urls.identity.users.sessions.configurations.v1);
+}
+export async function createOrUpdateSessionConfigrations(body) {
+  await Post(urls.identity.users.sessions.configurations.v1, body);
+}
+export async function deleteSessionForUser(id) {
+  await Delete(`${urls.identity.users.sessions.currentUser.v1}/${id}`);
+}
+export async function deleteAllSessionsForUser() {
+  await Delete(`${urls.identity.users.sessions.currentUser.v1}/all`);
+}
+export async function getUserAccessTokensData() {
+  return Get(urls.identity.users.accessTokens.v1);
+}
+export async function getTenantAccessTokensData() {
+  return Get(urls.identity.tenants.accessTokens.v1);
+}
+export async function deleteTenantAccessToken({
+  id
+}) {
+  return Delete(`${urls.identity.tenants.accessTokens.v1}/${id}`);
+}
+export async function deleteUserAccessToken({
+  id
+}) {
+  return Delete(`${urls.identity.users.accessTokens.v1}/${id}`);
+}
+export async function createUserAccessToken(body) {
+  return Post(urls.identity.users.accessTokens.v1, body);
+}
+export async function createTenantAccessToken(body) {
+  return Post(urls.identity.tenants.accessTokens.v1, body);
+}
+export async function getUserApiTokensData() {
+  return Get(urls.identity.users.apiTokens.v1);
+}
+export async function getTenantApiTokensData() {
+  return Get(urls.identity.tenants.apiTokens.v1);
+}
+export async function updateUserApiTokensData(body) {
+  return Post(urls.identity.users.apiTokens.v1, body);
+}
+export async function updateTenantApiTokensData(body) {
+  return Post(urls.identity.tenants.apiTokens.v2, body);
+}
+export async function deleteTenantApiToken({
+  tokenId
+}) {
+  return Delete(`${urls.identity.tenants.apiTokens.v1}/${tokenId}`);
+}
+export async function deleteUserApiToken({
+  tokenId
+}) {
+  return Delete(`${urls.identity.users.apiTokens.v1}/${tokenId}`);
+}
+export async function getUserById({
+  userId
+}) {
+  return Get(`${urls.identity.users.v1}/${userId}`);
+}
+export async function checkIfAllowToRememberMfaDevice(mfaToken) {
+  return Get(`${urls.identity.configurations.v1}/mfa-policy/allow-remember-device`, {
+    mfaToken
+  });
+}
+export async function passwordlessPreLogin(_ref) {
+  let {
+    type
+  } = _ref,
+      body = _objectWithoutPropertiesLoose(_ref, _excluded);
 
-      if (!data.accessToken) {
-        return data;
-      }
+  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/prelogin`, body);
+}
+export async function passwordlessPostLoginV2(_ref2) {
+  let {
+    type
+  } = _ref2,
+      body = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+
+  const data = await Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
+  return generateLoginResponseV3(data);
+}
+export async function passwordlessPostLogin(_ref3) {
+  let {
+    type
+  } = _ref3,
+      body = _objectWithoutPropertiesLoose(_ref3, _excluded3);
 
-      return this.generateLoginResponseV3(data);
-    };
+  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
+}
+export async function verifyInviteToken({
+  token
+}) {
+  return Post(urls.identity.tenants.invites.verify.v1, {
+    token
+  });
+}
+export async function getSSOConfigurations() {
+  return Get(`${urls.team.sso.v1}/configurations`);
+}
+export async function createSSOConfiguration(body) {
+  return Post(`${urls.team.sso.v1}/configurations`, body);
+}
+export async function updateSSOConfiguration(ssoConfigId, body) {
+  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}`, body);
+}
+export async function deleteSSOConfiguration(ssoConfigId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}`);
+}
+export async function createSSOConfigurationByMetadata(body) {
+  return Post(`${urls.team.sso.v1}/configurations/metadata`, body);
+}
+export async function updateSSOConfigurationByMetadata(ssoConfigId, body) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata`, body);
+}
+export async function createSSOConfigurationByMetadataUrl(body) {
+  return Post(`${urls.team.sso.v1}/configurations/metadata-url`, body);
+}
+export async function updateSSOConfigurationByMetadataUrl(ssoConfigId, body) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata-url`, body);
+}
+export async function createSSODomain(ssoConfigId, body) {
+  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains`, body);
+}
+export async function deleteSSODomain(ssoConfigId, domainId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}`);
+}
+export async function validateSSODomain(ssoConfigId, domainId) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
+}
+export async function validateSSODomainV2(ssoConfigId, domainId) {
+  return Put(`${urls.team.sso.v2}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
+}
+export async function getSSODefaultRoles(ssoConfigId) {
+  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`);
+}
+export async function setSSODefaultRoles(ssoConfigId, body) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`, body);
+}
+export async function createSSOGroup(ssoConfigId, body) {
+  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`, body);
+}
+export async function updateSSOGroup(ssoConfigId, {
+  roleIds,
+  group,
+  id
+}) {
+  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+export async function deleteSSOGroup(ssoConfigId, groupId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${groupId}`);
+}
+export async function getSSOGroups(ssoConfigId) {
+  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`);
+}
+export async function preLoginV2(body) {
+  return Post(`${urls.identity.auth.v2}/user/sso/prelogin`, body);
+}
+export async function oidcPostLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v2}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function exchangeOAuthTokensV2(body) {
+  const data = await Post(`${urls.oauth.v1}/token`, body);
+  return generateLoginResponseFromOAuthResponseV2(data);
+}
+export async function silentOAuthRefreshTokenV2() {
+  const tabTenantId = getTabTenantFromSessionStorage();
+  const data = await Post(`${urls.oauth.v1}/authorize/silent`, {
+    tenantId: tabTenantId
+  });
+  return generateLoginResponseFromOAuthResponseV2(data);
+}
+export async function exchangeOAuthTokens(body) {
+  const data = await Post(`${urls.oauth.v1}/token`, body);
+  return generateLoginResponseFromOAuthResponse(data);
+}
+export async function silentOAuthRefreshToken() {
+  const tabTenantId = getTabTenantFromSessionStorage();
+  const data = await Post(`${urls.oauth.v1}/authorize/silent`, {
+    tenantId: tabTenantId
+  });
+  return generateLoginResponseFromOAuthResponse(data);
+}
+export async function resetPhoneNumber(body) {
+  return Post(`${urls.identity.users.v1}/phone/reset`, body);
+}
+export async function verifyResetPhoneNumber(body) {
+  return Post(`${urls.identity.users.v1}/phone/reset/verify`, body);
+}
+export async function changePhoneNumberWithVerification(body) {
+  return Post(`${urls.identity.users.v1}/phone`, body);
+}
+export async function verifyChangePhoneNumber(body) {
+  return Post(`${urls.identity.users.v1}/phone/verify`, body);
+}
+export async function changePhoneNumber(body) {
+  return Put(`${urls.identity.users.v1}/phone/change`, body);
+}
+export async function webAuthnPreLogin(body) {
+  return Post(`${urls.identity.auth.v1}/webauthn/prelogin`, body);
+}
+export async function webAuthnPostLogin(body) {
+  return Post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
+}
+export async function webAuthnPostLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
+  return generateLoginResponseV3(data);
+}
+export async function webAuthnCreateNewDeviceSession() {
+  return Post(urls.identity.webAuthnDevices.v1);
+}
+export async function getWebAuthnDevices() {
+  return Get(urls.identity.webAuthnDevices.v1);
+}
+export async function deleteWebAuthnDevice(deviceId) {
+  return Delete(`${urls.identity.webAuthnDevices.v1}/${deviceId}`);
+}
+export async function verifyNewDeviceSession(body) {
+  return Post(`${urls.identity.webAuthnDevices.v1}/verify`, body);
+}
+export async function getVendorPublicAuthStrategiesConfig() {
+  return Get(`${urls.identity.configurations.v1}/auth/strategies/public`);
+}
+export async function getPublicAuthStrategiesConfigForAuthenticatedUser() {
+  return Get(`${urls.identity.configurations.v1}/auth/strategies`);
+}
+export async function getMFAStrategiesConfig() {
+  return Get(`${urls.identity.configurations.v1}/mfa/strategies`);
+}
+export async function getUserAuthorization() {
+  return Get(`${urls.identity.users.authorization.v1}`);
+}
+export async function getMeV2() {
+  return Get(`${urls.identity.users.v2}/me`);
+}
 
-    this.getGlobalSecurityPolicy = this.securityPolicy.getGlobalSecurityPolicy.bind(this.securityPolicy);
-    this.getMfaPolicy = this.securityPolicy.getMfaPolicy.bind(this.securityPolicy);
-    this.getVendorMfaPolicy = this.securityPolicy.getVendorMfaPolicy.bind(this.securityPolicy);
-    this.saveMfaPolicy = this.securityPolicy.saveMfaPolicy.bind(this.securityPolicy);
-    this.getLockoutPolicy = this.securityPolicy.getLockoutPolicy.bind(this.securityPolicy);
-    this.getVendorLockoutPolicy = this.securityPolicy.getVendorLockoutPolicy.bind(this.securityPolicy);
-    this.saveLockoutPolicy = this.securityPolicy.saveLockoutPolicy.bind(this.securityPolicy);
-    this.getCaptchaPolicy = this.securityPolicy.getCaptchaPolicy.bind(this.securityPolicy);
-    this.getPasswordHistoryPolicy = this.securityPolicy.getPasswordHistoryPolicy.bind(this.securityPolicy);
-    this.getVendorPasswordHistoryPolicy = this.securityPolicy.getVendorPasswordHistoryPolicy.bind(this.securityPolicy);
-    this.savePasswordHistoryPolicy = this.securityPolicy.savePasswordHistoryPolicy.bind(this.securityPolicy);
-    this.getPasswordConfigPolicy = this.securityPolicy.getPasswordConfigPolicy.bind(this.securityPolicy);
-    this.getDomainRestrictions = this.securityPolicy.getDomainRestrictions.bind(this.securityPolicy);
-    this.getDomainRestrictionsConfig = this.securityPolicy.getDomainRestrictionsConfig.bind(this.securityPolicy);
-    this.createDomainRestriction = this.securityPolicy.createDomainRestriction.bind(this.securityPolicy);
-    this.updateDomainRestrictionConfig = this.securityPolicy.updateDomainRestrictionConfig.bind(this.securityPolicy);
-    this.deleteDomainRestriction = this.securityPolicy.deleteDomainRestriction.bind(this.securityPolicy);
-    this.getIPRestrictions = this.securityPolicy.getIPRestrictions.bind(this.securityPolicy);
-    this.getIPRestrictionsConfig = this.securityPolicy.getIPRestrictionsConfig.bind(this.securityPolicy);
-    this.createIPRestriction = this.securityPolicy.createIPRestriction.bind(this.securityPolicy);
-    this.bulkCreateIPRestriction = this.securityPolicy.bulkCreateIPRestriction.bind(this.securityPolicy);
-    this.updateIPRestrictionConfig = this.securityPolicy.updateIPRestrictionConfig.bind(this.securityPolicy);
-    this.deleteIPRestriction = this.securityPolicy.deleteIPRestriction.bind(this.securityPolicy);
-    this.testCurrentIp = this.securityPolicy.testCurrentIp.bind(this.securityPolicy);
-    this.testCurrentIpInAllowList = this.securityPolicy.testCurrentIpInAllowList.bind(this.securityPolicy);
+const noThrowLoadEntitlements = async () => {
+  try {
+    return await loadEntitlementsV2();
+  } catch (e) {}
+};
+
+export async function getMeAndEntitlements() {
+  const actions = [{
+    action: getMeV2,
+    shouldLoad: true
+  }, {
+    action: noThrowLoadEntitlements,
+    shouldLoad: shouldLoadEntitlements()
+  }, {
+    action: getUserAuthorization,
+    shouldLoad: shouldLoadMeAuthorization()
+  }];
+  const promises = actions.map(action => executeConditionalPromise(action));
+  const [me, entitlements, authorization] = await Promise.all(promises);
+  const tabTenant = getTabTenantFromSessionStorage();
+
+  if (tabTenant) {
+    me.tenantId = tabTenant;
   }
 
-  shouldLoadEntitlements() {
-    if (!ContextHolder.for(this.appName).shouldLoadEntitlements()) {
-      return false;
-    }
-
-    const [isEntitlementsFFOn] = FeatureFlags.getFeatureFlags([ADMIN_PORTAL_ENTITLEMENTS_FF], this.appName || '');
-    return isEntitlementsFFOn;
-  }
+  return _extends({}, me, authorization != null ? authorization : {}, {
+    entitlements
+  });
+}
+export async function generateStepupSession(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/step-up/generate`, body);
 
-  shouldLoadMeAuthorization() {
-    const [shouldLoadAuthorization] = FeatureFlags.getFeatureFlags([LOAD_AUTHORIZATION_FF], this.appName);
-    return shouldLoadAuthorization;
+  if (!data.accessToken) {
+    return data;
   }
 
-}
-export default new AuthenticationApi('default');
+  return generateLoginResponseV3(data);
+}