@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/auth/StepUpState/actions/generateStepUpSession.actions.d.ts

@@ -0,0 +1,6 @@
+import { IGenerateStepUpSession } from '../interfaces';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    generateStepUpSession: (payload: WithCallback<IGenerateStepUpSession>) => Promise<void>;
+};
+export default _default;

package/auth/StepUpState/actions/generateStepUpSession.actions.js

@@ -0,0 +1,104 @@
+import { ContextHolder } from '@frontegg/rest-api';
+import { getMfaStepForEnrolledUsers } from '../../LoginState/helpers';
+import { MFAStep } from '../../MfaState/interfaces';
+import { SHOULD_STEP_UP_KEY } from '../consts';
+/**
+ * Error returned from the BE when the user is not enrolled to MFA and logged in with email magic code/link
+ */
+const MFA_IS_NOT_ENROLLED_ERROR = 'MFA is not enrolled';
+
+/**
+ * @param error API error
+ * @returns true when the error is MFA is not enrolled error
+ */
+const isMfaIsNotEnrolledError = error => (error == null ? void 0 : error['message']) === MFA_IS_NOT_ENROLLED_ERROR;
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Handle an edge case when the user should NOT step up, so the response including the generated stepped-up jwt
+   * Relevant for scenarios like login with magic code, no other mfa enrolled, allowed to skip mfa and max age is valid
+   * @param generateResponse
+   * @private
+   */
+  const __handleNoNeedToStepUpFlow = async generateResponse => {
+    await actions.__afterAuthenticationStateUpdate(generateResponse);
+    await actions.afterStepUpAuthNavigation();
+  };
+
+  /**
+   * Handle the common scenario when the user should step up by the mfa token and devices returned from the generate req
+   * @param generateStepUpSessionResponse
+   * @private
+   */
+  const __handleNeedToStepUpFlow = async ({
+    mfaToken,
+    mfaDevices
+  }) => {
+    actions.setStepUpState({
+      mfaDevices,
+      mfaToken
+    });
+
+    // to handle scenarios when sms, email or authenticator are the only options - show immediately the enrolled one
+    const step = await getMfaStepForEnrolledUsers(mfaDevices);
+    actions.setMfaState({
+      step
+    });
+  };
+
+  /**
+   * Handle step up generation request error
+   * @param error
+   * @private
+   */
+  const __handleStepUpError = async error => {
+    if (isMfaIsNotEnrolledError(error)) {
+      actions.setMfaState({
+        step: MFAStep.noMFAEnrolledStepUp
+      });
+      return;
+    }
+    window.localStorage.setItem(SHOULD_STEP_UP_KEY, 'true');
+    const routes = store.auth.routes;
+    ContextHolder.for(store.root.appName).onRedirectTo(routes.logoutUrl, {
+      preserveQueryParams: true
+    });
+  };
+
+  /**
+   * Generate step up session
+   * Logout on error and redirecting to the login page
+   * @param payload.maxAge - The max age of the session in seconds
+   * @param payload.callback - The callback function to be called after the request is done
+   */
+  const generateStepUpSession = async payload => {
+    const {
+      maxAge,
+      callback
+    } = payload;
+    actions.setStepUpState({
+      mfaDevices: undefined,
+      mfaToken: ''
+    });
+    try {
+      const response = await api.auth.generateStepupSession({
+        maxAge
+      });
+      if (response.hasOwnProperty('user')) {
+        // got stepped up jwt, no need to continue step up by a second factor
+        await __handleNoNeedToStepUpFlow(response);
+      } else {
+        // regular step up flow
+        await __handleNeedToStepUpFlow(response);
+      }
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      callback == null ? void 0 : callback(false);
+      await __handleStepUpError(e);
+    }
+  };
+  return {
+    generateStepUpSession
+  };
+});

package/auth/StepUpState/actions/index.d.ts

