@frontegg/rest-api 2.10.90 → 3.0.1

package/auth/index.js

@@ -0,0 +1,2102 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { getTenants } from "../tenants";
+export * from './secutiry-poilicy';
+export * from './enums';
+import { urls } from '../constants';
+import { ContextHolder } from '../ContextHolder';
+import { Delete, Get, Patch, Post, Put } from '../fetch';
+import { jwtDecode } from '../jwt';
+export function generateLoginResponse(_x) {
+  return _generateLoginResponse.apply(this, arguments);
+}
+
+function _generateLoginResponse() {
+  _generateLoginResponse = _asyncToGenerator(_regeneratorRuntime.mark(function _callee(loginResponse) {
+    var me, decodedContent, user;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (loginResponse.accessToken) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return", loginResponse);
+
+          case 2:
+            ContextHolder.setAccessToken(loginResponse.accessToken);
+            _context.next = 5;
+            return Get("".concat(urls.identity.users.v2, "/me"));
+
+          case 5:
+            me = _context.sent;
+            decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
+            user = _extends({}, loginResponse, decodedContent, me);
+            ContextHolder.setUser(user);
+            return _context.abrupt("return", user);
+
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _generateLoginResponse.apply(this, arguments);
+}
+
+export function generateLoginResponseV2(_x2) {
+  return _generateLoginResponseV.apply(this, arguments);
+}
+
+function _generateLoginResponseV() {
+  _generateLoginResponseV = _asyncToGenerator(_regeneratorRuntime.mark(function _callee2(loginResponse) {
+    var _yield$Promise$all, _yield$Promise$all2, me, tenants, decodedContent, user;
+
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (loginResponse.accessToken) {
+              _context2.next = 2;
+              break;
+            }
+
+            return _context2.abrupt("return", {
+              user: loginResponse
+            });
+
+          case 2:
+            ContextHolder.setAccessToken(loginResponse.accessToken);
+            _context2.next = 5;
+            return Promise.all([Get("".concat(urls.identity.users.v2, "/me")), getTenants()]);
+
+          case 5:
+            _yield$Promise$all = _context2.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+            me = _yield$Promise$all2[0];
+            tenants = _yield$Promise$all2[1];
+            decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
+            user = _extends({}, loginResponse, decodedContent, me);
+            ContextHolder.setUser(user);
+            return _context2.abrupt("return", {
+              user: user,
+              tenants: tenants
+            });
+
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _generateLoginResponseV.apply(this, arguments);
+}
+
+export function generateLoginResponseFromOAuthResponse(_x3) {
+  return _generateLoginResponseFromOAuthResponse.apply(this, arguments);
+}
+
+function _generateLoginResponseFromOAuthResponse() {
+  _generateLoginResponseFromOAuthResponse = _asyncToGenerator(_regeneratorRuntime.mark(function _callee3(oauthResponse) {
+    var me, decodedContent, user;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            ContextHolder.setAccessToken(oauthResponse.id_token);
+            _context3.next = 3;
+            return Get("".concat(urls.identity.users.v2, "/me"));
+
+          case 3:
+            me = _context3.sent;
+            decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
+            user = _extends({
+              mfaRequired: false,
+              accessToken: oauthResponse.id_token,
+              refreshToken: oauthResponse.refresh_token
+            }, decodedContent, me);
+            ContextHolder.setUser(user);
+            return _context3.abrupt("return", user);
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _generateLoginResponseFromOAuthResponse.apply(this, arguments);
+}
+
+export function preLogin(_x4) {
+  return _preLogin.apply(this, arguments);
+}
+
+function _preLogin() {
+  _preLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee4(body) {
+    var _yield$Post, address;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.prev = 0;
+            _context4.next = 3;
+            return Post("".concat(urls.identity.auth.v1, "/user/saml/prelogin"), body);
+
+          case 3:
+            _yield$Post = _context4.sent;
+            address = _yield$Post.address;
+            return _context4.abrupt("return", address);
+
+          case 8:
+            _context4.prev = 8;
+            _context4.t0 = _context4["catch"](0);
+            return _context4.abrupt("return", null);
+
+          case 11:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[0, 8]]);
+  }));
+  return _preLogin.apply(this, arguments);
+}
+
+export function preLoginWithIdpType(_x5) {
+  return _preLoginWithIdpType.apply(this, arguments);
+}
+
+function _preLoginWithIdpType() {
+  _preLoginWithIdpType = _asyncToGenerator(_regeneratorRuntime.mark(function _callee5(body) {
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            return _context5.abrupt("return", Post("".concat(urls.identity.auth.v1, "/user/saml/prelogin"), body));
+
+          case 1:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _preLoginWithIdpType.apply(this, arguments);
+}
+
+export function postLogin(_x6) {
+  return _postLogin.apply(this, arguments);
+}
+
+function _postLogin() {
+  _postLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee6(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user/saml/postlogin"), body);
+
+          case 2:
+            data = _context6.sent;
+            return _context6.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _postLogin.apply(this, arguments);
+}
+
+export function oidcPostLogin(_x7) {
+  return _oidcPostLogin.apply(this, arguments);
+}
+
+function _oidcPostLogin() {
+  _oidcPostLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee7(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user/oidc/postlogin"), body);
+
+          case 2:
+            data = _context7.sent;
+            return _context7.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  }));
+  return _oidcPostLogin.apply(this, arguments);
+}
+
+export function login(_x8) {
+  return _login.apply(this, arguments);
+}
+
+function _login() {
+  _login = _asyncToGenerator(_regeneratorRuntime.mark(function _callee8(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            _context8.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user"), body);
+
+          case 2:
+            data = _context8.sent;
+            return _context8.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  }));
+  return _login.apply(this, arguments);
+}
+
+export function loginWithMfa(_x9) {
+  return _loginWithMfa.apply(this, arguments);
+}
+
+function _loginWithMfa() {
+  _loginWithMfa = _asyncToGenerator(_regeneratorRuntime.mark(function _callee9(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            _context9.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user/mfa/verify"), body);
+
+          case 2:
+            data = _context9.sent;
+            return _context9.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee9);
+  }));
+  return _loginWithMfa.apply(this, arguments);
+}
+
+export function activateAccount(_x10) {
+  return _activateAccount.apply(this, arguments);
+}
+
+function _activateAccount() {
+  _activateAccount = _asyncToGenerator(_regeneratorRuntime.mark(function _callee10(body) {
+    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+      while (1) {
+        switch (_context10.prev = _context10.next) {
+          case 0:
+            return _context10.abrupt("return", Post("".concat(urls.identity.users.v1, "/activate"), body));
+
+          case 1:
+          case "end":
+            return _context10.stop();
+        }
+      }
+    }, _callee10);
+  }));
+  return _activateAccount.apply(this, arguments);
+}
+
+export function getActivateAccountStrategy(_x11) {
+  return _getActivateAccountStrategy.apply(this, arguments);
+}
+
+function _getActivateAccountStrategy() {
+  _getActivateAccountStrategy = _asyncToGenerator(_regeneratorRuntime.mark(function _callee11(params) {
+    return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            return _context11.abrupt("return", Get("".concat(urls.identity.users.v1, "/activate/strategy"), params));
+
+          case 1:
+          case "end":
+            return _context11.stop();
+        }
+      }
+    }, _callee11);
+  }));
+  return _getActivateAccountStrategy.apply(this, arguments);
+}
+
+export function resendActivationEmail(_x12) {
+  return _resendActivationEmail.apply(this, arguments);
+}
+
+function _resendActivationEmail() {
+  _resendActivationEmail = _asyncToGenerator(_regeneratorRuntime.mark(function _callee12(body) {
+    return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+      while (1) {
+        switch (_context12.prev = _context12.next) {
+          case 0:
+            return _context12.abrupt("return", Post("".concat(urls.identity.users.v1, "/activate/reset"), body));
+
+          case 1:
+          case "end":
+            return _context12.stop();
+        }
+      }
+    }, _callee12);
+  }));
+  return _resendActivationEmail.apply(this, arguments);
+}
+
+export function acceptInvitation(_x13) {
+  return _acceptInvitation.apply(this, arguments);
+}
+
+function _acceptInvitation() {
+  _acceptInvitation = _asyncToGenerator(_regeneratorRuntime.mark(function _callee13(body) {
+    return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+      while (1) {
+        switch (_context13.prev = _context13.next) {
+          case 0:
+            return _context13.abrupt("return", Post("".concat(urls.identity.users.v1, "/invitation/accept"), body));
+
+          case 1:
+          case "end":
+            return _context13.stop();
+        }
+      }
+    }, _callee13);
+  }));
+  return _acceptInvitation.apply(this, arguments);
+}
+
+export function refreshToken() {
+  return _refreshToken.apply(this, arguments);
+}
+
+function _refreshToken() {
+  _refreshToken = _asyncToGenerator(_regeneratorRuntime.mark(function _callee14() {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+      while (1) {
+        switch (_context14.prev = _context14.next) {
+          case 0:
+            _context14.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user/token/refresh"));
+
+          case 2:
+            data = _context14.sent;
+            return _context14.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context14.stop();
+        }
+      }
+    }, _callee14);
+  }));
+  return _refreshToken.apply(this, arguments);
+}
+
+export function refreshTokenV2() {
+  return _refreshTokenV.apply(this, arguments);
+}
+
+function _refreshTokenV() {
+  _refreshTokenV = _asyncToGenerator(_regeneratorRuntime.mark(function _callee15() {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+      while (1) {
+        switch (_context15.prev = _context15.next) {
+          case 0:
+            _context15.next = 2;
+            return Post("".concat(urls.identity.auth.v1, "/user/token/refresh"));
+
+          case 2:
+            data = _context15.sent;
+            return _context15.abrupt("return", generateLoginResponseV2(data));
+
+          case 4:
+          case "end":
+            return _context15.stop();
+        }
+      }
+    }, _callee15);
+  }));
+  return _refreshTokenV.apply(this, arguments);
+}
+
+export function logout() {
+  return _logout.apply(this, arguments);
+}
+
+function _logout() {
+  _logout = _asyncToGenerator(_regeneratorRuntime.mark(function _callee16() {
+    return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+      while (1) {
+        switch (_context16.prev = _context16.next) {
+          case 0:
+            return _context16.abrupt("return", Post("".concat(urls.identity.auth.v1, "/logout")));
+
+          case 1:
+          case "end":
+            return _context16.stop();
+        }
+      }
+    }, _callee16);
+  }));
+  return _logout.apply(this, arguments);
+}
+
+export function forgotPassword(_x14) {
+  return _forgotPassword.apply(this, arguments);
+}
+
+function _forgotPassword() {
+  _forgotPassword = _asyncToGenerator(_regeneratorRuntime.mark(function _callee17(body) {
+    return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+      while (1) {
+        switch (_context17.prev = _context17.next) {
+          case 0:
+            return _context17.abrupt("return", Post("".concat(urls.identity.users.v1, "/passwords/reset"), body));
+
+          case 1:
+          case "end":
+            return _context17.stop();
+        }
+      }
+    }, _callee17);
+  }));
+  return _forgotPassword.apply(this, arguments);
+}
+
+export function resetPassword(_x15) {
+  return _resetPassword.apply(this, arguments);
+}
+
+function _resetPassword() {
+  _resetPassword = _asyncToGenerator(_regeneratorRuntime.mark(function _callee18(body) {
+    return _regeneratorRuntime.wrap(function _callee18$(_context18) {
+      while (1) {
+        switch (_context18.prev = _context18.next) {
+          case 0:
+            return _context18.abrupt("return", Post("".concat(urls.identity.users.v1, "/passwords/reset/verify"), body));
+
+          case 1:
+          case "end":
+            return _context18.stop();
+        }
+      }
+    }, _callee18);
+  }));
+  return _resetPassword.apply(this, arguments);
+}
+
+export function loadPasswordConfig(_x16) {
+  return _loadPasswordConfig.apply(this, arguments);
+}
+
+function _loadPasswordConfig() {
+  _loadPasswordConfig = _asyncToGenerator(_regeneratorRuntime.mark(function _callee19(params) {
+    return _regeneratorRuntime.wrap(function _callee19$(_context19) {
+      while (1) {
+        switch (_context19.prev = _context19.next) {
+          case 0:
+            return _context19.abrupt("return", Get("".concat(urls.identity.users.v1, "/passwords/config"), params));
+
+          case 1:
+          case "end":
+            return _context19.stop();
+        }
+      }
+    }, _callee19);
+  }));
+  return _loadPasswordConfig.apply(this, arguments);
+}
+
+export function recoverMfaToken(_x17) {
+  return _recoverMfaToken.apply(this, arguments);
+}
+
+function _recoverMfaToken() {
+  _recoverMfaToken = _asyncToGenerator(_regeneratorRuntime.mark(function _callee20(body) {
+    return _regeneratorRuntime.wrap(function _callee20$(_context20) {
+      while (1) {
+        switch (_context20.prev = _context20.next) {
+          case 0:
+            return _context20.abrupt("return", Post("".concat(urls.identity.auth.v1, "/user/mfa/recover"), body));
+
+          case 1:
+          case "end":
+            return _context20.stop();
+        }
+      }
+    }, _callee20);
+  }));
+  return _recoverMfaToken.apply(this, arguments);
+}
+
+export function enrollMfa() {
+  return _enrollMfa.apply(this, arguments);
+}
+
+function _enrollMfa() {
+  _enrollMfa = _asyncToGenerator(_regeneratorRuntime.mark(function _callee21() {
+    return _regeneratorRuntime.wrap(function _callee21$(_context21) {
+      while (1) {
+        switch (_context21.prev = _context21.next) {
+          case 0:
+            return _context21.abrupt("return", Post("".concat(urls.identity.users.v1, "/mfa/enroll")));
+
+          case 1:
+          case "end":
+            return _context21.stop();
+        }
+      }
+    }, _callee21);
+  }));
+  return _enrollMfa.apply(this, arguments);
+}
+
+export function verifyMfa(_x18) {
+  return _verifyMfa.apply(this, arguments);
+}
+
+function _verifyMfa() {
+  _verifyMfa = _asyncToGenerator(_regeneratorRuntime.mark(function _callee22(body) {
+    return _regeneratorRuntime.wrap(function _callee22$(_context22) {
+      while (1) {
+        switch (_context22.prev = _context22.next) {
+          case 0:
+            return _context22.abrupt("return", Post("".concat(urls.identity.users.v1, "/mfa/enroll/verify"), body));
+
+          case 1:
+          case "end":
+            return _context22.stop();
+        }
+      }
+    }, _callee22);
+  }));
+  return _verifyMfa.apply(this, arguments);
+}
+
+export function disableMfa(_x19) {
+  return _disableMfa.apply(this, arguments);
+}
+
+function _disableMfa() {
+  _disableMfa = _asyncToGenerator(_regeneratorRuntime.mark(function _callee23(body) {
+    return _regeneratorRuntime.wrap(function _callee23$(_context23) {
+      while (1) {
+        switch (_context23.prev = _context23.next) {
+          case 0:
+            return _context23.abrupt("return", Post("".concat(urls.identity.users.v1, "/mfa/disable"), body));
+
+          case 1:
+          case "end":
+            return _context23.stop();
+        }
+      }
+    }, _callee23);
+  }));
+  return _disableMfa.apply(this, arguments);
+}
+
+export function getSamlConfiguration() {
+  return _getSamlConfiguration.apply(this, arguments);
+}
+
+function _getSamlConfiguration() {
+  _getSamlConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee24() {
+    return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+      while (1) {
+        switch (_context24.prev = _context24.next) {
+          case 0:
+            return _context24.abrupt("return", Get("".concat(urls.team.sso.v1, "/saml/configurations")));
+
+          case 1:
+          case "end":
+            return _context24.stop();
+        }
+      }
+    }, _callee24);
+  }));
+  return _getSamlConfiguration.apply(this, arguments);
+}
+
+export function updateSamlConfiguration(_x20) {
+  return _updateSamlConfiguration.apply(this, arguments);
+}
+
+function _updateSamlConfiguration() {
+  _updateSamlConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee25(body) {
+    return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+      while (1) {
+        switch (_context25.prev = _context25.next) {
+          case 0:
+            return _context25.abrupt("return", Post("".concat(urls.team.sso.v1, "/saml/configurations"), body));
+
+          case 1:
+          case "end":
+            return _context25.stop();
+        }
+      }
+    }, _callee25);
+  }));
+  return _updateSamlConfiguration.apply(this, arguments);
+}
+
+export function getSamlVendorConfiguration() {
+  return _getSamlVendorConfiguration.apply(this, arguments);
+}
+
+function _getSamlVendorConfiguration() {
+  _getSamlVendorConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee26() {
+    return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+      while (1) {
+        switch (_context26.prev = _context26.next) {
+          case 0:
+            return _context26.abrupt("return", Get("".concat(urls.team.sso.v1, "/saml/configurations/vendor-config")));
+
+          case 1:
+          case "end":
+            return _context26.stop();
+        }
+      }
+    }, _callee26);
+  }));
+  return _getSamlVendorConfiguration.apply(this, arguments);
+}
+
+export function updateSamlVendorMetadata(_x21) {
+  return _updateSamlVendorMetadata.apply(this, arguments);
+}
+
+function _updateSamlVendorMetadata() {
+  _updateSamlVendorMetadata = _asyncToGenerator(_regeneratorRuntime.mark(function _callee27(body) {
+    return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+      while (1) {
+        switch (_context27.prev = _context27.next) {
+          case 0:
+            return _context27.abrupt("return", Put("".concat(urls.team.sso.v1, "/saml/configurations/metadata"), body));
+
+          case 1:
+          case "end":
+            return _context27.stop();
+        }
+      }
+    }, _callee27);
+  }));
+  return _updateSamlVendorMetadata.apply(this, arguments);
+}
+
+export function validateSamlDomain() {
+  return _validateSamlDomain.apply(this, arguments);
+}
+
+function _validateSamlDomain() {
+  _validateSamlDomain = _asyncToGenerator(_regeneratorRuntime.mark(function _callee28() {
+    return _regeneratorRuntime.wrap(function _callee28$(_context28) {
+      while (1) {
+        switch (_context28.prev = _context28.next) {
+          case 0:
+            return _context28.abrupt("return", Put("".concat(urls.team.sso.v1, "/saml/validations/domain")));
+
+          case 1:
+          case "end":
+            return _context28.stop();
+        }
+      }
+    }, _callee28);
+  }));
+  return _validateSamlDomain.apply(this, arguments);
+}
+
+export function getSamlRoles() {
+  return _getSamlRoles.apply(this, arguments);
+}
+
+function _getSamlRoles() {
+  _getSamlRoles = _asyncToGenerator(_regeneratorRuntime.mark(function _callee29() {
+    return _regeneratorRuntime.wrap(function _callee29$(_context29) {
+      while (1) {
+        switch (_context29.prev = _context29.next) {
+          case 0:
+            return _context29.abrupt("return", Get("".concat(urls.team.sso.v1, "/saml/configurations/roles/default")));
+
+          case 1:
+          case "end":
+            return _context29.stop();
+        }
+      }
+    }, _callee29);
+  }));
+  return _getSamlRoles.apply(this, arguments);
+}
+
+export function getSamlRolesGroups() {
+  return _getSamlRolesGroups.apply(this, arguments);
+}
+
+function _getSamlRolesGroups() {
+  _getSamlRolesGroups = _asyncToGenerator(_regeneratorRuntime.mark(function _callee30() {
+    return _regeneratorRuntime.wrap(function _callee30$(_context30) {
+      while (1) {
+        switch (_context30.prev = _context30.next) {
+          case 0:
+            return _context30.abrupt("return", Get("".concat(urls.team.sso.v2, "/saml/configurations/groups")));
+
+          case 1:
+          case "end":
+            return _context30.stop();
+        }
+      }
+    }, _callee30);
+  }));
+  return _getSamlRolesGroups.apply(this, arguments);
+}
+
+export function updateSamlRoles(_x22) {
+  return _updateSamlRoles.apply(this, arguments);
+}
+
+function _updateSamlRoles() {
+  _updateSamlRoles = _asyncToGenerator(_regeneratorRuntime.mark(function _callee31(_ref) {
+    var roleIds;
+    return _regeneratorRuntime.wrap(function _callee31$(_context31) {
+      while (1) {
+        switch (_context31.prev = _context31.next) {
+          case 0:
+            roleIds = _ref.roleIds;
+            return _context31.abrupt("return", Post("".concat(urls.team.sso.v1, "/saml/configurations/roles/default"), {
+              roleIds: roleIds
+            }));
+
+          case 2:
+          case "end":
+            return _context31.stop();
+        }
+      }
+    }, _callee31);
+  }));
+  return _updateSamlRoles.apply(this, arguments);
+}
+
+export function createSamlGroup(_x23) {
+  return _createSamlGroup.apply(this, arguments);
+}
+
+function _createSamlGroup() {
+  _createSamlGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee32(_ref2) {
+    var roleIds, group;
+    return _regeneratorRuntime.wrap(function _callee32$(_context32) {
+      while (1) {
+        switch (_context32.prev = _context32.next) {
+          case 0:
+            roleIds = _ref2.roleIds, group = _ref2.group;
+            return _context32.abrupt("return", Post("".concat(urls.team.sso.v2, "/saml/configurations/groups"), {
+              group: group,
+              roleIds: roleIds
+            }));
+
+          case 2:
+          case "end":
+            return _context32.stop();
+        }
+      }
+    }, _callee32);
+  }));
+  return _createSamlGroup.apply(this, arguments);
+}
+
+export function updateSamlGroup(_x24) {
+  return _updateSamlGroup.apply(this, arguments);
+}
+
+function _updateSamlGroup() {
+  _updateSamlGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee33(_ref3) {
+    var roleIds, group, id;
+    return _regeneratorRuntime.wrap(function _callee33$(_context33) {
+      while (1) {
+        switch (_context33.prev = _context33.next) {
+          case 0:
+            roleIds = _ref3.roleIds, group = _ref3.group, id = _ref3.id;
+            return _context33.abrupt("return", Patch("".concat(urls.team.sso.v2, "/saml/configurations/groups/").concat(id), {
+              group: group,
+              roleIds: roleIds
+            }));
+
+          case 2:
+          case "end":
+            return _context33.stop();
+        }
+      }
+    }, _callee33);
+  }));
+  return _updateSamlGroup.apply(this, arguments);
+}
+
+export function deleteSamlGroup(_x25) {
+  return _deleteSamlGroup.apply(this, arguments);
+}
+
+function _deleteSamlGroup() {
+  _deleteSamlGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee34(_ref4) {
+    var id;
+    return _regeneratorRuntime.wrap(function _callee34$(_context34) {
+      while (1) {
+        switch (_context34.prev = _context34.next) {
+          case 0:
+            id = _ref4.id;
+            return _context34.abrupt("return", Delete("".concat(urls.team.sso.v2, "/saml/configurations/groups/").concat(id)));
+
+          case 2:
+          case "end":
+            return _context34.stop();
+        }
+      }
+    }, _callee34);
+  }));
+  return _deleteSamlGroup.apply(this, arguments);
+}
+
+export function getOidcConfiguration() {
+  return _getOidcConfiguration.apply(this, arguments);
+}
+
+function _getOidcConfiguration() {
+  _getOidcConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee35() {
+    return _regeneratorRuntime.wrap(function _callee35$(_context35) {
+      while (1) {
+        switch (_context35.prev = _context35.next) {
+          case 0:
+            return _context35.abrupt("return", Get("".concat(urls.team.sso.v1, "/oidc/configurations")));
+
+          case 1:
+          case "end":
+            return _context35.stop();
+        }
+      }
+    }, _callee35);
+  }));
+  return _getOidcConfiguration.apply(this, arguments);
+}
+
+export function getSSOPublicConfiguration() {
+  return _getSSOPublicConfiguration.apply(this, arguments);
+}
+
+function _getSSOPublicConfiguration() {
+  _getSSOPublicConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee36() {
+    return _regeneratorRuntime.wrap(function _callee36$(_context36) {
+      while (1) {
+        switch (_context36.prev = _context36.next) {
+          case 0:
+            return _context36.abrupt("return", Get("".concat(urls.team.sso.v2, "/configurations/public")));
+
+          case 1:
+          case "end":
+            return _context36.stop();
+        }
+      }
+    }, _callee36);
+  }));
+  return _getSSOPublicConfiguration.apply(this, arguments);
+}
+
+export function getSocialLoginProviders() {
+  return _getSocialLoginProviders.apply(this, arguments);
+}
+
+function _getSocialLoginProviders() {
+  _getSocialLoginProviders = _asyncToGenerator(_regeneratorRuntime.mark(function _callee37() {
+    return _regeneratorRuntime.wrap(function _callee37$(_context37) {
+      while (1) {
+        switch (_context37.prev = _context37.next) {
+          case 0:
+            return _context37.abrupt("return", Get(urls.identity.sso.v1));
+
+          case 1:
+          case "end":
+            return _context37.stop();
+        }
+      }
+    }, _callee37);
+  }));
+  return _getSocialLoginProviders.apply(this, arguments);
+}
+
+export function getSocialLoginProvidersV2() {
+  return _getSocialLoginProvidersV.apply(this, arguments);
+}
+
+function _getSocialLoginProvidersV() {
+  _getSocialLoginProvidersV = _asyncToGenerator(_regeneratorRuntime.mark(function _callee38() {
+    return _regeneratorRuntime.wrap(function _callee38$(_context38) {
+      while (1) {
+        switch (_context38.prev = _context38.next) {
+          case 0:
+            return _context38.abrupt("return", Get(urls.identity.sso.v2));
+
+          case 1:
+          case "end":
+            return _context38.stop();
+        }
+      }
+    }, _callee38);
+  }));
+  return _getSocialLoginProvidersV.apply(this, arguments);
+}
+
+export function loginViaSocialLogin(_x26) {
+  return _loginViaSocialLogin.apply(this, arguments);
+}
+
+function _loginViaSocialLogin() {
+  _loginViaSocialLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee39(_ref5) {
+    var provider, code, redirectUri, codeVerifier, metadata, invitationToken, state, params;
+    return _regeneratorRuntime.wrap(function _callee39$(_context39) {
+      while (1) {
+        switch (_context39.prev = _context39.next) {
+          case 0:
+            provider = _ref5.provider, code = _ref5.code, redirectUri = _ref5.redirectUri, codeVerifier = _ref5.codeVerifier, metadata = _ref5.metadata, invitationToken = _ref5.invitationToken, state = _ref5.state;
+            params = {
+              code: code
+            };
+
+            if (redirectUri) {
+              params.redirectUri = redirectUri;
+            }
+
+            if (codeVerifier) {
+              params.code_verifier = codeVerifier;
+            }
+
+            if (state) {
+              params.state = state;
+            }
+
+            return _context39.abrupt("return", Post("".concat(urls.identity.auth.v1, "/user/sso/").concat(provider, "/postlogin"), {
+              metadata: metadata,
+              invitationToken: invitationToken
+            }, {
+              params: params
+            }));
+
+          case 6:
+          case "end":
+            return _context39.stop();
+        }
+      }
+    }, _callee39);
+  }));
+  return _loginViaSocialLogin.apply(this, arguments);
+}
+
+export function getVendorConfig() {
+  return _getVendorConfig.apply(this, arguments);
+}
+
+function _getVendorConfig() {
+  _getVendorConfig = _asyncToGenerator(_regeneratorRuntime.mark(function _callee40() {
+    return _regeneratorRuntime.wrap(function _callee40$(_context40) {
+      while (1) {
+        switch (_context40.prev = _context40.next) {
+          case 0:
+            return _context40.abrupt("return", Get("".concat(urls.identity.configurations.v1, "/public")));
+
+          case 1:
+          case "end":
+            return _context40.stop();
+        }
+      }
+    }, _callee40);
+  }));
+  return _getVendorConfig.apply(this, arguments);
+}
+
+export function signUpUser(_x27) {
+  return _signUpUser.apply(this, arguments);
+}
+
+function _signUpUser() {
+  _signUpUser = _asyncToGenerator(_regeneratorRuntime.mark(function _callee41(body) {
+    var _yield$Post2, shouldActivate, authResponse, userId, tenantId, loginResponse;
+
+    return _regeneratorRuntime.wrap(function _callee41$(_context41) {
+      while (1) {
+        switch (_context41.prev = _context41.next) {
+          case 0:
+            _context41.next = 2;
+            return Post("".concat(urls.identity.users.v1, "/signUp"), body);
+
+          case 2:
+            _yield$Post2 = _context41.sent;
+            shouldActivate = _yield$Post2.shouldActivate;
+            authResponse = _yield$Post2.authResponse;
+            userId = _yield$Post2.userId;
+            tenantId = _yield$Post2.tenantId;
+
+            if (!(!shouldActivate && authResponse)) {
+              _context41.next = 13;
+              break;
+            }
+
+            _context41.next = 10;
+            return generateLoginResponse(authResponse);
+
+          case 10:
+            _context41.t0 = _context41.sent;
+            _context41.next = 14;
+            break;
+
+          case 13:
+            _context41.t0 = undefined;
+
+          case 14:
+            loginResponse = _context41.t0;
+            return _context41.abrupt("return", {
+              shouldActivate: shouldActivate,
+              user: loginResponse,
+              userId: userId,
+              tenantId: tenantId
+            });
+
+          case 16:
+          case "end":
+            return _context41.stop();
+        }
+      }
+    }, _callee41);
+  }));
+  return _signUpUser.apply(this, arguments);
+}
+
+export function getCurrentUserSessions() {
+  return _getCurrentUserSessions.apply(this, arguments);
+}
+
+function _getCurrentUserSessions() {
+  _getCurrentUserSessions = _asyncToGenerator(_regeneratorRuntime.mark(function _callee42() {
+    return _regeneratorRuntime.wrap(function _callee42$(_context42) {
+      while (1) {
+        switch (_context42.prev = _context42.next) {
+          case 0:
+            return _context42.abrupt("return", Get(urls.identity.users.sessions.currentUser.v1));
+
+          case 1:
+          case "end":
+            return _context42.stop();
+        }
+      }
+    }, _callee42);
+  }));
+  return _getCurrentUserSessions.apply(this, arguments);
+}
+
+export function getSessionConfigurations() {
+  return _getSessionConfigurations.apply(this, arguments);
+}
+
+function _getSessionConfigurations() {
+  _getSessionConfigurations = _asyncToGenerator(_regeneratorRuntime.mark(function _callee43() {
+    return _regeneratorRuntime.wrap(function _callee43$(_context43) {
+      while (1) {
+        switch (_context43.prev = _context43.next) {
+          case 0:
+            return _context43.abrupt("return", Get(urls.identity.users.sessions.configurations.v1));
+
+          case 1:
+          case "end":
+            return _context43.stop();
+        }
+      }
+    }, _callee43);
+  }));
+  return _getSessionConfigurations.apply(this, arguments);
+}
+
+export function createOrUpdateSessionConfigrations(_x28) {
+  return _createOrUpdateSessionConfigrations.apply(this, arguments);
+}
+
+function _createOrUpdateSessionConfigrations() {
+  _createOrUpdateSessionConfigrations = _asyncToGenerator(_regeneratorRuntime.mark(function _callee44(body) {
+    return _regeneratorRuntime.wrap(function _callee44$(_context44) {
+      while (1) {
+        switch (_context44.prev = _context44.next) {
+          case 0:
+            _context44.next = 2;
+            return Post(urls.identity.users.sessions.configurations.v1, body);
+
+          case 2:
+          case "end":
+            return _context44.stop();
+        }
+      }
+    }, _callee44);
+  }));
+  return _createOrUpdateSessionConfigrations.apply(this, arguments);
+}
+
+export function deleteSessionForUser(_x29) {
+  return _deleteSessionForUser.apply(this, arguments);
+}
+
+function _deleteSessionForUser() {
+  _deleteSessionForUser = _asyncToGenerator(_regeneratorRuntime.mark(function _callee45(id) {
+    return _regeneratorRuntime.wrap(function _callee45$(_context45) {
+      while (1) {
+        switch (_context45.prev = _context45.next) {
+          case 0:
+            _context45.next = 2;
+            return Delete("".concat(urls.identity.users.sessions.currentUser.v1, "/").concat(id));
+
+          case 2:
+          case "end":
+            return _context45.stop();
+        }
+      }
+    }, _callee45);
+  }));
+  return _deleteSessionForUser.apply(this, arguments);
+}
+
+export function deleteAllSessionsForUser() {
+  return _deleteAllSessionsForUser.apply(this, arguments);
+}
+
+function _deleteAllSessionsForUser() {
+  _deleteAllSessionsForUser = _asyncToGenerator(_regeneratorRuntime.mark(function _callee46() {
+    return _regeneratorRuntime.wrap(function _callee46$(_context46) {
+      while (1) {
+        switch (_context46.prev = _context46.next) {
+          case 0:
+            _context46.next = 2;
+            return Delete("".concat(urls.identity.users.sessions.currentUser.v1, "/all"));
+
+          case 2:
+          case "end":
+            return _context46.stop();
+        }
+      }
+    }, _callee46);
+  }));
+  return _deleteAllSessionsForUser.apply(this, arguments);
+}
+
+export function getUserApiTokensData() {
+  return _getUserApiTokensData.apply(this, arguments);
+}
+
+function _getUserApiTokensData() {
+  _getUserApiTokensData = _asyncToGenerator(_regeneratorRuntime.mark(function _callee47() {
+    return _regeneratorRuntime.wrap(function _callee47$(_context47) {
+      while (1) {
+        switch (_context47.prev = _context47.next) {
+          case 0:
+            return _context47.abrupt("return", Get(urls.identity.users.apiTokens.v1));
+
+          case 1:
+          case "end":
+            return _context47.stop();
+        }
+      }
+    }, _callee47);
+  }));
+  return _getUserApiTokensData.apply(this, arguments);
+}
+
+export function getTenantApiTokensData() {
+  return _getTenantApiTokensData.apply(this, arguments);
+}
+
+function _getTenantApiTokensData() {
+  _getTenantApiTokensData = _asyncToGenerator(_regeneratorRuntime.mark(function _callee48() {
+    return _regeneratorRuntime.wrap(function _callee48$(_context48) {
+      while (1) {
+        switch (_context48.prev = _context48.next) {
+          case 0:
+            return _context48.abrupt("return", Get(urls.identity.tenants.apiTokens.v1));
+
+          case 1:
+          case "end":
+            return _context48.stop();
+        }
+      }
+    }, _callee48);
+  }));
+  return _getTenantApiTokensData.apply(this, arguments);
+}
+
+export function updateUserApiTokensData(_x30) {
+  return _updateUserApiTokensData.apply(this, arguments);
+}
+
+function _updateUserApiTokensData() {
+  _updateUserApiTokensData = _asyncToGenerator(_regeneratorRuntime.mark(function _callee49(body) {
+    return _regeneratorRuntime.wrap(function _callee49$(_context49) {
+      while (1) {
+        switch (_context49.prev = _context49.next) {
+          case 0:
+            return _context49.abrupt("return", Post(urls.identity.users.apiTokens.v1, body));
+
+          case 1:
+          case "end":
+            return _context49.stop();
+        }
+      }
+    }, _callee49);
+  }));
+  return _updateUserApiTokensData.apply(this, arguments);
+}
+
+export function updateTenantApiTokensData(_x31) {
+  return _updateTenantApiTokensData.apply(this, arguments);
+}
+
+function _updateTenantApiTokensData() {
+  _updateTenantApiTokensData = _asyncToGenerator(_regeneratorRuntime.mark(function _callee50(body) {
+    return _regeneratorRuntime.wrap(function _callee50$(_context50) {
+      while (1) {
+        switch (_context50.prev = _context50.next) {
+          case 0:
+            return _context50.abrupt("return", Post(urls.identity.tenants.apiTokens.v2, body));
+
+          case 1:
+          case "end":
+            return _context50.stop();
+        }
+      }
+    }, _callee50);
+  }));
+  return _updateTenantApiTokensData.apply(this, arguments);
+}
+
+export function deleteTenantApiToken(_x32) {
+  return _deleteTenantApiToken.apply(this, arguments);
+}
+
+function _deleteTenantApiToken() {
+  _deleteTenantApiToken = _asyncToGenerator(_regeneratorRuntime.mark(function _callee51(_ref6) {
+    var tokenId;
+    return _regeneratorRuntime.wrap(function _callee51$(_context51) {
+      while (1) {
+        switch (_context51.prev = _context51.next) {
+          case 0:
+            tokenId = _ref6.tokenId;
+            return _context51.abrupt("return", Delete("".concat(urls.identity.tenants.apiTokens.v1, "/").concat(tokenId)));
+
+          case 2:
+          case "end":
+            return _context51.stop();
+        }
+      }
+    }, _callee51);
+  }));
+  return _deleteTenantApiToken.apply(this, arguments);
+}
+
+export function deleteUserApiToken(_x33) {
+  return _deleteUserApiToken.apply(this, arguments);
+}
+
+function _deleteUserApiToken() {
+  _deleteUserApiToken = _asyncToGenerator(_regeneratorRuntime.mark(function _callee52(_ref7) {
+    var tokenId;
+    return _regeneratorRuntime.wrap(function _callee52$(_context52) {
+      while (1) {
+        switch (_context52.prev = _context52.next) {
+          case 0:
+            tokenId = _ref7.tokenId;
+            return _context52.abrupt("return", Delete("".concat(urls.identity.users.apiTokens.v1, "/").concat(tokenId)));
+
+          case 2:
+          case "end":
+            return _context52.stop();
+        }
+      }
+    }, _callee52);
+  }));
+  return _deleteUserApiToken.apply(this, arguments);
+}
+
+export function getUserById(_x34) {
+  return _getUserById.apply(this, arguments);
+}
+
+function _getUserById() {
+  _getUserById = _asyncToGenerator(_regeneratorRuntime.mark(function _callee53(_ref8) {
+    var userId;
+    return _regeneratorRuntime.wrap(function _callee53$(_context53) {
+      while (1) {
+        switch (_context53.prev = _context53.next) {
+          case 0:
+            userId = _ref8.userId;
+            return _context53.abrupt("return", Get("".concat(urls.identity.users.v1, "/").concat(userId)));
+
+          case 2:
+          case "end":
+            return _context53.stop();
+        }
+      }
+    }, _callee53);
+  }));
+  return _getUserById.apply(this, arguments);
+}
+
+export function checkIfAllowToRememberMfaDevice(_x35) {
+  return _checkIfAllowToRememberMfaDevice.apply(this, arguments);
+}
+
+function _checkIfAllowToRememberMfaDevice() {
+  _checkIfAllowToRememberMfaDevice = _asyncToGenerator(_regeneratorRuntime.mark(function _callee54(mfaToken) {
+    return _regeneratorRuntime.wrap(function _callee54$(_context54) {
+      while (1) {
+        switch (_context54.prev = _context54.next) {
+          case 0:
+            return _context54.abrupt("return", Get("".concat(urls.identity.configurations.v1, "/mfa-policy/allow-remember-device"), {
+              mfaToken: mfaToken
+            }));
+
+          case 1:
+          case "end":
+            return _context54.stop();
+        }
+      }
+    }, _callee54);
+  }));
+  return _checkIfAllowToRememberMfaDevice.apply(this, arguments);
+}
+
+export function passwordlessPreLogin(_x36) {
+  return _passwordlessPreLogin.apply(this, arguments);
+}
+
+function _passwordlessPreLogin() {
+  _passwordlessPreLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee55(_ref9) {
+    var type, body;
+    return _regeneratorRuntime.wrap(function _callee55$(_context55) {
+      while (1) {
+        switch (_context55.prev = _context55.next) {
+          case 0:
+            type = _ref9.type, body = _objectWithoutProperties(_ref9, ["type"]);
+            return _context55.abrupt("return", Post("".concat(urls.identity.auth.v1, "/passwordless/").concat(type.toLocaleLowerCase(), "/prelogin"), body));
+
+          case 2:
+          case "end":
+            return _context55.stop();
+        }
+      }
+    }, _callee55);
+  }));
+  return _passwordlessPreLogin.apply(this, arguments);
+}
+
+export function passwordlessPostLogin(_x37) {
+  return _passwordlessPostLogin.apply(this, arguments);
+}
+
+function _passwordlessPostLogin() {
+  _passwordlessPostLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee56(_ref10) {
+    var type, body;
+    return _regeneratorRuntime.wrap(function _callee56$(_context56) {
+      while (1) {
+        switch (_context56.prev = _context56.next) {
+          case 0:
+            type = _ref10.type, body = _objectWithoutProperties(_ref10, ["type"]);
+            return _context56.abrupt("return", Post("".concat(urls.identity.auth.v1, "/passwordless/").concat(type.toLocaleLowerCase(), "/postlogin"), body));
+
+          case 2:
+          case "end":
+            return _context56.stop();
+        }
+      }
+    }, _callee56);
+  }));
+  return _passwordlessPostLogin.apply(this, arguments);
+}
+
+export function verifyInviteToken(_x38) {
+  return _verifyInviteToken.apply(this, arguments);
+}
+
+function _verifyInviteToken() {
+  _verifyInviteToken = _asyncToGenerator(_regeneratorRuntime.mark(function _callee57(_ref11) {
+    var token;
+    return _regeneratorRuntime.wrap(function _callee57$(_context57) {
+      while (1) {
+        switch (_context57.prev = _context57.next) {
+          case 0:
+            token = _ref11.token;
+            return _context57.abrupt("return", Post(urls.identity.tenants.invites.verify.v1, {
+              token: token
+            }));
+
+          case 2:
+          case "end":
+            return _context57.stop();
+        }
+      }
+    }, _callee57);
+  }));
+  return _verifyInviteToken.apply(this, arguments);
+}
+
+export function getSSOConfigurations() {
+  return _getSSOConfigurations.apply(this, arguments);
+}
+
+function _getSSOConfigurations() {
+  _getSSOConfigurations = _asyncToGenerator(_regeneratorRuntime.mark(function _callee58() {
+    return _regeneratorRuntime.wrap(function _callee58$(_context58) {
+      while (1) {
+        switch (_context58.prev = _context58.next) {
+          case 0:
+            return _context58.abrupt("return", Get("".concat(urls.team.sso.v1, "/configurations")));
+
+          case 1:
+          case "end":
+            return _context58.stop();
+        }
+      }
+    }, _callee58);
+  }));
+  return _getSSOConfigurations.apply(this, arguments);
+}
+
+export function createSSOConfiguration(_x39) {
+  return _createSSOConfiguration.apply(this, arguments);
+}
+
+function _createSSOConfiguration() {
+  _createSSOConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee59(body) {
+    return _regeneratorRuntime.wrap(function _callee59$(_context59) {
+      while (1) {
+        switch (_context59.prev = _context59.next) {
+          case 0:
+            return _context59.abrupt("return", Post("".concat(urls.team.sso.v1, "/configurations"), body));
+
+          case 1:
+          case "end":
+            return _context59.stop();
+        }
+      }
+    }, _callee59);
+  }));
+  return _createSSOConfiguration.apply(this, arguments);
+}
+
+export function updateSSOConfiguration(_x40, _x41) {
+  return _updateSSOConfiguration.apply(this, arguments);
+}
+
+function _updateSSOConfiguration() {
+  _updateSSOConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee60(ssoConfigId, body) {
+    return _regeneratorRuntime.wrap(function _callee60$(_context60) {
+      while (1) {
+        switch (_context60.prev = _context60.next) {
+          case 0:
+            return _context60.abrupt("return", Patch("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId), body));
+
+          case 1:
+          case "end":
+            return _context60.stop();
+        }
+      }
+    }, _callee60);
+  }));
+  return _updateSSOConfiguration.apply(this, arguments);
+}
+
+export function deleteSSOConfiguration(_x42) {
+  return _deleteSSOConfiguration.apply(this, arguments);
+}
+
+function _deleteSSOConfiguration() {
+  _deleteSSOConfiguration = _asyncToGenerator(_regeneratorRuntime.mark(function _callee61(ssoConfigId) {
+    return _regeneratorRuntime.wrap(function _callee61$(_context61) {
+      while (1) {
+        switch (_context61.prev = _context61.next) {
+          case 0:
+            return _context61.abrupt("return", Delete("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId)));
+
+          case 1:
+          case "end":
+            return _context61.stop();
+        }
+      }
+    }, _callee61);
+  }));
+  return _deleteSSOConfiguration.apply(this, arguments);
+}
+
+export function createSSOConfigurationByMetadata(_x43) {
+  return _createSSOConfigurationByMetadata.apply(this, arguments);
+}
+
+function _createSSOConfigurationByMetadata() {
+  _createSSOConfigurationByMetadata = _asyncToGenerator(_regeneratorRuntime.mark(function _callee62(body) {
+    return _regeneratorRuntime.wrap(function _callee62$(_context62) {
+      while (1) {
+        switch (_context62.prev = _context62.next) {
+          case 0:
+            return _context62.abrupt("return", Post("".concat(urls.team.sso.v1, "/configurations/metadata"), body));
+
+          case 1:
+          case "end":
+            return _context62.stop();
+        }
+      }
+    }, _callee62);
+  }));
+  return _createSSOConfigurationByMetadata.apply(this, arguments);
+}
+
+export function updateSSOConfigurationByMetadata(_x44, _x45) {
+  return _updateSSOConfigurationByMetadata.apply(this, arguments);
+}
+
+function _updateSSOConfigurationByMetadata() {
+  _updateSSOConfigurationByMetadata = _asyncToGenerator(_regeneratorRuntime.mark(function _callee63(ssoConfigId, body) {
+    return _regeneratorRuntime.wrap(function _callee63$(_context63) {
+      while (1) {
+        switch (_context63.prev = _context63.next) {
+          case 0:
+            return _context63.abrupt("return", Put("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/metadata"), body));
+
+          case 1:
+          case "end":
+            return _context63.stop();
+        }
+      }
+    }, _callee63);
+  }));
+  return _updateSSOConfigurationByMetadata.apply(this, arguments);
+}
+
+export function createSSODomain(_x46, _x47) {
+  return _createSSODomain.apply(this, arguments);
+}
+
+function _createSSODomain() {
+  _createSSODomain = _asyncToGenerator(_regeneratorRuntime.mark(function _callee64(ssoConfigId, body) {
+    return _regeneratorRuntime.wrap(function _callee64$(_context64) {
+      while (1) {
+        switch (_context64.prev = _context64.next) {
+          case 0:
+            return _context64.abrupt("return", Post("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/domains"), body));
+
+          case 1:
+          case "end":
+            return _context64.stop();
+        }
+      }
+    }, _callee64);
+  }));
+  return _createSSODomain.apply(this, arguments);
+}
+
+export function deleteSSODomain(_x48, _x49) {
+  return _deleteSSODomain.apply(this, arguments);
+}
+
+function _deleteSSODomain() {
+  _deleteSSODomain = _asyncToGenerator(_regeneratorRuntime.mark(function _callee65(ssoConfigId, domainId) {
+    return _regeneratorRuntime.wrap(function _callee65$(_context65) {
+      while (1) {
+        switch (_context65.prev = _context65.next) {
+          case 0:
+            return _context65.abrupt("return", Delete("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/domains/").concat(domainId)));
+
+          case 1:
+          case "end":
+            return _context65.stop();
+        }
+      }
+    }, _callee65);
+  }));
+  return _deleteSSODomain.apply(this, arguments);
+}
+
+export function validateSSODomain(_x50, _x51) {
+  return _validateSSODomain.apply(this, arguments);
+}
+
+function _validateSSODomain() {
+  _validateSSODomain = _asyncToGenerator(_regeneratorRuntime.mark(function _callee66(ssoConfigId, domainId) {
+    return _regeneratorRuntime.wrap(function _callee66$(_context66) {
+      while (1) {
+        switch (_context66.prev = _context66.next) {
+          case 0:
+            return _context66.abrupt("return", Put("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/domains/").concat(domainId, "/validate")));
+
+          case 1:
+          case "end":
+            return _context66.stop();
+        }
+      }
+    }, _callee66);
+  }));
+  return _validateSSODomain.apply(this, arguments);
+}
+
+export function getSSODefaultRoles(_x52) {
+  return _getSSODefaultRoles.apply(this, arguments);
+}
+
+function _getSSODefaultRoles() {
+  _getSSODefaultRoles = _asyncToGenerator(_regeneratorRuntime.mark(function _callee67(ssoConfigId) {
+    return _regeneratorRuntime.wrap(function _callee67$(_context67) {
+      while (1) {
+        switch (_context67.prev = _context67.next) {
+          case 0:
+            return _context67.abrupt("return", Get("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/roles")));
+
+          case 1:
+          case "end":
+            return _context67.stop();
+        }
+      }
+    }, _callee67);
+  }));
+  return _getSSODefaultRoles.apply(this, arguments);
+}
+
+export function setSSODefaultRoles(_x53, _x54) {
+  return _setSSODefaultRoles.apply(this, arguments);
+}
+
+function _setSSODefaultRoles() {
+  _setSSODefaultRoles = _asyncToGenerator(_regeneratorRuntime.mark(function _callee68(ssoConfigId, body) {
+    return _regeneratorRuntime.wrap(function _callee68$(_context68) {
+      while (1) {
+        switch (_context68.prev = _context68.next) {
+          case 0:
+            return _context68.abrupt("return", Put("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/roles"), body));
+
+          case 1:
+          case "end":
+            return _context68.stop();
+        }
+      }
+    }, _callee68);
+  }));
+  return _setSSODefaultRoles.apply(this, arguments);
+}
+
+export function createSSOGroup(_x55, _x56) {
+  return _createSSOGroup.apply(this, arguments);
+}
+
+function _createSSOGroup() {
+  _createSSOGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee69(ssoConfigId, body) {
+    return _regeneratorRuntime.wrap(function _callee69$(_context69) {
+      while (1) {
+        switch (_context69.prev = _context69.next) {
+          case 0:
+            return _context69.abrupt("return", Post("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/groups"), body));
+
+          case 1:
+          case "end":
+            return _context69.stop();
+        }
+      }
+    }, _callee69);
+  }));
+  return _createSSOGroup.apply(this, arguments);
+}
+
+export function updateSSOGroup(_x57, _x58) {
+  return _updateSSOGroup.apply(this, arguments);
+}
+
+function _updateSSOGroup() {
+  _updateSSOGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee70(ssoConfigId, _ref12) {
+    var roleIds, group, id;
+    return _regeneratorRuntime.wrap(function _callee70$(_context70) {
+      while (1) {
+        switch (_context70.prev = _context70.next) {
+          case 0:
+            roleIds = _ref12.roleIds, group = _ref12.group, id = _ref12.id;
+            return _context70.abrupt("return", Patch("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/groups/").concat(id), {
+              group: group,
+              roleIds: roleIds
+            }));
+
+          case 2:
+          case "end":
+            return _context70.stop();
+        }
+      }
+    }, _callee70);
+  }));
+  return _updateSSOGroup.apply(this, arguments);
+}
+
+export function deleteSSOGroup(_x59, _x60) {
+  return _deleteSSOGroup.apply(this, arguments);
+}
+
+function _deleteSSOGroup() {
+  _deleteSSOGroup = _asyncToGenerator(_regeneratorRuntime.mark(function _callee71(ssoConfigId, groupId) {
+    return _regeneratorRuntime.wrap(function _callee71$(_context71) {
+      while (1) {
+        switch (_context71.prev = _context71.next) {
+          case 0:
+            return _context71.abrupt("return", Delete("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/groups/").concat(groupId)));
+
+          case 1:
+          case "end":
+            return _context71.stop();
+        }
+      }
+    }, _callee71);
+  }));
+  return _deleteSSOGroup.apply(this, arguments);
+}
+
+export function getSSOGroups(_x61) {
+  return _getSSOGroups.apply(this, arguments);
+}
+
+function _getSSOGroups() {
+  _getSSOGroups = _asyncToGenerator(_regeneratorRuntime.mark(function _callee72(ssoConfigId) {
+    return _regeneratorRuntime.wrap(function _callee72$(_context72) {
+      while (1) {
+        switch (_context72.prev = _context72.next) {
+          case 0:
+            return _context72.abrupt("return", Get("".concat(urls.team.sso.v1, "/configurations/").concat(ssoConfigId, "/groups")));
+
+          case 1:
+          case "end":
+            return _context72.stop();
+        }
+      }
+    }, _callee72);
+  }));
+  return _getSSOGroups.apply(this, arguments);
+}
+
+export function preLoginV2(_x62) {
+  return _preLoginV.apply(this, arguments);
+}
+
+function _preLoginV() {
+  _preLoginV = _asyncToGenerator(_regeneratorRuntime.mark(function _callee73(body) {
+    return _regeneratorRuntime.wrap(function _callee73$(_context73) {
+      while (1) {
+        switch (_context73.prev = _context73.next) {
+          case 0:
+            return _context73.abrupt("return", Post("".concat(urls.identity.auth.v2, "/user/sso/prelogin"), body));
+
+          case 1:
+          case "end":
+            return _context73.stop();
+        }
+      }
+    }, _callee73);
+  }));
+  return _preLoginV.apply(this, arguments);
+}
+
+export function oidcPostLoginV2(_x63) {
+  return _oidcPostLoginV.apply(this, arguments);
+}
+
+function _oidcPostLoginV() {
+  _oidcPostLoginV = _asyncToGenerator(_regeneratorRuntime.mark(function _callee74(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee74$(_context74) {
+      while (1) {
+        switch (_context74.prev = _context74.next) {
+          case 0:
+            _context74.next = 2;
+            return Post("".concat(urls.identity.auth.v2, "/user/oidc/postlogin"), body);
+
+          case 2:
+            data = _context74.sent;
+            return _context74.abrupt("return", generateLoginResponse(data));
+
+          case 4:
+          case "end":
+            return _context74.stop();
+        }
+      }
+    }, _callee74);
+  }));
+  return _oidcPostLoginV.apply(this, arguments);
+}
+
+export function exchangeOAuthTokens(_x64) {
+  return _exchangeOAuthTokens.apply(this, arguments);
+}
+
+function _exchangeOAuthTokens() {
+  _exchangeOAuthTokens = _asyncToGenerator(_regeneratorRuntime.mark(function _callee75(body) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee75$(_context75) {
+      while (1) {
+        switch (_context75.prev = _context75.next) {
+          case 0:
+            _context75.next = 2;
+            return Post("".concat(urls.oauth.v1, "/token"), body);
+
+          case 2:
+            data = _context75.sent;
+            return _context75.abrupt("return", generateLoginResponseFromOAuthResponse(data));
+
+          case 4:
+          case "end":
+            return _context75.stop();
+        }
+      }
+    }, _callee75);
+  }));
+  return _exchangeOAuthTokens.apply(this, arguments);
+}
+
+export function resetPhoneNumber(_x65) {
+  return _resetPhoneNumber.apply(this, arguments);
+}
+
+function _resetPhoneNumber() {
+  _resetPhoneNumber = _asyncToGenerator(_regeneratorRuntime.mark(function _callee76(body) {
+    return _regeneratorRuntime.wrap(function _callee76$(_context76) {
+      while (1) {
+        switch (_context76.prev = _context76.next) {
+          case 0:
+            return _context76.abrupt("return", Post("".concat(urls.identity.users.v1, "/phone/reset"), body));
+
+          case 1:
+          case "end":
+            return _context76.stop();
+        }
+      }
+    }, _callee76);
+  }));
+  return _resetPhoneNumber.apply(this, arguments);
+}
+
+export function verifyResetPhoneNumber(_x66) {
+  return _verifyResetPhoneNumber.apply(this, arguments);
+}
+
+function _verifyResetPhoneNumber() {
+  _verifyResetPhoneNumber = _asyncToGenerator(_regeneratorRuntime.mark(function _callee77(body) {
+    return _regeneratorRuntime.wrap(function _callee77$(_context77) {
+      while (1) {
+        switch (_context77.prev = _context77.next) {
+          case 0:
+            return _context77.abrupt("return", Post("".concat(urls.identity.users.v1, "/phone/reset/verify"), body));
+
+          case 1:
+          case "end":
+            return _context77.stop();
+        }
+      }
+    }, _callee77);
+  }));
+  return _verifyResetPhoneNumber.apply(this, arguments);
+}
+
+export function changePhoneNumberWithVerification(_x67) {
+  return _changePhoneNumberWithVerification.apply(this, arguments);
+}
+
+function _changePhoneNumberWithVerification() {
+  _changePhoneNumberWithVerification = _asyncToGenerator(_regeneratorRuntime.mark(function _callee78(body) {
+    return _regeneratorRuntime.wrap(function _callee78$(_context78) {
+      while (1) {
+        switch (_context78.prev = _context78.next) {
+          case 0:
+            return _context78.abrupt("return", Post("".concat(urls.identity.users.v1, "/phone"), body));
+
+          case 1:
+          case "end":
+            return _context78.stop();
+        }
+      }
+    }, _callee78);
+  }));
+  return _changePhoneNumberWithVerification.apply(this, arguments);
+}
+
+export function verifyChangePhoneNumber(_x68) {
+  return _verifyChangePhoneNumber.apply(this, arguments);
+}
+
+function _verifyChangePhoneNumber() {
+  _verifyChangePhoneNumber = _asyncToGenerator(_regeneratorRuntime.mark(function _callee79(body) {
+    return _regeneratorRuntime.wrap(function _callee79$(_context79) {
+      while (1) {
+        switch (_context79.prev = _context79.next) {
+          case 0:
+            return _context79.abrupt("return", Post("".concat(urls.identity.users.v1, "/phone/verify"), body));
+
+          case 1:
+          case "end":
+            return _context79.stop();
+        }
+      }
+    }, _callee79);
+  }));
+  return _verifyChangePhoneNumber.apply(this, arguments);
+}
+
+export function changePhoneNumber(_x69) {
+  return _changePhoneNumber.apply(this, arguments);
+}
+
+function _changePhoneNumber() {
+  _changePhoneNumber = _asyncToGenerator(_regeneratorRuntime.mark(function _callee80(body) {
+    return _regeneratorRuntime.wrap(function _callee80$(_context80) {
+      while (1) {
+        switch (_context80.prev = _context80.next) {
+          case 0:
+            return _context80.abrupt("return", Put("".concat(urls.identity.users.v1, "/phone/change"), body));
+
+          case 1:
+          case "end":
+            return _context80.stop();
+        }
+      }
+    }, _callee80);
+  }));
+  return _changePhoneNumber.apply(this, arguments);
+}
+
+export function webAuthnPreLogin(_x70) {
+  return _webAuthnPreLogin.apply(this, arguments);
+}
+
+function _webAuthnPreLogin() {
+  _webAuthnPreLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee81(body) {
+    return _regeneratorRuntime.wrap(function _callee81$(_context81) {
+      while (1) {
+        switch (_context81.prev = _context81.next) {
+          case 0:
+            return _context81.abrupt("return", Post("".concat(urls.identity.auth.v1, "/webauthn/prelogin"), body));
+
+          case 1:
+          case "end":
+            return _context81.stop();
+        }
+      }
+    }, _callee81);
+  }));
+  return _webAuthnPreLogin.apply(this, arguments);
+}
+
+export function webAuthnPostLogin(_x71) {
+  return _webAuthnPostLogin.apply(this, arguments);
+}
+
+function _webAuthnPostLogin() {
+  _webAuthnPostLogin = _asyncToGenerator(_regeneratorRuntime.mark(function _callee82(body) {
+    return _regeneratorRuntime.wrap(function _callee82$(_context82) {
+      while (1) {
+        switch (_context82.prev = _context82.next) {
+          case 0:
+            return _context82.abrupt("return", Post("".concat(urls.identity.auth.v1, "/webauthn/postlogin"), body));
+
+          case 1:
+          case "end":
+            return _context82.stop();
+        }
+      }
+    }, _callee82);
+  }));
+  return _webAuthnPostLogin.apply(this, arguments);
+}
+
+export function webAuthnCreateNewDeviceSession() {
+  return _webAuthnCreateNewDeviceSession.apply(this, arguments);
+}
+
+function _webAuthnCreateNewDeviceSession() {
+  _webAuthnCreateNewDeviceSession = _asyncToGenerator(_regeneratorRuntime.mark(function _callee83() {
+    return _regeneratorRuntime.wrap(function _callee83$(_context83) {
+      while (1) {
+        switch (_context83.prev = _context83.next) {
+          case 0:
+            return _context83.abrupt("return", Post(urls.identity.webAuthnDevices.v1));
+
+          case 1:
+          case "end":
+            return _context83.stop();
+        }
+      }
+    }, _callee83);
+  }));
+  return _webAuthnCreateNewDeviceSession.apply(this, arguments);
+}
+
+export function verifyNewDeviceSession(_x72) {
+  return _verifyNewDeviceSession.apply(this, arguments);
+}
+
+function _verifyNewDeviceSession() {
+  _verifyNewDeviceSession = _asyncToGenerator(_regeneratorRuntime.mark(function _callee84(body) {
+    return _regeneratorRuntime.wrap(function _callee84$(_context84) {
+      while (1) {
+        switch (_context84.prev = _context84.next) {
+          case 0:
+            return _context84.abrupt("return", Post("".concat(urls.identity.webAuthnDevices.v1, "/verify"), body));
+
+          case 1:
+          case "end":
+            return _context84.stop();
+        }
+      }
+    }, _callee84);
+  }));
+  return _verifyNewDeviceSession.apply(this, arguments);
+}
+
+export function getVendorPublicAuthStrategiesConfig() {
+  return _getVendorPublicAuthStrategiesConfig.apply(this, arguments);
+}
+
+function _getVendorPublicAuthStrategiesConfig() {
+  _getVendorPublicAuthStrategiesConfig = _asyncToGenerator(_regeneratorRuntime.mark(function _callee85() {
+    return _regeneratorRuntime.wrap(function _callee85$(_context85) {
+      while (1) {
+        switch (_context85.prev = _context85.next) {
+          case 0:
+            return _context85.abrupt("return", Get("".concat(urls.identity.configurations.v1, "/auth/strategies/public")));
+
+          case 1:
+          case "end":
+            return _context85.stop();
+        }
+      }
+    }, _callee85);
+  }));
+  return _getVendorPublicAuthStrategiesConfig.apply(this, arguments);
+}
+
+;