@frontegg/rest-api 2.10.82 → 6.0.1-alpha.0

package/src/auth/index.ts

@@ -1,900 +0,0 @@
-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';
-import {ISamlRolesGroup} from '../teams/interfaces';
-import {
-  IAcceptInvitation,
-  IActivateAccount,
-  IAllowedToRememberMfaDevice,
-  ICreateSamlGroup,
-  IDeleteApiToken,
-  IDisableMfa,
-  IEnrollMfaResponse,
-  IForgotPassword,
-  IGetActivateAccountStrategy,
-  IGetActivateAccountStrategyResponse,
-  IGetUserById,
-  IGetUserPasswordConfig,
-  ILogin,
-  ILoginResponse,
-  ILoginViaSocialLogin,
-  ILoginViaSocialLoginResponse,
-  ILoginWithMfa,
-  IOidcPostLogin,
-  IOidcConfiguration,
-  IPostLogin,
-  IPreLogin,
-  IRecoverMFAToken,
-  IResendActivationEmail,
-  IResetPassword,
-  ISamlConfiguration,
-  ISamlVendorConfigResponse,
-  ISignUpResponse,
-  ISignUpUser,
-  ISocialLoginProviderConfiguration,
-  ITenantApiTokensData,
-  IUpdateSamlConfiguration,
-  IUpdateSamlGroup,
-  IUpdateSamlRoles,
-  IUpdateSamlVendorMetadata,
-  IUpdateTenantApiTokensData,
-  IUpdateUserApiTokensData,
-  IUserApiTokensData,
-  IUserIdResponse,
-  IVendorConfig,
-  IVerifyMfa,
-  IVerifyMfaResponse,
-  TestConfig,
-  ISSOPublicConfiguration,
-  IPreLoginWithIdpTypeResponse,
-  IPasswordlessPreLogin,
-  IPasswordlessPostLogin,
-  ICreateSSODomain,
-  IVerifyInviteToken,
-  ISSODomain,
-  ISSOConfigurationDefaultRoles,
-  ISSOConfiguration,
-  IUpdateSSOConfiguration,
-  IOidcPostLoginV2,
-  IExchangeOAuthTokens, IOAuthTokenResponse, ISocialLoginProviderConfigurationV2, ILoginResponseV2, IResetPhoneNumber, IVerifyResetPhoneNumber, IChangePhoneNumber, IVerifyResetPhoneNumberResponse, IResetPhoneNumberResponse, IWebAuthnPreLogin, IWebAuthnPostLogin, IVerifyNewWebAuthnDevice, IWebAuthnPreLoginResponse, ICreateNewDeviceSessionResponse, IAuthStrategiesConfig, ISessionResponse
-} from './interfaces';
-
-/*****************************************
- * Authentication
- *****************************************/
-
-export async function generateLoginResponse(loginResponse: ILoginResponse): Promise<ILoginResponse> {
-  if (!loginResponse.accessToken) {
-    return loginResponse;
-  }
-  ContextHolder.setAccessToken(loginResponse.accessToken);
-  const me = await Get(`${urls.identity.users.v2}/me`);
-  const decodedContent: any = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
-  const user = {
-    ...loginResponse,
-    ...decodedContent,
-    ...me,
-  };
-  ContextHolder.setUser(user);
-  return user;
-}
-
-export async function generateLoginResponseV2(loginResponse: ILoginResponse): Promise<ILoginResponseV2> {
-    if (!loginResponse.accessToken) {
-        return {user: loginResponse};
-    }
-    ContextHolder.setAccessToken(loginResponse.accessToken);
-    const [me, tenants] = await Promise.all([Get(`${urls.identity.users.v2}/me`), getTenants()]);
-    const decodedContent: any = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
-    const user = {
-        ...loginResponse,
-        ...decodedContent,
-        ...me,
-    };
-    ContextHolder.setUser(user);
-    return {user, tenants};
-}
-
-export async function generateLoginResponseFromOAuthResponse(oauthResponse: IOAuthTokenResponse): Promise<ILoginResponse> {
-  ContextHolder.setAccessToken(oauthResponse.id_token);
-  const me = await Get(`${urls.identity.users.v2}/me`);
-  const decodedContent: any = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
-  const user = {
-    mfaRequired: false,
-    accessToken: oauthResponse.id_token,
-    refreshToken: oauthResponse.refresh_token,
-    ...decodedContent,
-    ...me,
-  };
-  ContextHolder.setUser(user);
-  return user;
-}
-
-/**
- * Check if requested email address has sso configuration
- * If true, this function will return the sso address to navigate to
- * else, return null
- */
-export async function preLogin(body: IPreLogin): Promise<string | null> {
-  console.debug('preLogin()', body);
-  try {
-    const {address} = await Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
-    return address;
-  } catch {
-    return null;
-  }
-}
-
-
-/**
- * Check if requested email address has sso configuration
- * If true, this function will return the sso address and IdpType to navigate to
- */
-export async function preLoginWithIdpType(body: IPreLogin): Promise<IPreLoginWithIdpTypeResponse | null> {
-  console.debug('preLoginWithIdpType()', body);
-  return Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
-}
-
-/**
- * After calling preLogin and navigated to SSO url, the IDP will redirect you to the ACS Url
- * Which configured in the SSO configuraation
- * else, return null
- */
-export async function postLogin(body: IPostLogin): Promise<ILoginResponse> {
-  console.debug('postLogin()');
-  const data = await Post(`${urls.identity.auth.v1}/user/saml/postlogin`, body);
-  return generateLoginResponse(data);
-}
-
-/**
- * After calling preLogin and navigated to SSO url, the IDP will redirect you to the redirect url
- * with code and state
- */
-export async function oidcPostLogin(body: IOidcPostLogin): Promise<ILoginResponse> {
-  console.debug('oidcPostLogin()');
-  const data = await Post(`${urls.identity.auth.v1}/user/oidc/postlogin`, body);
-  return generateLoginResponse(data);
-}
-
-/**
- * login with username and password.
- * if the user has two factor authentication
- *    the server will return mfaToken with mfaRequired: true,
- *    and then ``loginWithMfa`` should be called with the mfaToken and and generated code
- * else, the server will accessToken and refreshToken.
- * the refresh should be used to renew your access token by calling ``refreshToken``
- *
- * @throw exception if login failed
- */
-export async function login(body: ILogin): Promise<ILoginResponse> {
-  console.debug('login()');
-  const data = await Post(`${urls.identity.auth.v1}/user`, body);
-  return generateLoginResponse(data);
-}
-
-/**
- * after login succeeded with mfaRequired token response, this function should be called
- * with the mfaToken and the generated code from your authenticator app.
- *
- * @throw exception if generated code or mfaToken are incorrect
- */
-export async function loginWithMfa(body: ILoginWithMfa): Promise<ILoginResponse> {
-  console.debug('loginWithMfa()');
-  const data = await Post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
-  return generateLoginResponse(data);
-}
-
-/**
- * activating account should be called after registering new user of deactivate account
- * ``activateAccount`` should contains userId and the token that has been sent to the user after activation requested.
- *
- * @throws exception if activation failed
- */
-export async function activateAccount(body: IActivateAccount): Promise<void> {
-  console.debug('activateAccount()');
-  return Post(`${urls.identity.users.v1}/activate`, body);
-}
-
-/**
- * get account activation configuration.
- */
-export async function getActivateAccountStrategy(
-  params: IGetActivateAccountStrategy
-): Promise<IGetActivateAccountStrategyResponse> {
-  console.debug('getActivateAccountStrategy()');
-  return Get(`${urls.identity.users.v1}/activate/strategy`, params);
-}
-
-/**
- * resend activation email should be called after a failed user activation.
- * ``resend activation email`` should contain  the user email.
- *
- * @throws exception if resend failed
- */
-export async function resendActivationEmail(body: IResendActivationEmail): Promise<void> {
-  console.debug('resendActivationEmail()');
-  return Post(`${urls.identity.users.v1}/activate/reset`, body);
-}
-
-/**
- * activating account should be called after registering new user of deactivate account
- * ``activateAccount`` should contains userId and the token that has been sent to the user after activation requested.
- *
- * @throws exception if activation failed
- */
-export async function acceptInvitation(body: IAcceptInvitation): Promise<void> {
-  console.debug('acceptInvitation()');
-  return Post(`${urls.identity.users.v1}/invitation/accept`, body);
-}
-
-/**
- * refresh token called as authenticated use, access and refresh tokens resolved by the cookies.
- * the server will return ILoginResponse with new access Token and refresh token and store it in the browser cookies.
- */
-export async function refreshToken(): Promise<ILoginResponse> {
-  console.debug('refreshToken()');
-  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`);
-  return generateLoginResponse(data);
-}
-
-/**
- * refresh token called as authenticated use, access and refresh tokens resolved by the cookies.
- * the server will return ILoginResponseV2 with new access Token and refresh token and store it in the browser cookies, as well as the tenants.
- */
-export async function refreshTokenV2(): Promise<ILoginResponseV2> {
-  console.debug('refreshTokenV2()');
-  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`);
-  return generateLoginResponseV2(data);
-}
-
-/**
- * logout from server, invalidate access and refresh token, remove it from cookies.
- */
-export async function logout(): Promise<void> {
-  console.debug('logout()');
-  return Post(`${urls.identity.auth.v1}/logout`);
-}
-
-/**
- * calling forgot password request will send email with link to reset user's password.
- *
- * @throws exception if the user not found
- */
-export async function forgotPassword(body: IForgotPassword): Promise<void> {
-  console.debug('forgotPassword()', body);
-  return Post(`${urls.identity.users.v1}/passwords/reset`, body);
-}
-
-/**
- * reset password should be called after forget password request.
- * userId, new password and the token has been sent to the user email.
- *
- * @throws exception if the user not found, password validation failed or invalid token.
- */
-export async function resetPassword(body: IResetPassword): Promise<void> {
-  console.debug('resetPassword()');
-  return Post(`${urls.identity.users.v1}/passwords/reset/verify`, body);
-}
-
-/**
- * load password configuration for user.
- */
-export async function loadPasswordConfig(params?: IGetUserPasswordConfig): Promise<Partial<TestConfig> | null> {
-  console.debug('loadPasswordConfig()');
-  return Get(`${urls.identity.users.v1}/passwords/config`, params);
-}
-
-/**
- * recover Multi-Factor authentication by providing the recoveryCode
- * that has been received when activated it
- *
- * @throws exception if recovery code is not valid
- */
-export async function recoverMfaToken(body: IRecoverMFAToken): Promise<void> {
-  console.debug('recoverMfaToken()', body);
-  return Post(`${urls.identity.auth.v1}/user/mfa/recover`, body);
-}
-
-/**
- * Multi-Factor Settings
- */
-
-/**
- * enroll Multi-Factor Auth Code to use in 3rd party apps like Google Authenticator.
- * the server returns qrCode as png image in base64 format
- *
- * @throws exception if the user already have mfa-enabled
- * ``authorized user``
- */
-export async function enrollMfa(): Promise<IEnrollMfaResponse> {
-  console.debug('enrollMfa()');
-  return Post(`${urls.identity.users.v1}/mfa/enroll`);
-}
-
-/**
- * after enrolling MFA QR code, verify function should be called
- * with the generated code in the Authenticator App
- *
- * @return recoveryCode to use to disable mfa if your device is lost, this code won't show it again.
- * @throws exception if the generated token is invalid
- * ``authorized user``
- */
-export async function verifyMfa(body: IVerifyMfa): Promise<IVerifyMfaResponse> {
-  console.debug('verifyMfa()', body);
-  return Post(`${urls.identity.users.v1}/mfa/enroll/verify`, body);
-}
-
-/**
- * disable MFA by either passing the recoveryCode or the generated code from the Authenticator App.
- *
- * @throws exception if the generated token or the recoveryCode are incorrect.
- * * ``authorized user``
- */
-export async function disableMfa(body: IDisableMfa): Promise<void> {
-  console.debug('disableMfa()', body);
-  return Post(`${urls.identity.users.v1}/mfa/disable`, body);
-}
-
-/**
- * SSO Configurations
- */
-
-/**
- *  Retrieve SAML configurations from server by logged in user (tenantId, vendorId)
- *
- *  @return {enabled: false} if no saml configuration found. else ISamlConfiguration
- * * ``authorized user``
- */
-export async function getSamlConfiguration(): Promise<ISamlConfiguration> {
-  console.debug('getSamlConfiguration()');
-  return Get(`${urls.team.sso.v1}/saml/configurations`);
-}
-
-/**
- *  Update SAML configuration by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function updateSamlConfiguration(body: IUpdateSamlConfiguration): Promise<ISamlConfiguration> {
-  console.debug('updateSamlConfiguration()', body);
-  return Post(`${urls.team.sso.v1}/saml/configurations`, body);
-}
-
-/**
- *  Retrieve 'Vendor' Saml config from server by logged in user (tenantId, vendorId)
- *
- *  @throws exception 'ACS url information not found' if no saml vendor configuration found.
- * * ``authorized user``
- */
-export async function getSamlVendorConfiguration(): Promise<ISamlVendorConfigResponse> {
-  console.debug('getSamlVendorConfiguration()');
-  return Get(`${urls.team.sso.v1}/saml/configurations/vendor-config`);
-}
-
-/**
- *  Update Vendor Saml metadata by logged in user (tenantId, vendorId)
- *
- *  @return {enabled: false} if no saml configuration found. else ISamlConfiguration
- * * ``authorized user``
- */
-export async function updateSamlVendorMetadata(body: IUpdateSamlVendorMetadata): Promise<ISamlConfiguration> {
-  console.debug('updateSamlVendorMetadata()', body);
-  return Put(`${urls.team.sso.v1}/saml/configurations/metadata`, body);
-}
-
-/**
- *  Validate Saml configuration's domain by logged in user (tenantId, vendorId)
- *
- *  @return {enabled: false} if no saml configuration found. else ISamlConfiguration
- * * ``authorized user``
- */
-export async function validateSamlDomain(): Promise<ISamlConfiguration> {
-  console.debug('validateSamlDomain()');
-  return Put(`${urls.team.sso.v1}/saml/validations/domain`);
-}
-
-/**
- *  Get Saml roles for authorization
- * @return array of role IDs
- */
-export async function getSamlRoles(): Promise<string[]> {
-  console.debug('getSamlRoles()');
-  return Get(`${urls.team.sso.v1}/saml/configurations/roles/default`);
-}
-
-/**
- *  Get Saml roles groups
- * @return array of groups and assigend role IDs
- */
-export async function getSamlRolesGroups(): Promise<ISamlRolesGroup[]> {
-  console.debug('getSamlRoles()');
-  return Get(`${urls.team.sso.v2}/saml/configurations/groups`);
-}
-
-/**
- *  Update Saml roles for authorization
- */
-export async function updateSamlRoles({roleIds}: IUpdateSamlRoles): Promise<void> {
-  console.debug('updateSamlRoles()');
-  return Post(`${urls.team.sso.v1}/saml/configurations/roles/default`, {roleIds});
-}
-
-/**
- *  Create Saml group roles for authorization
- */
-export async function createSamlGroup({roleIds, group}: ICreateSamlGroup): Promise<void> {
-  console.debug('createSamlGroup()');
-  return Post(`${urls.team.sso.v2}/saml/configurations/groups`, {group, roleIds});
-}
-
-/**
- *  Update Saml group roles for authorization
- */
-export async function updateSamlGroup({roleIds, group, id}: IUpdateSamlGroup): Promise<void> {
-  console.debug('updateSamlGroup()');
-  return Patch(`${urls.team.sso.v2}/saml/configurations/groups/${id}`, {group, roleIds});
-}
-
-/**
- *  Delete Saml group
- */
-export async function deleteSamlGroup({id}: { id: string }): Promise<void> {
-  console.debug('deleteSamlGroup()');
-  return Delete(`${urls.team.sso.v2}/saml/configurations/groups/${id}`);
-}
-
-/**
- *  Retrieve OIDC configurations from server by logged in user (vendorId)
- *
- *  @return {active: true} if no oidc configuration found. else IOidcConfiguration
- * * ``authorized user``
- */
-export async function getOidcConfiguration(): Promise<IOidcConfiguration> {
-  console.debug('getOidcConfiguration()');
-  return Get(`${urls.team.sso.v1}/oidc/configurations`);
-}
-
-/**
- *  Check if one or more saml/oidc configuration are active
- *
- **  @return {isActive: true/false}
- */
-export async function getSSOPublicConfiguration(): Promise<ISSOPublicConfiguration> {
-  console.debug('getSSOPublicConfiguration()');
-  return Get(`${urls.team.sso.v2}/configurations/public`);
-}
-
-
-/**
- *  Get social logins providers configurations for vendor
- * @return array of providers configurations
- */
-export async function getSocialLoginProviders(): Promise<ISocialLoginProviderConfiguration[]> {
-  console.debug('getSocialLoginProviders()');
-  return Get(urls.identity.sso.v1);
-}
-
-/**
- *  Get social logins providers configurations V2 supports dev credentials as well
- * @return array of providers configurations
- */
-export async function getSocialLoginProvidersV2(): Promise<ISocialLoginProviderConfigurationV2[]> {
-  console.debug('getSocialLoginProvidersV2()');
-  return Get(urls.identity.sso.v2);
-}
-
-/**
- * Login using social login
- * @return cookie with refresh token
- */
-export async function loginViaSocialLogin({
-                                            provider,
-                                            code,
-                                            redirectUri,
-                                            codeVerifier,
-                                            metadata,
-                                            invitationToken,
-                                            state,
-                                          }: ILoginViaSocialLogin): Promise<ILoginViaSocialLoginResponse> {
-  console.debug('loginViaSocialLogin()');
-  const params: {
-    code: string;
-    redirectUri?: string;
-    code_verifier?: string;
-    state?: string;
-  } = {code};
-  if (redirectUri) {
-    params.redirectUri = redirectUri;
-  }
-  if (codeVerifier) {
-    params.code_verifier = codeVerifier;
-  }
-  if(state) {
-    params.state = state
-  }
-
-  return Post(`${urls.identity.auth.v1}/user/sso/${provider}/postlogin`, {metadata, invitationToken}, {params});
-}
-
-/**
- * Get vendor secure access configuration
- */
-export async function getVendorConfig(): Promise<IVendorConfig> {
-  console.debug('getVendorConfig()');
-  return Get(`${urls.identity.configurations.v1}/public`);
-}
-
-/**
- * Sign up new user
- * create new user with a new tenant
- */
-export async function signUpUser(body: ISignUpUser): Promise<ISignUpResponse> {
-  console.debug('signUpUser()', body);
-  const {shouldActivate, authResponse, userId, tenantId} = await Post(`${urls.identity.users.v1}/signUp`, body);
-  const loginResponse =
-    !shouldActivate && authResponse ? await generateLoginResponse(authResponse as ILoginResponse) : undefined;
-  return {shouldActivate, user: loginResponse, userId, tenantId};
-}
-
-/**
- * Get all current user active sessions
- */
- export async function getCurrentUserSessions(): Promise<ISessionResponse[]> {
-  console.debug('getCurrentUserSessions');
-  const sessions = await Get(urls.identity.users.sessions.currentUser.v1);
-  return sessions;
-}
-
-/**
- * Delete user session
- */
- export async function deleteSessionForUser(id: string): Promise<void> {
-  console.debug('deleteSessionForUser', id);
-  await Delete(`${urls.identity.users.sessions.currentUser.v1}/${id}`);
-}
-
-/**
- * Delete all user sessions
- */
- export async function deleteAllSessionsForUser(): Promise<void> {
-  console.debug('deleteAllSessionsForUser');
-  await Delete(`${urls.identity.users.sessions.currentUser.v1}/all`);
-}
-
-
-/**
- * Api tokens Configurations
- */
-
-/**
- * Get user api tokens data
- */
-export async function getUserApiTokensData(): Promise<IUserApiTokensData[]> {
-  console.debug('getUserApiTokensData()');
-  return Get(urls.identity.users.apiTokens.v1);
-}
-
-/**
- * Get tenant api tokens data
- */
-export async function getTenantApiTokensData(): Promise<ITenantApiTokensData[]> {
-  console.debug('geTenantApiTokensData()');
-  return Get(urls.identity.tenants.apiTokens.v1);
-}
-
-/**
- *  Update User Api Tokens
- */
-
-export async function updateUserApiTokensData(body: IUpdateUserApiTokensData): Promise<IUserApiTokensData> {
-  console.debug('updateUserApiTokensData()', body);
-  return Post(urls.identity.users.apiTokens.v1, body);
-}
-
-/**
- * Update Tenant Api Tokens
- */
-export async function updateTenantApiTokensData(body: IUpdateTenantApiTokensData): Promise<ITenantApiTokensData> {
-  console.debug('updateTenantApiTokensData()', body);
-  return Post(urls.identity.tenants.apiTokens.v2, body);
-}
-
-/**
- * Delete Tenant Api Token
- */
-export async function deleteTenantApiToken({tokenId}: IDeleteApiToken): Promise<void> {
-  console.debug('deleteTenantApiToken()', tokenId);
-  return Delete(`${urls.identity.tenants.apiTokens.v1}/${tokenId}`);
-}
-
-/**
- * Delete Tenant Api Token
- */
-export async function deleteUserApiToken({tokenId}: IDeleteApiToken): Promise<void> {
-  console.debug('deleteUserApiToken()', tokenId);
-  return Delete(`${urls.identity.users.apiTokens.v1}/${tokenId}`);
-}
-
-/**
- * Get Tenant Api Token Creator User
- */
-
-export async function getUserById({userId}: IGetUserById): Promise<IUserIdResponse> {
-  console.debug('getUserById()');
-  return Get(`${urls.identity.users.v1}/${userId}`);
-}
-
-/**
- * Checks if remember MFA device is enabled for user.
- */
-export async function checkIfAllowToRememberMfaDevice(mfaToken: string): Promise<IAllowedToRememberMfaDevice> {
-  console.debug('checkIfAllowToRememberMfaDevice()');
-  return Get(`${urls.identity.configurations.v1}/mfa-policy/allow-remember-device`, {mfaToken});
-}
-
-/**
- * Passwordless prelogin authentication
- */
-export async function passwordlessPreLogin({ type, ...body }: IPasswordlessPreLogin): Promise<void> {
-  console.debug('passwordlessPrelogin()');
-  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/prelogin`, body);
-}
-
-export async function passwordlessPostLogin({ type, ...body }: IPasswordlessPostLogin): Promise<ILoginResponse> {
-  console.debug('passwordlessPostLogin()');
-  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
-}
-
-/**
- * Check if tenant invitation token is valid
- * @param token - invitation token
- * @returns tenant name
- */
-export async function verifyInviteToken({ token }: IVerifyInviteToken): Promise<string> {
-  console.debug('verifyInviteToken()');
-  return Post(urls.identity.tenants.invites.verify.v1, { token });
-}
-/**
- * SSO Configurations V1
- */
-
-/**
- *  Retrieve SSO configurations from server by logged in user (tenantId, vendorId)
- *
- *  @return ISSOConfiguration[]
- * * ``authorized user``
- */
-export async function getSSOConfigurations(): Promise<ISSOConfiguration[]> {
-  console.debug('getSSOConfigurations()');
-  return Get(`${urls.team.sso.v1}/configurations`);
-}
-
-/**
- *  Create SSO configuration by logged in user (tenantId, vendorId)
- *
- *  @returns ISSOConfiguration
- * * ``authorized user``
- */
-export async function createSSOConfiguration(body: IUpdateSSOConfiguration): Promise<ISSOConfiguration> {
-  console.debug('createSSOConfiguration()', body);
-  return Post(`${urls.team.sso.v1}/configurations`, body);
-}
-
-/**
- *  Update SSO configuration by logged in user (tenantId, vendorId)
- *
- *  @returns ISSOConfiguration
- * * ``authorized user``
- */
-export async function updateSSOConfiguration(ssoConfigId: string, body: IUpdateSSOConfiguration): Promise<ISSOConfiguration> {
-  console.debug('updateSSOConfiguration()', { body, ssoConfigId });
-  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}`, body);
-}
-
-/**
- *  Delete SSO configuration by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function deleteSSOConfiguration(ssoConfigId: string): Promise<void> {
-  console.debug('deleteSSOConfiguration()', { ssoConfigId });
-  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}`);
-}
-
-/**
- *  Create SSO configuration by metadata by logged in user (tenantId, vendorId)
- *
- *  @returns ISSOConfiguration
- * * ``authorized user``
- */
-export async function createSSOConfigurationByMetadata(body: IUpdateSamlVendorMetadata): Promise<ISSOConfiguration> {
-  console.debug('createSSOConfigurationByMetadata()', body);
-  return Post(`${urls.team.sso.v1}/configurations/metadata`, body);
-}
-
-/**
- *  Update SSO configuration by metadata by logged in user (tenantId, vendorId)
- *
- *  @returns ISSOConfiguration
- * * ``authorized user``
- */
-export async function updateSSOConfigurationByMetadata(ssoConfigId: string, body: IUpdateSamlVendorMetadata): Promise<ISSOConfiguration> {
-  console.debug('updateSSOConfigurationByMetadata()', { body, ssoConfigId });
-  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata`, body);
-}
-
-/**
- *  Create SSO configuration domain by logged in user (tenantId, vendorId)
- *
- *  @returns ISSODomain
- * * ``authorized user``
- */
-export async function createSSODomain(ssoConfigId: string, body: ICreateSSODomain): Promise<ISSODomain> {
-  console.debug('createSSODomain()', { body, ssoConfigId });
-  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains`, body);
-}
-
-/**
- *  Create SSO configuration domain by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function deleteSSODomain(ssoConfigId: string, domainId: string): Promise<void> {
-  console.debug('deleteSSODomain()', { domainId, ssoConfigId });
-  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}`);
-}
-
-/**
- *  Validate SSO configuration domain by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function validateSSODomain(ssoConfigId: string, domainId: string): Promise<void> {
-  console.debug('validateSSODomain()', { domainId, ssoConfigId });
-  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
-}
-
-/**
- *  Get SSO configuration default roles by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function getSSODefaultRoles(ssoConfigId: string): Promise<ISSOConfigurationDefaultRoles> {
-  console.debug('getSSODefaultRoles()', { ssoConfigId });
-  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`);
-}
-
-/**
- *  Create SSO configuration default roles by logged in user (tenantId, vendorId)
- * * ``authorized user``
- */
-export async function setSSODefaultRoles(ssoConfigId: string, body: IUpdateSamlRoles): Promise<void> {
-  console.debug('setSSODefaultRoles()', { body, ssoConfigId });
-  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`, body);
-}
-
-/**
- *  Create SSO configuration group roles for authorization
- */
-export async function createSSOGroup(ssoConfigId: string, body: ICreateSamlGroup): Promise<void> {
-  console.debug('createSSOGroup()', { body, ssoConfigId });
-  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`, body);
-}
-
-/**
- *  Update SSO configuration group roles for authorization
- */
-export async function updateSSOGroup(ssoConfigId: string, { roleIds, group, id }: IUpdateSamlGroup): Promise<void> {
-  console.debug('updateSSOGroup()', { ssoConfigId, roleIds, group });
-  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${id}`, { group, roleIds });
-}
-
-/**
- *  Delete SSO configuration group
- */
-export async function deleteSSOGroup(ssoConfigId: string, groupId: string): Promise<void> {
-  console.debug('deleteSSOGroup()', { ssoConfigId, groupId });
-  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${groupId}`);
-}
-
-/**
- *  Get SSO configuration groups
- */
-export async function getSSOGroups(ssoConfigId: string): Promise<ISamlRolesGroup[]> {
-  console.debug('getSSOGroups()', { ssoConfigId });
-  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`);
-}
-
-/**
- * Check if requested email address has sso configuration
- * If true, this function will return the sso address to navigate to
- * else, return null
- */
-export async function preLoginV2(body: IPreLogin): Promise<IPreLoginWithIdpTypeResponse | null> {
-  console.debug('preLoginV2()', body);
-  return Post(`${urls.identity.auth.v2}/user/sso/prelogin`, body);
-}
-
-/**
- * After calling preLogin and navigated to SSO url, the IDP will redirect you to the redirect url 
- * with code and state
- */
-export async function oidcPostLoginV2(body: IOidcPostLoginV2): Promise<ILoginResponse> {
-  console.debug('oidcPostLoginV2()');
-  const data = await Post(`${urls.identity.auth.v2}/user/oidc/postlogin`, body);
-  return generateLoginResponse(data);
-}
-
-export async function exchangeOAuthTokens(body: IExchangeOAuthTokens): Promise<ILoginResponse> {
-  console.debug('exchangeOauthTokens()');
-  const data = await Post(`${urls.oauth.v1}/token`, body);
-  return generateLoginResponseFromOAuthResponse(data);
-}
-
-
-/**
- * reset phone should be called in case user want to reset his phone number 
- * when using sms authentication strategy. a 6-digits code will be send to the user email.
- */
-export async function resetPhoneNumber(body: IResetPhoneNumber): Promise<IResetPhoneNumberResponse> {
-  console.debug('resetPhoneNumber()', body);
-  return Post(`${urls.identity.users.v1}/phone/reset`, body);
-}
-
-/**
- * verify reset phone should be called after reset phone number request
- * with the token received from the reset phone number request and a code that was sent to the user email
- */
-export async function verifyResetPhoneNumber(body: IVerifyResetPhoneNumber): Promise<IVerifyResetPhoneNumberResponse> {
-  console.debug('verifyResetPhoneNumber()', body);
-  return Post(`${urls.identity.users.v1}/phone/reset/verify`, body);
-}
-
-/**
- * change phone number should be called after verify reset phone number with the new phone number
- */
-export async function changePhoneNumber(body: IChangePhoneNumber): Promise<void> {
-  console.debug('changePhoneNumber()', body);
-  return Put(`${urls.identity.users.v1}/phone/change`, body);
-}
-
-/**
- * webauthn prelogin should be called when the user wants to be authenticated using his device/android/usb key
- */
-export async function webAuthnPreLogin(body: IWebAuthnPreLogin): Promise<IWebAuthnPreLoginResponse> {
-  console.debug('webAuthnPreLogin()', body);
-  return Post(`${urls.identity.auth.v1}/webauthn/prelogin`, body);
-}
-
-/**
- * webauthn postlogin should be called after the user used his authenticator (device/android/usb key) in order to login
- */
-export async function webAuthnPostLogin(body: IWebAuthnPostLogin): Promise<ILoginResponse> {
-  console.debug('webAuthnPostLogin()', body);
-  return Post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
-}
-
-/**
- * webauthn create new device should be called once the user wants to add new device as authenticator
- */
-export async function webAuthnCreateNewDeviceSession(): Promise<ICreateNewDeviceSessionResponse> {
-  console.debug('webAuthnCreateNewDeviceSession()');
-  return Post(urls.identity.webAuthnDevices.v1);
-}
-
-/**
- * webauthn verify new device should be called after the user used his authenticator in order to register the new device
- */
-export async function verifyNewDeviceSession(body: IVerifyNewWebAuthnDevice): Promise<void> {
-  console.debug('verifyNewDeviceSession()', body);
-  return Post(`${urls.identity.webAuthnDevices.v1}/verify`, body);
-}
-
-/**
- * Get public vendor auth strategies public configuration
- */
-export async function getVendorPublicAuthStrategiesConfig(): Promise<IAuthStrategiesConfig> {
-  console.debug('getVendorPublicAuthStrategiesConfig()');
-  return Get(`${urls.identity.configurations.v1}/auth/strategies/public`);
-};