@@ -0,0 +1,18 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { IStepUpWithAuthenticator, StepUpState } from '../interfaces';
+import { IPreVerifyMFAWebAuthNForLoginResponse, IVerifyMFAWebAuthnPayload, WithDeviceId } from '../../LoginState/interfaces';
+import { IPreVerifyMFA, IVerifyMFAEmailCode, IVerifyMFASMS } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    stepUpHostedLogin: (payload: import("../interfaces").IStepUpHostedLogin) => Promise<void>;
+    generateStepUpSession: (payload: WithCallback<import("../interfaces").IGenerateStepUpSession, boolean>) => Promise<void>;
+    setStepUpState: (state: Partial<StepUpState>) => void;
+    resetStepUpState: () => void;
+    stepUpWithAuthenticator: (payload: WithCallback<IStepUpWithAuthenticator>) => Promise<void>;
+    preVerifyMFASMSForStepUp: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>>) => Promise<void>;
+    verifyMFASMSForStepUp: (payload: WithCallback<WithDeviceId<IVerifyMFASMS>>) => Promise<void>;
+    preVerifyMFAWebAuthnForStepUp: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForStepUp: (payload: WithCallback<IVerifyMFAWebAuthnPayload>) => Promise<void>;
+    preVerifyMFAEmailCodeForStepUp: (payload: WithCallback<IPreVerifyMFA>) => Promise<void>;
+    verifyMFAEmailCodeForStepUp: (payload: WithCallback<IVerifyMFAEmailCode>) => Promise<void>;
+};
+export default _default;

package/auth/StepUpState/actions/index.js

