@frontegg/react-hooks 7.77.0 → 7.78.0-alpha.1

package/auth/security/securityPolicy.d.ts

@@ -1,7 +1,37 @@
-import type { SecurityPolicyActions, SecurityPolicyState } from '@frontegg/redux-store';
-export type SecurityPolicyStateMapper<S> = (state: SecurityPolicyState) => S;
-export declare function useSecurityPolicyState(): SecurityPolicyState;
-export declare function useSecurityPolicyState<S>(stateMapper: SecurityPolicyStateMapper<S>): S;
-export declare const useSecurityPolicyActions: () => SecurityPolicyActions;
+import type { SecurityPolicyState } from '@frontegg/redux-store';
+export declare const useSecurityPolicyState: <S = SecurityPolicyState>(selector?: (s: SecurityPolicyState) => S) => S, useSecurityPolicyActions: () => {
+    setSecurityPolicyState: (state: Partial<SecurityPolicyState>) => void;
+    setSecurityPolicyGlobalState: (state: Partial<import("@frontegg/redux-store").GlobalPolicyState>) => void;
+    setSecurityPolicyPublicState: (state: Partial<import("@frontegg/redux-store").PublicPolicyState>) => void;
+    setSecurityPolicyMfaState: (state: Partial<import("@frontegg/redux-store").MfaPolicyState>) => void;
+    setSecurityPolicyVendorMfaState: (state: Partial<import("@frontegg/redux-store").MfaPolicyState>) => void;
+    setSecurityPolicyLockoutState: (state: Partial<import("@frontegg/redux-store").LockoutPolicyState>) => void;
+    setSecurityPolicyVendorLockoutState: (state: Partial<import("@frontegg/redux-store").LockoutPolicyState>) => void;
+    setSecurityPolicyCaptchaState: (state: Partial<import("@frontegg/redux-store").CaptchaPolicyState>) => void;
+    setSecurityPolicyPasswordHistoryState: (state: Partial<import("@frontegg/redux-store").PasswordHistoryPolicyState>) => void;
+    setSecurityPolicyVendorPasswordHistoryState: (state: Partial<import("@frontegg/redux-store").PasswordHistoryPolicyState>) => void;
+    setSecurityPolicyPasswordRotationState: (state: Partial<import("@frontegg/redux-store").PasswordRotationPolicyState>) => void;
+    resetSecurityPolicyState: () => void;
+    setSecurityPolicyPasswordState: (state: Partial<import("@frontegg/redux-store").PasswordPolicyState>) => void;
+    setSecurityPolicyAuthStrategyPublicState: (state: Partial<import("@frontegg/redux-store").PublicAuthStrategyPolicyState>) => void;
+    loadSecurityPolicy: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadGlobalSecurityPolicy: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadPublicSecurityPolicy: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadVendorPasswordConfig: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>, Partial<import("dist/@frontegg/rest-api").TestConfig>>) => Promise<void>;
+    loadSecurityPolicyMfa: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyVendorMfa: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyLockout: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyVendorLockout: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyCaptcha: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyPasswordHistory: () => Promise<void>;
+    loadSecurityPolicyVendorPasswordHistory: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadSecurityPolicyPasswordRotation: () => Promise<void>;
+    loadPublicAuthStrategiesPolicy: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>, import("dist/@frontegg/rest-api").IAuthStrategiesConfig>) => Promise<void>;
+    saveSecurityPolicyMfa: (payload: import("@frontegg/redux-store").SaveSecurityPolicyMfaPayload) => Promise<void>;
+    saveSecurityPolicyLockout: (payload: import("@frontegg/redux-store").SaveSecurityPolicyLockoutPayload) => Promise<void>;
+    saveSecurityPolicyPasswordHistory: (payload: import("@frontegg/redux-store").SaveSecurityPolicyPasswordHistoryPayload) => Promise<void>;
+    saveSecurityPolicyPasswordRotation: (payload: import("@frontegg/redux-store").SaveSecurityPolicyPasswordRotationPayload) => Promise<void>;
+    __getSecurityPolicyPublicStateWithCustomLogin: (securityPolicyPublicState?: import("dist/@frontegg/rest-api").IVendorConfig, retryConfig?: import("@frontegg/redux-store").RetryConfig) => Promise<import("dist/@frontegg/rest-api").IVendorConfig | undefined>;
+};
 export declare const usePublicPolicySettings: (loadOnMount?: boolean) => import("@frontegg/redux-store").PublicPolicyState;
 export declare const usePublicAuthStrategiesPolicySettings: (loadOnMount?: boolean) => import("@frontegg/redux-store").PublicAuthStrategyPolicyState;

