@frontegg/rest-api 2.10.90 → 3.0.3

package/node/auth/index.js

@@ -0,0 +1,709 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  generateLoginResponse: true,
+  generateLoginResponseV2: true,
+  generateLoginResponseFromOAuthResponse: true,
+  preLogin: true,
+  preLoginWithIdpType: true,
+  postLogin: true,
+  oidcPostLogin: true,
+  login: true,
+  loginWithMfa: true,
+  activateAccount: true,
+  getActivateAccountStrategy: true,
+  resendActivationEmail: true,
+  acceptInvitation: true,
+  refreshToken: true,
+  refreshTokenV2: true,
+  logout: true,
+  forgotPassword: true,
+  resetPassword: true,
+  loadPasswordConfig: true,
+  recoverMfaToken: true,
+  enrollMfa: true,
+  verifyMfa: true,
+  disableMfa: 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,
+  loginViaSocialLogin: true,
+  getVendorConfig: true,
+  signUpUser: true,
+  getCurrentUserSessions: true,
+  getSessionConfigurations: true,
+  createOrUpdateSessionConfigrations: true,
+  deleteSessionForUser: true,
+  deleteAllSessionsForUser: true,
+  getUserApiTokensData: true,
+  getTenantApiTokensData: true,
+  updateUserApiTokensData: true,
+  updateTenantApiTokensData: true,
+  deleteTenantApiToken: true,
+  deleteUserApiToken: true,
+  getUserById: true,
+  checkIfAllowToRememberMfaDevice: true,
+  passwordlessPreLogin: true,
+  passwordlessPostLogin: true,
+  verifyInviteToken: true,
+  getSSOConfigurations: true,
+  createSSOConfiguration: true,
+  updateSSOConfiguration: true,
+  deleteSSOConfiguration: true,
+  createSSOConfigurationByMetadata: true,
+  updateSSOConfigurationByMetadata: true,
+  createSSODomain: true,
+  deleteSSODomain: true,
+  validateSSODomain: true,
+  getSSODefaultRoles: true,
+  setSSODefaultRoles: true,
+  createSSOGroup: true,
+  updateSSOGroup: true,
+  deleteSSOGroup: true,
+  getSSOGroups: true,
+  preLoginV2: true,
+  oidcPostLoginV2: true,
+  exchangeOAuthTokens: true,
+  resetPhoneNumber: true,
+  verifyResetPhoneNumber: true,
+  changePhoneNumberWithVerification: true,
+  verifyChangePhoneNumber: true,
+  changePhoneNumber: true,
+  webAuthnPreLogin: true,
+  webAuthnPostLogin: true,
+  webAuthnCreateNewDeviceSession: true,
+  verifyNewDeviceSession: true,
+  getVendorPublicAuthStrategiesConfig: true
+};
+exports.acceptInvitation = acceptInvitation;
+exports.activateAccount = activateAccount;
+exports.changePhoneNumber = changePhoneNumber;
+exports.changePhoneNumberWithVerification = changePhoneNumberWithVerification;
+exports.checkIfAllowToRememberMfaDevice = checkIfAllowToRememberMfaDevice;
+exports.createOrUpdateSessionConfigrations = createOrUpdateSessionConfigrations;
+exports.createSSOConfiguration = createSSOConfiguration;
+exports.createSSOConfigurationByMetadata = createSSOConfigurationByMetadata;
+exports.createSSODomain = createSSODomain;
+exports.createSSOGroup = createSSOGroup;
+exports.createSamlGroup = createSamlGroup;
+exports.deleteAllSessionsForUser = deleteAllSessionsForUser;
+exports.deleteSSOConfiguration = deleteSSOConfiguration;
+exports.deleteSSODomain = deleteSSODomain;
+exports.deleteSSOGroup = deleteSSOGroup;
+exports.deleteSamlGroup = deleteSamlGroup;
+exports.deleteSessionForUser = deleteSessionForUser;
+exports.deleteTenantApiToken = deleteTenantApiToken;
+exports.deleteUserApiToken = deleteUserApiToken;
+exports.disableMfa = disableMfa;
+exports.enrollMfa = enrollMfa;
+exports.exchangeOAuthTokens = exchangeOAuthTokens;
+exports.forgotPassword = forgotPassword;
+exports.generateLoginResponse = generateLoginResponse;
+exports.generateLoginResponseFromOAuthResponse = generateLoginResponseFromOAuthResponse;
+exports.generateLoginResponseV2 = generateLoginResponseV2;
+exports.getActivateAccountStrategy = getActivateAccountStrategy;
+exports.getCurrentUserSessions = getCurrentUserSessions;
+exports.getOidcConfiguration = getOidcConfiguration;
+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.getTenantApiTokensData = getTenantApiTokensData;
+exports.getUserApiTokensData = getUserApiTokensData;
+exports.getUserById = getUserById;
+exports.getVendorConfig = getVendorConfig;
+exports.getVendorPublicAuthStrategiesConfig = getVendorPublicAuthStrategiesConfig;
+exports.loadPasswordConfig = loadPasswordConfig;
+exports.login = login;
+exports.loginViaSocialLogin = loginViaSocialLogin;
+exports.loginWithMfa = loginWithMfa;
+exports.logout = logout;
+exports.oidcPostLogin = oidcPostLogin;
+exports.oidcPostLoginV2 = oidcPostLoginV2;
+exports.passwordlessPostLogin = passwordlessPostLogin;
+exports.passwordlessPreLogin = passwordlessPreLogin;
+exports.postLogin = postLogin;
+exports.preLogin = preLogin;
+exports.preLoginV2 = preLoginV2;
+exports.preLoginWithIdpType = preLoginWithIdpType;
+exports.recoverMfaToken = recoverMfaToken;
+exports.refreshToken = refreshToken;
+exports.refreshTokenV2 = refreshTokenV2;
+exports.resendActivationEmail = resendActivationEmail;
+exports.resetPassword = resetPassword;
+exports.resetPhoneNumber = resetPhoneNumber;
+exports.setSSODefaultRoles = setSSODefaultRoles;
+exports.signUpUser = signUpUser;
+exports.updateSSOConfiguration = updateSSOConfiguration;
+exports.updateSSOConfigurationByMetadata = updateSSOConfigurationByMetadata;
+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.validateSamlDomain = validateSamlDomain;
+exports.verifyChangePhoneNumber = verifyChangePhoneNumber;
+exports.verifyInviteToken = verifyInviteToken;
+exports.verifyMfa = verifyMfa;
+exports.verifyNewDeviceSession = verifyNewDeviceSession;
+exports.verifyResetPhoneNumber = verifyResetPhoneNumber;
+exports.webAuthnCreateNewDeviceSession = webAuthnCreateNewDeviceSession;
+exports.webAuthnPostLogin = webAuthnPostLogin;
+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) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _secutiryPoilicy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _secutiryPoilicy[key];
+    }
+  });
+});
+
+var _enums = require("./enums");
+
+Object.keys(_enums).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _enums[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _enums[key];
+    }
+  });
+});
+
+var _constants = require("../constants");
+
+var _ContextHolder = require("../ContextHolder");
+
+var _fetch = require("../fetch");
+
+var _jwt = require("../jwt");
+
+const _excluded = ["type"],
+      _excluded2 = ["type"];
+
+async function generateLoginResponse(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return loginResponse;
+  }
+
+  _ContextHolder.ContextHolder.setAccessToken(loginResponse.accessToken);
+
+  const me = await (0, _fetch.Get)(`${_constants.urls.identity.users.v2}/me`);
+  const decodedContent = loginResponse.accessToken ? (0, _jwt.jwtDecode)(loginResponse.accessToken) : {};
+  const user = (0, _extends2.default)({}, loginResponse, decodedContent, me);
+
+  _ContextHolder.ContextHolder.setUser(user);
+
+  return user;
+}
+
+async function generateLoginResponseV2(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return {
+      user: loginResponse
+    };
+  }
+
+  _ContextHolder.ContextHolder.setAccessToken(loginResponse.accessToken);
+
+  const [me, tenants] = await Promise.all([(0, _fetch.Get)(`${_constants.urls.identity.users.v2}/me`), (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
+  };
+}
+
+async function generateLoginResponseFromOAuthResponse(oauthResponse) {
+  _ContextHolder.ContextHolder.setAccessToken(oauthResponse.id_token);
+
+  const me = await (0, _fetch.Get)(`${_constants.urls.identity.users.v2}/me`);
+  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);
+
+  _ContextHolder.ContextHolder.setUser(user);
+
+  return user;
+}
+
+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;
+  }
+}
+
+async function preLoginWithIdpType(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/saml/prelogin`, body);
+}
+
+async function postLogin(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/saml/postlogin`, body);
+  return generateLoginResponse(data);
+}
+
+async function oidcPostLogin(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+
+async function login(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user`, body);
+  return generateLoginResponse(data);
+}
+
+async function loginWithMfa(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/mfa/verify`, body);
+  return generateLoginResponse(data);
+}
+
+async function activateAccount(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/activate`, body);
+}
+
+async function getActivateAccountStrategy(params) {
+  return (0, _fetch.Get)(`${_constants.urls.identity.users.v1}/activate/strategy`, params);
+}
+
+async function resendActivationEmail(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/activate/reset`, body);
+}
+
+async function acceptInvitation(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/invitation/accept`, body);
+}
+
+async function refreshToken() {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/token/refresh`);
+  return generateLoginResponse(data);
+}
+
+async function refreshTokenV2() {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/token/refresh`);
+  return generateLoginResponseV2(data);
+}
+
+async function logout() {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/logout`);
+}
+
+async function forgotPassword(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/passwords/reset`, body);
+}
+
+async function resetPassword(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/passwords/reset/verify`, body);
+}
+
+async function loadPasswordConfig(params) {
+  return (0, _fetch.Get)(`${_constants.urls.identity.users.v1}/passwords/config`, params);
+}
+
+async function recoverMfaToken(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/mfa/recover`, body);
+}
+
+async function enrollMfa() {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/mfa/enroll`);
+}
+
+async function verifyMfa(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/mfa/enroll/verify`, body);
+}
+
+async function disableMfa(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/mfa/disable`, body);
+}
+
+async function getSamlConfiguration() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/saml/configurations`);
+}
+
+async function updateSamlConfiguration(body) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/saml/configurations`, body);
+}
+
+async function getSamlVendorConfiguration() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/saml/configurations/vendor-config`);
+}
+
+async function updateSamlVendorMetadata(body) {
+  return (0, _fetch.Put)(`${_constants.urls.team.sso.v1}/saml/configurations/metadata`, body);
+}
+
+async function validateSamlDomain() {
+  return (0, _fetch.Put)(`${_constants.urls.team.sso.v1}/saml/validations/domain`);
+}
+
+async function getSamlRoles() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/saml/configurations/roles/default`);
+}
+
+async function getSamlRolesGroups() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v2}/saml/configurations/groups`);
+}
+
+async function updateSamlRoles({
+  roleIds
+}) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/saml/configurations/roles/default`, {
+    roleIds
+  });
+}
+
+async function createSamlGroup({
+  roleIds,
+  group
+}) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v2}/saml/configurations/groups`, {
+    group,
+    roleIds
+  });
+}
+
+async function updateSamlGroup({
+  roleIds,
+  group,
+  id
+}) {
+  return (0, _fetch.Patch)(`${_constants.urls.team.sso.v2}/saml/configurations/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+
+async function deleteSamlGroup({
+  id
+}) {
+  return (0, _fetch.Delete)(`${_constants.urls.team.sso.v2}/saml/configurations/groups/${id}`);
+}
+
+async function getOidcConfiguration() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/oidc/configurations`);
+}
+
+async function getSSOPublicConfiguration() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v2}/configurations/public`);
+}
+
+async function getSocialLoginProviders() {
+  return (0, _fetch.Get)(_constants.urls.identity.sso.v1);
+}
+
+async function getSocialLoginProvidersV2() {
+  return (0, _fetch.Get)(_constants.urls.identity.sso.v2);
+}
+
+async function loginViaSocialLogin({
+  provider,
+  code,
+  redirectUri,
+  codeVerifier,
+  metadata,
+  invitationToken,
+  state
+}) {
+  const params = {
+    code
+  };
+
+  if (redirectUri) {
+    params.redirectUri = redirectUri;
+  }
+
+  if (codeVerifier) {
+    params.code_verifier = codeVerifier;
+  }
+
+  if (state) {
+    params.state = state;
+  }
+
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/user/sso/${provider}/postlogin`, {
+    metadata,
+    invitationToken
+  }, {
+    params
+  });
+}
+
+async function getVendorConfig() {
+  return (0, _fetch.Get)(`${_constants.urls.identity.configurations.v1}/public`);
+}
+
+async function signUpUser(body) {
+  const {
+    shouldActivate,
+    authResponse,
+    userId,
+    tenantId
+  } = await (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/signUp`, body);
+  const loginResponse = !shouldActivate && authResponse ? await generateLoginResponse(authResponse) : undefined;
+  return {
+    shouldActivate,
+    user: loginResponse,
+    userId,
+    tenantId
+  };
+}
+
+async function getCurrentUserSessions() {
+  return (0, _fetch.Get)(_constants.urls.identity.users.sessions.currentUser.v1);
+}
+
+async function getSessionConfigurations() {
+  return (0, _fetch.Get)(_constants.urls.identity.users.sessions.configurations.v1);
+}
+
+async function createOrUpdateSessionConfigrations(body) {
+  await (0, _fetch.Post)(_constants.urls.identity.users.sessions.configurations.v1, body);
+}
+
+async function deleteSessionForUser(id) {
+  await (0, _fetch.Delete)(`${_constants.urls.identity.users.sessions.currentUser.v1}/${id}`);
+}
+
+async function deleteAllSessionsForUser() {
+  await (0, _fetch.Delete)(`${_constants.urls.identity.users.sessions.currentUser.v1}/all`);
+}
+
+async function getUserApiTokensData() {
+  return (0, _fetch.Get)(_constants.urls.identity.users.apiTokens.v1);
+}
+
+async function getTenantApiTokensData() {
+  return (0, _fetch.Get)(_constants.urls.identity.tenants.apiTokens.v1);
+}
+
+async function updateUserApiTokensData(body) {
+  return (0, _fetch.Post)(_constants.urls.identity.users.apiTokens.v1, body);
+}
+
+async function updateTenantApiTokensData(body) {
+  return (0, _fetch.Post)(_constants.urls.identity.tenants.apiTokens.v2, body);
+}
+
+async function deleteTenantApiToken({
+  tokenId
+}) {
+  return (0, _fetch.Delete)(`${_constants.urls.identity.tenants.apiTokens.v1}/${tokenId}`);
+}
+
+async function deleteUserApiToken({
+  tokenId
+}) {
+  return (0, _fetch.Delete)(`${_constants.urls.identity.users.apiTokens.v1}/${tokenId}`);
+}
+
+async function getUserById({
+  userId
+}) {
+  return (0, _fetch.Get)(`${_constants.urls.identity.users.v1}/${userId}`);
+}
+
+async function checkIfAllowToRememberMfaDevice(mfaToken) {
+  return (0, _fetch.Get)(`${_constants.urls.identity.configurations.v1}/mfa-policy/allow-remember-device`, {
+    mfaToken
+  });
+}
+
+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);
+}
+
+async function passwordlessPostLogin(_ref2) {
+  let {
+    type
+  } = _ref2,
+      body = (0, _objectWithoutPropertiesLoose2.default)(_ref2, _excluded2);
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
+}
+
+async function verifyInviteToken({
+  token
+}) {
+  return (0, _fetch.Post)(_constants.urls.identity.tenants.invites.verify.v1, {
+    token
+  });
+}
+
+async function getSSOConfigurations() {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/configurations`);
+}
+
+async function createSSOConfiguration(body) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/configurations`, body);
+}
+
+async function updateSSOConfiguration(ssoConfigId, body) {
+  return (0, _fetch.Patch)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}`, body);
+}
+
+async function deleteSSOConfiguration(ssoConfigId) {
+  return (0, _fetch.Delete)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}`);
+}
+
+async function createSSOConfigurationByMetadata(body) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/configurations/metadata`, body);
+}
+
+async function updateSSOConfigurationByMetadata(ssoConfigId, body) {
+  return (0, _fetch.Put)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/metadata`, body);
+}
+
+async function createSSODomain(ssoConfigId, body) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/domains`, body);
+}
+
+async function deleteSSODomain(ssoConfigId, domainId) {
+  return (0, _fetch.Delete)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}`);
+}
+
+async function validateSSODomain(ssoConfigId, domainId) {
+  return (0, _fetch.Put)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
+}
+
+async function getSSODefaultRoles(ssoConfigId) {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/roles`);
+}
+
+async function setSSODefaultRoles(ssoConfigId, body) {
+  return (0, _fetch.Put)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/roles`, body);
+}
+
+async function createSSOGroup(ssoConfigId, body) {
+  return (0, _fetch.Post)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/groups`, body);
+}
+
+async function updateSSOGroup(ssoConfigId, {
+  roleIds,
+  group,
+  id
+}) {
+  return (0, _fetch.Patch)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+
+async function deleteSSOGroup(ssoConfigId, groupId) {
+  return (0, _fetch.Delete)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${groupId}`);
+}
+
+async function getSSOGroups(ssoConfigId) {
+  return (0, _fetch.Get)(`${_constants.urls.team.sso.v1}/configurations/${ssoConfigId}/groups`);
+}
+
+async function preLoginV2(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v2}/user/sso/prelogin`, body);
+}
+
+async function oidcPostLoginV2(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.identity.auth.v2}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+
+async function exchangeOAuthTokens(body) {
+  const data = await (0, _fetch.Post)(`${_constants.urls.oauth.v1}/token`, body);
+  return generateLoginResponseFromOAuthResponse(data);
+}
+
+async function resetPhoneNumber(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/phone/reset`, body);
+}
+
+async function verifyResetPhoneNumber(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/phone/reset/verify`, body);
+}
+
+async function changePhoneNumberWithVerification(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/phone`, body);
+}
+
+async function verifyChangePhoneNumber(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.users.v1}/phone/verify`, body);
+}
+
+async function changePhoneNumber(body) {
+  return (0, _fetch.Put)(`${_constants.urls.identity.users.v1}/phone/change`, body);
+}
+
+async function webAuthnPreLogin(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/webauthn/prelogin`, body);
+}
+
+async function webAuthnPostLogin(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.auth.v1}/webauthn/postlogin`, body);
+}
+
+async function webAuthnCreateNewDeviceSession() {
+  return (0, _fetch.Post)(_constants.urls.identity.webAuthnDevices.v1);
+}
+
+async function verifyNewDeviceSession(body) {
+  return (0, _fetch.Post)(`${_constants.urls.identity.webAuthnDevices.v1}/verify`, body);
+}
+
+async function getVendorPublicAuthStrategiesConfig() {
+  return (0, _fetch.Get)(`${_constants.urls.identity.configurations.v1}/auth/strategies/public`);
+}
+
+;