@@ -0,0 +1,98 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { deepClone } from '../../../helpers';
+import { initialState } from '../state';
+import generateStepUpSessionActions from './generateStepUpSession.actions';
+import stepUpHostedLoginActions from './stepUpHostedLogin.actions';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setStepUpState = state => {
+    Object.assign(store.auth.stepUpState, state);
+  };
+  const resetStepUpState = () => {
+    store.auth.stepUpState = deepClone(initialState);
+  };
+
+  /**
+   * Step up with authenticator app
+   * @param payload.callback - callback function to be called after the verification is done
+   * @param payload.mfaToken
+   * @param payload.value - 6 digits code input by the user
+   */
+  const stepUpWithAuthenticator = async payload => {
+    await actions.mfaWithAuthenticator(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA SMS step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFASMSForStepUp = async payload => {
+    await actions.preVerifyMFASMS(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA SMS step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.otcToken
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFASMSForStepUp = async payload => {
+    await actions.verifyMFASMS(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA Webauthn step up
+   * @param payload.callback - callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAWebAuthnForStepUp = async payload => {
+    await actions.preVerifyMFAWebAuthn(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA Webauthn step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.webauthnToken
+   * @param payload.mfaToken
+   * @param payload.publicKey - public key object from browser navigator credentials
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFAWebAuthnForStepUp = async payload => {
+    await actions.verifyMFAWebAuthn(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA Email code step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAEmailCodeForStepUp = async payload => {
+    await actions.preVerifyMFAEmailCode(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA Email code step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.otcToken
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFAEmailCodeForStepUp = async payload => {
+    await actions.verifyMFAEmailCode(payload, actions.setStepUpState);
+  };
+  return _extends({
+    setStepUpState,
+    resetStepUpState,
+    stepUpWithAuthenticator,
+    preVerifyMFASMSForStepUp,
+    verifyMFASMSForStepUp,
+    preVerifyMFAWebAuthnForStepUp,
+    verifyMFAWebAuthnForStepUp,
+    preVerifyMFAEmailCodeForStepUp,
+    verifyMFAEmailCodeForStepUp
+  }, generateStepUpSessionActions(store, api, sharedActions), stepUpHostedLoginActions(store, api, sharedActions));
+});

package/auth/StepUpState/actions/stepUpHostedLogin.actions.d.ts

@@ -0,0 +1,6 @@
+import { IStepUpHostedLogin } from '../interfaces';
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    stepUpHostedLogin: (payload: IStepUpHostedLogin) => Promise<void>;
+};
+export default _default;

package/auth/StepUpState/actions/stepUpHostedLogin.actions.js

@@ -0,0 +1,32 @@
+import { ACR_VALUE, SHOULD_STEP_UP_KEY } from '../consts';
+import { setAfterAuthRedirectUrlForStepUp } from '../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Step up for hosted login apps
+   * @param payload.maxAge
+   */
+  const stepUpHostedLogin = async payload => {
+    var _store$auth$tenantsSt, _store$auth$tenantsSt2;
+    const params = {
+      acr_values: ACR_VALUE
+    };
+    const {
+      maxAge
+    } = payload || {};
+    if (maxAge !== undefined) {
+      params['max_age'] = maxAge.toString();
+    }
+    const alias = (_store$auth$tenantsSt = store.auth.tenantsState) == null ? void 0 : (_store$auth$tenantsSt2 = _store$auth$tenantsSt.activeTenant) == null ? void 0 : _store$auth$tenantsSt2.alias;
+    if (alias) {
+      params['organization'] = alias;
+    }
+    setAfterAuthRedirectUrlForStepUp();
+    window.localStorage.setItem(SHOULD_STEP_UP_KEY, 'true');
+    await actions.__requestHostedLoginAuthorize(params);
+  };
+  return {
+    stepUpHostedLogin
+  };
+});

package/auth/StepUpState/consts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The required ACR (Authorization Context Reference) value for the step up flow
+ */
+export declare const ACR_VALUE = "http://schemas.openid.net/pape/policies/2007/06/multi-factor";
+/**
+ * One of the required AMR (Authentication Methods References) values for the step up flow
+ */
+export declare const AMR_MFA_VALUE = "mfa";
+/**
+ * One of the required AMR (Authentication Methods References) values should be from the array for the step up flow
+ */
+export declare const AMR_ADDITIONAL_VALUE: string[];
+/**
+ * SHOULD_STEP_UP_KEY local storage key
+ * Used for scenarios when we logout for re-login and then should redirect to step up page
+ */
+export declare const SHOULD_STEP_UP_KEY = "SHOULD_STEP_UP";
+/**
+ * The name of the query param that contains the max age of the step up
+ */
+export declare const STEP_UP_MAX_AGE_PARAM_NAME = "maxAge";

package/auth/StepUpState/consts.js

@@ -0,0 +1,25 @@
+/**
+ * The required ACR (Authorization Context Reference) value for the step up flow
+ */
+export const ACR_VALUE = 'http://schemas.openid.net/pape/policies/2007/06/multi-factor';
+
+/**
+ * One of the required AMR (Authentication Methods References) values for the step up flow
+ */
+export const AMR_MFA_VALUE = 'mfa';
+
+/**
+ * One of the required AMR (Authentication Methods References) values should be from the array for the step up flow
+ */
+export const AMR_ADDITIONAL_VALUE = ['otp', 'sms', 'hwk'];
+
+/**
+ * SHOULD_STEP_UP_KEY local storage key
+ * Used for scenarios when we logout for re-login and then should redirect to step up page
+ */
+export const SHOULD_STEP_UP_KEY = 'SHOULD_STEP_UP';
+
+/**
+ * The name of the query param that contains the max age of the step up
+ */
+export const STEP_UP_MAX_AGE_PARAM_NAME = 'maxAge';

package/auth/StepUpState/helpers.d.ts

@@ -0,0 +1,29 @@
+import { RedirectOptions } from '@frontegg/rest-api';
+export interface IsSteppedUpOptions {
+    maxAge?: number;
+}
+export interface SteppedUpJWTValues {
+    amr?: string[];
+    acr?: string;
+    auth_time?: number;
+}
+/**
+ * @param options.amr
+ * @param options.acr
+ * @param options.auth_time - auth time of the user (last login time)
+ * @param options.maxAge - max age of step up
+ * @returns true when the user is stepped up, false otherwise
+ */
+export declare const isSteppedUp: (user?: SteppedUpJWTValues | null | undefined, { maxAge }?: IsSteppedUpOptions) => boolean;
+/**
+ * Set the url and query params in the local storage FRONTEGG_AFTER_AUTH_REDIRECT_URL value
+ */
+export declare function setAfterAuthRedirectUrlForStepUp(): void;
+/**
+ * Redirects to the step up url with the max age param and set the redirect url in the local storage
+ * The redirect url will be used after the step up flow is done
+ * @param stepUpUrl - step up url to redirect to
+ * @param onRedirectTo - redirect to function
+ * @param maxAge - max age of step up
+ */
+export declare const redirectByStepUpUrl: (stepUpUrl: string, onRedirectTo: (path: string, opts?: RedirectOptions | undefined) => void, maxAge?: number | undefined) => void;

package/auth/StepUpState/helpers.js

@@ -0,0 +1,54 @@
+import { FRONTEGG_AFTER_AUTH_REDIRECT_URL } from '../../constants';
+import { ACR_VALUE, AMR_MFA_VALUE, AMR_ADDITIONAL_VALUE, STEP_UP_MAX_AGE_PARAM_NAME } from './consts';
+/**
+ * @param options.amr
+ * @param options.acr
+ * @param options.auth_time - auth time of the user (last login time)
+ * @param options.maxAge - max age of step up
+ * @returns true when the user is stepped up, false otherwise
+ */
+export const isSteppedUp = (user, {
+  maxAge
+} = {}) => {
+  if (!user) return false;
+  const {
+    amr = [],
+    acr = '',
+    auth_time
+  } = user;
+  if (maxAge && auth_time) {
+    // when user is logged in for a long time (more than maxAge, but jwt is still valid because it's not refreshed yet)
+    const isMaxAgeValid = Date.now() / 1000 - auth_time <= maxAge;
+    if (!isMaxAgeValid) return false;
+  }
+  const isACRValid = acr === ACR_VALUE;
+  const isAMRIncludesMFA = amr.indexOf(AMR_MFA_VALUE) !== -1;
+  const isAMRIncludesMethod = AMR_ADDITIONAL_VALUE.find(method => amr.indexOf(method)) !== undefined;
+  return isACRValid && isAMRIncludesMFA && isAMRIncludesMethod;
+};
+
+/**
+ * Set the url and query params in the local storage FRONTEGG_AFTER_AUTH_REDIRECT_URL value
+ */
+export function setAfterAuthRedirectUrlForStepUp() {
+  const encodedRedirectUrl = window.location.pathname + window.location.search;
+  window.localStorage.setItem(FRONTEGG_AFTER_AUTH_REDIRECT_URL, encodedRedirectUrl);
+}
+
+/**
+ * Redirects to the step up url with the max age param and set the redirect url in the local storage
+ * The redirect url will be used after the step up flow is done
+ * @param stepUpUrl - step up url to redirect to
+ * @param onRedirectTo - redirect to function
+ * @param maxAge - max age of step up
+ */
+export const redirectByStepUpUrl = (stepUpUrl, onRedirectTo, maxAge) => {
+  setAfterAuthRedirectUrlForStepUp();
+  const searchParams = new URLSearchParams(window.location.search);
+  if (maxAge) {
+    searchParams.set(STEP_UP_MAX_AGE_PARAM_NAME, maxAge.toString());
+  }
+  onRedirectTo(`${stepUpUrl}${searchParams ? `?${searchParams}` : ''}`, {
+    refresh: false
+  });
+};

package/auth/StepUpState/index.d.ts

@@ -0,0 +1,3 @@
+import createStepUpState from './state';
+import buildStepUpActions from './actions';
+export { createStepUpState, buildStepUpActions };

package/auth/StepUpState/index.js

@@ -0,0 +1,3 @@
+import createStepUpState from './state';
+import buildStepUpActions from './actions';
+export { createStepUpState, buildStepUpActions };

package/auth/StepUpState/interfaces.d.ts

@@ -0,0 +1,36 @@
+import { UserMFADevicesResponse } from '@frontegg/rest-api';
+export type { IsSteppedUpOptions, SteppedUpJWTValues } from './helpers';
+/**
+ * Step up state
+ */
+export interface StepUpState {
+    loading: boolean;
+    mfaDevices?: UserMFADevicesResponse;
+    mfaToken?: string;
+    error?: any;
+}
+/**
+ * Generate state up session action payload
+ */
+export interface IGenerateStepUpSession {
+    maxAge?: number;
+}
+/**
+ * Step up with authenticator action payload
+ */
+export interface IStepUpWithAuthenticator {
+    mfaToken: string;
+    value: string;
+}
+/**
+ * Step up hosted login options
+ */
+export interface IStepUpHostedLogin {
+    maxAge?: number;
+}
+/**
+ * Step up options (for stepUp function)
+ */
+export interface StepUpOptions {
+    maxAge?: number;
+}

package/auth/StepUpState/interfaces.js

@@ -0,0 +1 @@
+export {};

package/auth/StepUpState/state.d.ts

@@ -0,0 +1,4 @@
+import { StepUpState } from './interfaces';
+export declare const initialState: StepUpState;
+declare const _default: (overrideState?: Partial<StepUpState> | undefined) => StepUpState;
+export default _default;

package/auth/StepUpState/state.js

@@ -0,0 +1,7 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  mfaDevices: undefined,
+  mfaToken: ''
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/TeamState/actions/activation-link.actions.d.ts

@@ -0,0 +1,9 @@
+import { IResendActivationLink, IResendInvitationEmail, IResendInvitationLink } from '@frontegg/rest-api';
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    resendActivationLink: (payload: WithCallback<IResendActivationLink>) => Promise<void>;
+    resendInvitationLink: (payload: WithCallback<IResendInvitationLink>) => Promise<void>;
+    resendInvitationEmail: (payload: WithCallback<IResendInvitationEmail>) => Promise<void>;
+    resendInvitationLinkToAllSubTenants: (payload: WithCallback<IResendInvitationLink>) => Promise<void>;
+};
+export default _default;

package/auth/TeamState/actions/activation-link.actions.js

@@ -0,0 +1,84 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"],
+  _excluded4 = ["callback"];
+import { errorHandler } from '../../../helpers';
+import { TeamStateKeys } from '../interfaces';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Helper function to perform loading and error handling with try catch
+   * @param key loading / error key
+   * @param callback withCallback function
+   * @param block function to execute
+   * @private
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const __activateLinkTryCatch = async (key, loadingValue, callback, block) => {
+    actions.setTeamLoader({
+      key,
+      value: loadingValue
+    });
+    try {
+      await block();
+    } catch (error) {
+      actions.setTeamError({
+        key,
+        value: errorHandler(error)
+      });
+      callback == null ? void 0 : callback(null, error);
+    } finally {
+      actions.setTeamLoader({
+        key,
+        value: false
+      });
+    }
+  };
+  const resendActivationLink = async payload => {
+    const {
+        callback
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded);
+    await __activateLinkTryCatch(TeamStateKeys.RESEND_ACTIVATE_LINK, body.userId, callback, async () => {
+      await api.teams.resendActivationLink(body);
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const resendInvitationLink = async payload => {
+    const {
+        callback
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded2);
+    await __activateLinkTryCatch(TeamStateKeys.RESEND_INVITATION_LINK, body.email, callback, async () => {
+      await api.teams.resendInvitationLink(body);
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const resendInvitationEmail = async payload => {
+    const {
+        callback
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded3);
+    await __activateLinkTryCatch(TeamStateKeys.RESEND_INVITATION_LINK, callback, body.email, async () => {
+      await api.auth.resendInvitationEmail(body);
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const resendInvitationLinkToAllSubTenants = async payload => {
+    const {
+        callback
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded4);
+    await __activateLinkTryCatch(TeamStateKeys.RESEND_INVITATION_LINK, body.email, callback, async () => {
+      await api.teams.resendInvitationLinkToAllTenants(body);
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  return {
+    resendActivationLink,
+    resendInvitationLink,
+    resendInvitationEmail,
+    resendInvitationLinkToAllSubTenants
+  };
+});

package/auth/TeamState/actions/index.d.ts

@@ -0,0 +1,52 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { TeamState, TeamStateIndicator } from '../interfaces';
+import { IDeleteUser } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    getInvitationLink: () => Promise<void>;
+    createInvitationLink: (payload: WithCallback<import("@frontegg/rest-api").ICreateOrUpdateInviteUserLink, string>) => Promise<void>;
+    updateInvitationLink: (payload: WithCallback<import("@frontegg/rest-api").ICreateOrUpdateInviteUserLink, boolean>) => Promise<void>;
+    deleteInvitationLink: (payload?: {
+        callback?: import("../../../interfaces").CallbackMethod<boolean> | undefined;
+    } | undefined) => Promise<void>;
+    resendActivationLink: (payload: WithCallback<import("@frontegg/rest-api").IResendActivationLink, boolean>) => Promise<void>;
+    resendInvitationLink: (payload: WithCallback<import("@frontegg/rest-api").IResendInvitationLink, boolean>) => Promise<void>;
+    resendInvitationEmail: (payload: WithCallback<import("@frontegg/rest-api").IResendInvitationEmail, boolean>) => Promise<void>;
+    resendInvitationLinkToAllSubTenants: (payload: WithCallback<import("@frontegg/rest-api").IResendInvitationLink, boolean>) => Promise<void>;
+    loadAllSubTenantsUsers: (payload: WithCallback<import("../../../interfaces").WithSilentLoad<Partial<import("@frontegg/rest-api").ILoadAllUsers>>, import("@frontegg/rest-api").ISubTenantUser[]>) => Promise<void>;
+    setUserRolesForSubTenants: (payload: WithCallback<import("@frontegg/rest-api").UpdateUserRolesForSubTenantsRequestDto & {
+        userId: string;
+    }, boolean>) => Promise<void>;
+    deleteUserFromSubTenants: (payload: WithCallback<import("@frontegg/rest-api").RemoveUserFromSubTenantsRequest, boolean>) => Promise<void>;
+    addUserToSubTenants: (payload: WithCallback<import("@frontegg/rest-api").AddUserToSubTenantsRequest, boolean>) => Promise<void>;
+    loadRoles: (payload?: {
+        callback?: import("../../../interfaces").CallbackMethod<{
+            roles: import("@frontegg/rest-api").ITeamUserRole[];
+            permissions: import("@frontegg/rest-api").ITeamUserPermission[];
+        }> | undefined;
+    } | undefined) => Promise<void>;
+    loadUsers: (payload: WithCallback<import("../../../interfaces").WithSilentLoad<import("@frontegg/rest-api").ILoadUsers>, import("@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    loadUsersV2: (payload: WithCallback<import("../../../interfaces").WithSilentLoad<import("../interfaces").IGetUsersV2Payload>, import("@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    addUser: (payload: WithCallback<import("../interfaces").AddUserPayload, import("@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    addUsersBulk: (payload: WithCallback<import("../interfaces").IAddUsers, import("../interfaces").BulkInvintationData>) => Promise<void>;
+    updateUser: (payload: WithCallback<Partial<import("@frontegg/rest-api").ITeamUser>, import("@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    deleteUser: (payload: WithCallback<IDeleteUser, boolean>) => Promise<void>;
+    enableUser: (payload: WithCallback<{
+        userId: string;
+    }, boolean>) => Promise<void>;
+    disableUser: (payload: WithCallback<{
+        userId: string;
+    }, boolean>) => Promise<void>;
+    getTemporaryUsersConfig: () => Promise<void>;
+    updateUserExpirationTime: (payload: WithCallback<import("@frontegg/rest-api").IUpdateUserExpiration, boolean>) => Promise<void>;
+    setUserAsPermanent: (payload: WithCallback<Pick<import("@frontegg/rest-api").IUpdateUserExpiration, "userId">, boolean>) => Promise<void>;
+    setTeamLoader: (payload: TeamStateIndicator) => void;
+    setTeamError: (payload: TeamStateIndicator) => void;
+    setTeamState: (payload: Partial<TeamState>) => void;
+    resetTeamState: () => void;
+    openAddUserDialog: (payload?: Pick<import("../interfaces").AddUserDialogState, "onClose"> | undefined) => void;
+    closeAddUserDialog: (payload?: any) => void;
+    openDeleteUserDialog: (payload?: Pick<import("../interfaces").DeleteUserDialogState, "userId" | "onClose" | "email"> | undefined) => void;
+    closeDeleteUserDialog: (payload?: any) => void;
+    lockUser: (payload: WithCallback<IDeleteUser>) => Promise<void>;
+};
+export default _default;