package/auth/security/securityPolicy.js

@@ -1,18 +1,12 @@
 import { useEffect } from 'react';
-import { useStore } from '../../FronteggStoreContext';
-import { useSnapshot } from '../../useSnapshot';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-// @deprecated use useSecurityPolicyState() instead
-export function useSecurityPolicyState(stateMapper = defaultMapper) {
-  const state = useStore().store.auth.securityPolicyState;
-  return stateMapper(useSnapshot(state));
-}
-export const useSecurityPolicyActions = () => {
-  return useStore().stateActions.auth.securityPolicyActions;
-};
+import { createSliceHooks } from '../../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSecurityPolicyState,
+  useSliceActions: useSecurityPolicyActions
+} = createSliceHooks({
+  getState: s => s.auth.securityPolicyState,
+  getActions: a => a.auth.securityPolicyActions
+});
 export const usePublicPolicySettings = (loadOnMount = false) => {
   const {
     publicPolicy
@@ -21,8 +15,10 @@ export const usePublicPolicySettings = (loadOnMount = false) => {
     loadPublicSecurityPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    (loadOnMount || !publicPolicy.policy) && loadPublicSecurityPolicy();
-  }, [loadOnMount, loadPublicSecurityPolicy]);
+    if ((loadOnMount || !publicPolicy.policy) && !publicPolicy.loading) {
+      loadPublicSecurityPolicy();
+    }
+  }, [loadOnMount, publicPolicy.policy, publicPolicy.loading, loadPublicSecurityPolicy]);
   return publicPolicy;
 };
 export const usePublicAuthStrategiesPolicySettings = (loadOnMount = false) => {
@@ -33,7 +29,9 @@ export const usePublicAuthStrategiesPolicySettings = (loadOnMount = false) => {
     loadPublicAuthStrategiesPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    (loadOnMount || !publicAuthStrategyPolicy.policy) && !publicAuthStrategyPolicy.error && loadPublicAuthStrategiesPolicy();
-  }, [loadOnMount, loadPublicAuthStrategiesPolicy]);
+    if ((loadOnMount || !publicAuthStrategyPolicy.policy) && !publicAuthStrategyPolicy.error && !publicAuthStrategyPolicy.loading) {
+      loadPublicAuthStrategiesPolicy();
+    }
+  }, [loadOnMount, publicAuthStrategyPolicy.policy, publicAuthStrategyPolicy.error, publicAuthStrategyPolicy.loading, loadPublicAuthStrategiesPolicy]);
   return publicAuthStrategyPolicy;
 };

package/auth/security/sessionsPolicy.d.ts

@@ -1,3 +1,7 @@
-import type { SessionsPolicyState, SessionsPolicyActions } from '@frontegg/redux-store';
-export declare function useSessionsPolicyState(): SessionsPolicyState;
-export declare const useSessionsPolicyActions: () => SessionsPolicyActions;
+import type { SessionsPolicyState } from '@frontegg/redux-store';
+export declare const useSessionsPolicyState: <S = SessionsPolicyState>(selector?: (s: SessionsPolicyState) => S) => S, useSessionsPolicyActions: () => {
+    setSessionsPolicyState: (state: Partial<SessionsPolicyState>) => void;
+    resetSessionsPolicyState: () => void;
+    loadSessionsPolicy: () => Promise<void>;
+    createOrUpdateSessionsPolicy: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ISessionConfigurations>) => Promise<void>;
+};

package/auth/security/sessionsPolicy.js

