@frontegg/rest-api 3.1.76-alpha.9502349697 → 3.1.76-alpha.9794353373

package/node/auth/index.js

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