@frontegg/rest-api 3.1.73 → 3.1.74-alpha.9436511986

package/node/auth/index.js

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