@@ -1,9 +1,8 @@
-import { useStore } from '../../FronteggStoreContext';
-import { useSnapshot } from '../../useSnapshot';
-export function useSessionsPolicyState() {
-  const state = useStore().store.auth.sessionsPolicyState;
-  return useSnapshot(state);
-}
-export const useSessionsPolicyActions = () => {
-  return useStore().stateActions.auth.sessionsPolicyActions;
-};
+import { createSliceHooks } from '../../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSessionsPolicyState,
+  useSliceActions: useSessionsPolicyActions
+} = createSliceHooks({
+  getState: s => s.auth.sessionsPolicyState,
+  getActions: a => a.auth.sessionsPolicyActions
+});

package/auth/sessions.d.ts

@@ -1,3 +1,12 @@
-import type { SessionsState, SessionsActions } from '@frontegg/redux-store';
-export declare function useSessionsState(): SessionsState;
-export declare const useSessionsActions: () => SessionsActions;
+import type { SessionsState } from '@frontegg/redux-store';
+export declare const useSessionsState: <S = SessionsState>(selector?: (s: SessionsState) => S) => S, useSessionsActions: () => {
+    setSessionsState: (state: Partial<SessionsState>) => void;
+    resetSessionsState: () => void;
+    loadUserSessions: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadCurrentUserSession: () => Promise<void>;
+    deleteUserSession: (payload: import("@frontegg/redux-store").WithId) => Promise<void>;
+    deleteAllUserSessions: () => Promise<void>;
+    revokeUserSessions: (payload: import("@frontegg/redux-store").WithCallback<{
+        userId: string;
+    }>) => Promise<void>;
+};

package/auth/sessions.js

@@ -1,8 +1,8 @@
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-export function useSessionsState() {
-  return useSnapshot(useStore().store.auth.sessionsState);
-}
-export const useSessionsActions = () => {
-  return useStore().stateActions.auth.sessionsActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSessionsState,
+  useSliceActions: useSessionsActions
+} = createSliceHooks({
+  getState: s => s.auth.sessionsState,
+  getActions: a => a.auth.sessionsActions
+});

package/auth/signup.d.ts

@@ -1,5 +1,10 @@
-import type { SignUpState, SignUpActions } from '@frontegg/redux-store';
-export type SignUpStateMapper<S> = (state: SignUpState) => S;
-export declare function useSignUpState(): SignUpState;
-export declare function useSignUpState<S>(stateMapper: SignUpStateMapper<S>): S;
-export declare const useSignUpActions: () => SignUpActions;
+import type { SignUpState } from '@frontegg/redux-store';
+export declare const useSignUpState: <S = SignUpState>(selector?: (s: SignUpState) => S) => S, useSignUpActions: () => {
+    setSignUpState: (state: Partial<SignUpState>) => void;
+    resetSignUpState: () => void;
+    resetSignUpStateSoft: () => void;
+    signUpUser: (_payload: import("@frontegg/redux-store").ISignUpUserPayload) => Promise<void>;
+    signUpUserWithPhoneNumber: (_payload: import("@frontegg/redux-store").ISignUpUserPayload) => Promise<void>;
+    loadAllowSignUps: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>, import("dist/@frontegg/rest-api").IVendorConfig>) => Promise<void>;
+    loadSignUpStrategies: () => Promise<void>;
+};

package/auth/signup.js

@@ -1,16 +1,8 @@
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-// @deprecated use useSignUpState() instead
-export function useSignUpState(stateMapper = defaultMapper) {
-  const {
-    signUpState
-  } = useStore().store.auth;
-  return stateMapper(useSnapshot(signUpState));
-}
-export const useSignUpActions = () => {
-  return useStore().stateActions.auth.signUpActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSignUpState,
+  useSliceActions: useSignUpActions
+} = createSliceHooks({
+  getState: s => s.auth.signUpState,
+  getActions: a => a.auth.signUpActions
+});

package/auth/sms.d.ts

@@ -1,3 +1,13 @@
-import type { SmsActions, SmsState } from '@frontegg/redux-store';
-export declare function useSmsState(): SmsState;
-export declare const useSmsActions: () => SmsActions;
+import type { SmsState } from '@frontegg/redux-store';
+export declare const useSmsState: <S = SmsState>(selector?: (s: SmsState) => S) => S, useSmsActions: () => {
+    setSmsState: (state: Partial<SmsState>) => void;
+    resetSmsState: () => void;
+    loadPhoneNumbers: () => Promise<void>;
+    loadUserOwnPhoneNumbers: () => Promise<void>;
+    setUpPhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdatePhoneNumber>) => Promise<void>;
+    setUpOwnPhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdatePhoneNumber>) => Promise<void>;
+    verifyPhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyPhoneNumber>) => Promise<void>;
+    deletePhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IPhoneId>) => Promise<void>;
+    verifyDeletePhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithPhoneId<import("dist/@frontegg/rest-api").IVerifyPhoneNumber>>) => Promise<void>;
+    preVerifyPhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreVerifyPhoneNumber>) => Promise<void>;
+};

package/auth/sms.js

@@ -1,8 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useSmsState() {
-  return useSnapshot(useStore().store.auth.smsState);
-}
-export const useSmsActions = () => {
-  return useStore().stateActions.auth.smsActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSmsState,
+  useSliceActions: useSmsActions
+} = createSliceHooks({
+  getState: s => s.auth.smsState,
+  getActions: a => a.auth.smsActions
+});

package/auth/socialLogin.d.ts

@@ -1,5 +1,9 @@
-import type { SocialLoginActions, SocialLoginState } from '@frontegg/redux-store';
-export type SocialLoginStateMapper<S> = (state: SocialLoginState) => S;
-export declare function useSocialLoginState(): SocialLoginState;
-export declare function useSocialLoginState<S>(stateMapper: SocialLoginStateMapper<S>): S;
-export declare const useSocialLoginActions: () => SocialLoginActions;
+import type { SocialLoginState } from '@frontegg/redux-store';
+export declare const useSocialLoginState: <S = SocialLoginState>(selector?: (s: SocialLoginState) => S) => S, useSocialLoginActions: () => {
+    setSocialLoginsState: (state: Partial<SocialLoginState>) => void;
+    resetSocialLoginsState: () => void;
+    setSocialLoginError: (payload: import("dist/@frontegg/rest-api").ISetSocialLoginError) => void;
+    loadSocialLoginsConfiguration: () => Promise<void>;
+    loadSocialLoginsConfigurationV2: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>, SocialLoginState>) => Promise<void>;
+    loginViaSocialLogin: (_payload: import("@frontegg/redux-store").ILoginViaSocialLoginPayload) => Promise<void>;
+};

package/auth/socialLogin.js

@@ -1,13 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-// @deprecated use useSocialLoginState() instead
-export function useSocialLoginState(stateMapper = defaultMapper) {
-  return stateMapper(useSnapshot(useStore().store.auth.socialLoginState));
-}
-export const useSocialLoginActions = () => {
-  return useStore().stateActions.auth.socialLoginActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSocialLoginState,
+  useSliceActions: useSocialLoginActions
+} = createSliceHooks({
+  getState: s => s.auth.socialLoginState,
+  getActions: a => a.auth.socialLoginActions
+});

package/auth/sso.d.ts

@@ -1,6 +1,31 @@
-import type { SSOState, SSOActions } from '@frontegg/redux-store';
-type AuthSSOStateMapper<S> = (state: SSOState) => S;
-export declare function useSSOState(): SSOState;
-export declare function useSSOState<S>(stateMapper: AuthSSOStateMapper<S>): S;
-export declare const useSSOActions: () => SSOActions;
-export {};
+import type { SSOState } from '@frontegg/redux-store';
+export declare const useSSOState: <S = SSOState>(selector?: (s: SSOState) => S) => S, useSSOActions: () => {
+    loadSSOConfigurationsV2: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<{}>) => Promise<void>;
+    saveSSOConfigurationV2: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationPayloadV2) => Promise<void>;
+    updateSSOConfiguration: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").UpdateSSOConfigurationPayload) => Promise<void>;
+    deleteSSOConfiguration: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").DeleteSSOConfigurationPayload) => Promise<void>;
+    saveSSODomain: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSODomainPayload) => Promise<void>;
+    deleteSSODomain: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").ValidateSSODomainPayload) => Promise<void>;
+    validateSSODomainV2: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").ValidateSSODomainPayload) => Promise<void>;
+    setSSOGroups: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SetSSOGroupsPayload) => Promise<void>;
+    updateSSOGroups: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").UpdateSSOGroupsPayload) => Promise<void>;
+    setSSODefaultRoles: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").UpdateSSODefaultRolesPayload) => Promise<void>;
+    saveSSOConfigurationByMetadata: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationByMetadataPayload) => Promise<void>;
+    updateSSOConfigurationByMetadata: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").UpdateSSOConfigurationByMetadataPayload) => Promise<void>;
+    saveSSOConfigurationByUrl: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationByUrlPayload) => Promise<void>;
+    saveSSOConfigurationByData: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationByDataPayload) => Promise<void>;
+    setSSOState: (state: Partial<import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SSOState>) => void;
+    resetSSOState: () => void;
+    setSSOLoader: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SSOStateIndicator) => void;
+    setSSOError: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SSOStateIndicator) => void;
+    loadSSOConfigurations: () => Promise<void>;
+    saveSSOConfigurations: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationPayload) => Promise<void>;
+    saveSSOConfigurationsFile: (configFile: File[]) => Promise<void>;
+    saveSSOConfigurationsFileWithCallback: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").SaveSSOConfigurationFilePayload) => Promise<void>;
+    validateSSODomain: (payload?: import("dist/@frontegg/redux-store/interfaces").WithCallback) => Promise<void>;
+    loadSSOAuthorizationRoles: () => Promise<void>;
+    updateSSOAuthorizationRoles: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").UpdateSSOAuthorizationRolesPayload) => Promise<void>;
+    deleteSamlGroup: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").DeleteSamlGroupPayload) => Promise<void>;
+    createSamlGroup: (payload: import("dist/@frontegg/redux-store/auth/SSOState/interfaces").CreateSamlGroupPayload) => Promise<void>;
+    oidcPostlogin: (payload: import("dist/@frontegg/rest-api").IOidcPostLogin) => Promise<void>;
+};

package/auth/sso.js

@@ -1,13 +1,8 @@
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-// @deprecated use useSSOState() instead
-export function useSSOState(stateMapper = defaultMapper) {
-  return stateMapper(useSnapshot(useStore().store.auth.ssoState));
-}
-export const useSSOActions = () => {
-  return useStore().stateActions.auth.ssoActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useSSOState,
+  useSliceActions: useSSOActions
+} = createSliceHooks({
+  getState: s => s.auth.ssoState,
+  getActions: a => a.auth.ssoActions
+});

package/auth/stepUp.d.ts

@@ -1,16 +1,17 @@
-import { StepUpState, StepUpActions, StepUpOptions, IsSteppedUpOptions } from '@frontegg/redux-store';
-export declare function useStepUpState(): StepUpState;
-export declare const useStepUpActions: () => StepUpActions;
-/**
- * @returns max age from the query param as a number or null if not exists
- */
+import { StepUpState, StepUpOptions, IsSteppedUpOptions } from '@frontegg/redux-store';
+export declare const useStepUpState: <S = StepUpState>(selector?: (s: StepUpState) => S) => S, useStepUpActions: () => {
+    stepUpHostedLogin: (payload: import("@frontegg/redux-store").IStepUpHostedLogin) => Promise<void>;
+    generateStepUpSession: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IGenerateStepUpSession>) => Promise<void>;
+    setStepUpState: (state: Partial<StepUpState>) => void;
+    resetStepUpState: () => void;
+    stepUpWithAuthenticator: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IStepUpWithAuthenticator>) => Promise<void>;
+    preVerifyMFASMSForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>>) => Promise<void>;
+    verifyMFASMSForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IVerifyMFASMS>>) => Promise<void>;
+    preVerifyMFAWebAuthnForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>, import("@frontegg/redux-store").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IVerifyMFAWebAuthnPayload>) => Promise<void>;
+    preVerifyMFAEmailCodeForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreVerifyMFA>) => Promise<void>;
+    verifyMFAEmailCodeForStepUp: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyMFAEmailCode>) => Promise<void>;
+};
 export declare const getMaxAgeFromQueryParam: () => number | undefined;
-/**
- * @returns step up function that redirects to the step up url with the max age param and set the redirect url in the local storage
- */
-export declare const useStepUp: () => ((options?: StepUpOptions) => void);
-/**
- * @param options.maxAge - max age of step up
- * @returns true when the user is stepped up, false otherwise
- */
+export declare const useStepUp: () => (options?: StepUpOptions) => void;
 export declare const useIsSteppedUp: (options?: IsSteppedUpOptions) => boolean;

package/auth/stepUp.js

@@ -1,26 +1,18 @@
 import { STEP_UP_MAX_AGE_PARAM_NAME, getSearchParam, redirectByStepUpUrl, isSteppedUp } from '@frontegg/redux-store';
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-import { useAuth, useAuthRoutes, useAuthUserOrNull, useOnRedirectTo } from './hooks';
 import { useCallback } from 'react';
-export function useStepUpState() {
-  return useSnapshot(useStore().store.auth.stepUpState);
-}
-export const useStepUpActions = () => {
-  return useStore().stateActions.auth.stepUpActions;
-};
-
-/**
- * @returns max age from the query param as a number or null if not exists
- */
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+import { useAuth, useAuthRoutes, useAuthUserOrNull, useOnRedirectTo } from './hooks';
+export const {
+  useSliceState: useStepUpState,
+  useSliceActions: useStepUpActions
+} = createSliceHooks({
+  getState: s => s.auth.stepUpState,
+  getActions: a => a.auth.stepUpActions
+});
 export const getMaxAgeFromQueryParam = () => {
   const str = getSearchParam(STEP_UP_MAX_AGE_PARAM_NAME);
   return str === undefined ? undefined : +str;
 };
-
-/**
- * @returns step up function that redirects to the step up url with the max age param and set the redirect url in the local storage
- */
 export const useStepUp = () => {
   const {
     stepUpUrl
@@ -40,11 +32,6 @@ export const useStepUp = () => {
     redirectByStepUpUrl(stepUpUrl, onRedirectTo, options == null ? void 0 : options.maxAge);
   }, [stepUpUrl, onRedirectTo, stepUpHostedLogin, hostedLoginBox]);
 };
-
-/**
- * @param options.maxAge - max age of step up
- * @returns true when the user is stepped up, false otherwise
- */
 export const useIsSteppedUp = (options = {}) => {
   const user = useAuthUserOrNull();
   return isSteppedUp(user, options);

package/auth/team.d.ts

@@ -1,13 +1,84 @@
-import { TeamActions, TeamState } from '@frontegg/redux-store';
-export declare function useTeamState(): TeamState;
-export declare const useTeamActions: () => TeamActions;
-export type AuthTeamStateMapper<S> = (state: TeamState) => S;
-/**
- * @deprecated use useTeamState instead
- */
-export declare function useAuthTeamState(): TeamState;
-export declare function useAuthTeamState<S>(stateMapper: AuthTeamStateMapper<S>): S;
-/**
- * @deprecated use useTeamActions instead
- */
-export declare const useAuthTeamActions: () => TeamActions;
+import type { TeamState } from '@frontegg/redux-store';
+export declare const useTeamState: <S = TeamState>(selector?: (s: TeamState) => S) => S, useTeamActions: () => {
+    getInvitationLink: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<{}>) => Promise<void>;
+    createInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ICreateOrUpdateInviteUserLink, string>) => Promise<void>;
+    updateInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ICreateOrUpdateInviteUserLink>) => Promise<void>;
+    deleteInvitationLink: (payload?: import("@frontegg/redux-store").WithCallback<{}, boolean>) => Promise<void>;
+    resendActivationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendActivationLink>) => Promise<void>;
+    resendInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationLink>) => Promise<void>;
+    resendInvitationEmail: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationEmail>) => Promise<void>;
+    resendInvitationLinkToAllSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationLink>) => Promise<void>;
+    loadAllSubTenantsUsers: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithSilentLoad<Partial<import("dist/@frontegg/rest-api").ILoadAllUsers>>, import("dist/@frontegg/rest-api").ISubTenantUser[]>) => Promise<void>;
+    setUserRolesForSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").UpdateUserRolesForSubTenantsRequestDto & {
+        userId: string;
+    }>) => Promise<void>;
+    deleteUserFromSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").RemoveUserFromSubTenantsRequest>) => Promise<void>;
+    addUserToSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").AddUserToSubTenantsRequest>) => Promise<void>;
+    loadRoles: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<import("dist/@frontegg/redux-store/auth/TeamState/interfaces").LoadRolesAndPermissionsPayload>) => Promise<void>;
+    loadUsers: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithSilentLoad<import("dist/@frontegg/rest-api").ILoadUsers>, import("dist/@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    loadUsersV2: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<import("@frontegg/redux-store").WithSilentLoad<import("@frontegg/redux-store").IGetUsersV2Payload>>, import("dist/@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    addUser: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").AddUserPayload, import("dist/@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    addUsersBulk: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IAddUsers, import("@frontegg/redux-store").BulkInvintationData>) => Promise<void>;
+    updateUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdateUser, import("dist/@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    deleteUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IDeleteUser>) => Promise<void>;
+    enableUser: (payload: import("@frontegg/redux-store").WithCallback<{
+        userId: string;
+    }>) => Promise<void>;
+    disableUser: (payload: import("@frontegg/redux-store").WithCallback<{
+        userId: string;
+    }>) => Promise<void>;
+    getTemporaryUsersConfig: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<{}>) => Promise<void>;
+    updateUserExpirationTime: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdateUserExpiration>) => Promise<void>;
+    setUserAsPermanent: (payload: import("@frontegg/redux-store").WithCallback<Pick<import("dist/@frontegg/rest-api").IUpdateUserExpiration, "userId">>) => Promise<void>;
+    setTeamLoader: (payload: import("@frontegg/redux-store").TeamStateIndicator) => void;
+    setTeamError: (payload: import("@frontegg/redux-store").TeamStateIndicator) => void;
+    setTeamState: (payload: Partial<TeamState>) => void;
+    resetTeamState: () => void;
+    openAddUserDialog: (payload?: import("@frontegg/redux-store").ISetAddUserDialog) => void;
+    closeAddUserDialog: (payload?: any) => void;
+    openDeleteUserDialog: (payload?: import("@frontegg/redux-store").ISetDeleteUserDialog) => void;
+    closeDeleteUserDialog: (payload?: any) => void;
+    lockUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IDeleteUser>) => Promise<void>;
+};
+export declare const useAuthTeamState: <S = TeamState>(selector?: (s: TeamState) => S) => S;
+export declare const useAuthTeamActions: () => {
+    getInvitationLink: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<{}>) => Promise<void>;
+    createInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ICreateOrUpdateInviteUserLink, string>) => Promise<void>;
+    updateInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ICreateOrUpdateInviteUserLink>) => Promise<void>;
+    deleteInvitationLink: (payload?: import("@frontegg/redux-store").WithCallback<{}, boolean>) => Promise<void>;
+    resendActivationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendActivationLink>) => Promise<void>;
+    resendInvitationLink: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationLink>) => Promise<void>;
+    resendInvitationEmail: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationEmail>) => Promise<void>;
+    resendInvitationLinkToAllSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendInvitationLink>) => Promise<void>;
+    loadAllSubTenantsUsers: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithSilentLoad<Partial<import("dist/@frontegg/rest-api").ILoadAllUsers>>, import("dist/@frontegg/rest-api").ISubTenantUser[]>) => Promise<void>;
+    setUserRolesForSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").UpdateUserRolesForSubTenantsRequestDto & {
+        userId: string;
+    }>) => Promise<void>;
+    deleteUserFromSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").RemoveUserFromSubTenantsRequest>) => Promise<void>;
+    addUserToSubTenants: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").AddUserToSubTenantsRequest>) => Promise<void>;
+    loadRoles: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<import("dist/@frontegg/redux-store/auth/TeamState/interfaces").LoadRolesAndPermissionsPayload>) => Promise<void>;
+    loadUsers: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithSilentLoad<import("dist/@frontegg/rest-api").ILoadUsers>, import("dist/@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    loadUsersV2: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<import("@frontegg/redux-store").WithSilentLoad<import("@frontegg/redux-store").IGetUsersV2Payload>>, import("dist/@frontegg/rest-api").ITeamUser[]>) => Promise<void>;
+    addUser: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").AddUserPayload, import("dist/@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    addUsersBulk: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IAddUsers, import("@frontegg/redux-store").BulkInvintationData>) => Promise<void>;
+    updateUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdateUser, import("dist/@frontegg/rest-api").ITeamUser>) => Promise<void>;
+    deleteUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IDeleteUser>) => Promise<void>;
+    enableUser: (payload: import("@frontegg/redux-store").WithCallback<{
+        userId: string;
+    }>) => Promise<void>;
+    disableUser: (payload: import("@frontegg/redux-store").WithCallback<{
+        userId: string;
+    }>) => Promise<void>;
+    getTemporaryUsersConfig: (payload?: import("dist/@frontegg/redux-store/interfaces").WithRetryConfig<{}>) => Promise<void>;
+    updateUserExpirationTime: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdateUserExpiration>) => Promise<void>;
+    setUserAsPermanent: (payload: import("@frontegg/redux-store").WithCallback<Pick<import("dist/@frontegg/rest-api").IUpdateUserExpiration, "userId">>) => Promise<void>;
+    setTeamLoader: (payload: import("@frontegg/redux-store").TeamStateIndicator) => void;
+    setTeamError: (payload: import("@frontegg/redux-store").TeamStateIndicator) => void;
+    setTeamState: (payload: Partial<TeamState>) => void;
+    resetTeamState: () => void;
+    openAddUserDialog: (payload?: import("@frontegg/redux-store").ISetAddUserDialog) => void;
+    closeAddUserDialog: (payload?: any) => void;
+    openDeleteUserDialog: (payload?: import("@frontegg/redux-store").ISetDeleteUserDialog) => void;
+    closeDeleteUserDialog: (payload?: any) => void;
+    lockUser: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IDeleteUser>) => Promise<void>;
+};

package/auth/team.js

@@ -1,25 +1,14 @@
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-export function useTeamState() {
-  const state = useStore().store.auth.teamState;
-  return useSnapshot(state);
-}
-export const useTeamActions = () => {
-  return useStore().stateActions.auth.teamActions;
-};
-const defaultMapper = state => state;
-/**
- * @deprecated use useTeamState instead
- */
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useTeamState,
+  useSliceActions: useTeamActions
+} = createSliceHooks({
+  getState: s => s.auth.teamState,
+  getActions: a => a.auth.teamActions
+});
 
-// @deprecated use useTeamState() instead
-export function useAuthTeamState(stateMapper = defaultMapper) {
-  return stateMapper(useTeamState());
-}
+/* @deprecated use useTeamActions instead */
+export const useAuthTeamState = useTeamState;
 
-/**
- * @deprecated use useTeamActions instead
- */
-export const useAuthTeamActions = () => {
-  return useTeamActions();
-};
+/* @deprecated use useTeamActions instead */
+export const useAuthTeamActions = useTeamActions;

package/auth/tenants.d.ts

@@ -1,3 +1,9 @@
-import type { TenantsState, TenantsActions } from '@frontegg/redux-store';
-export declare function useTenantsState(): TenantsState;
-export declare const useTenantsActions: () => TenantsActions;
+import type { TenantsState } from '@frontegg/redux-store';
+export declare const useTenantsState: <S = TenantsState>(selector?: (s: TenantsState) => S) => S, useTenantsActions: () => {
+    setTenantsState: (state: Partial<TenantsState>) => void;
+    resetTenantsState: () => void;
+    switchTenant: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").SwitchTenantOptions>) => Promise<void>;
+    loadTenants: (payload?: import("@frontegg/redux-store").WithCallback<{}, import("dist/@frontegg/rest-api").ITenantsResponse[]>) => Promise<void>;
+    loadSubTenants: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>>) => Promise<void>;
+    loadSubTenantsTree: (payload?: import("@frontegg/redux-store").WithCallback<{}>) => Promise<void>;
+};