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

package/auth/security/securityPolicy.d.ts

@@ -1,37 +1,7 @@
-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>;
-};
+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;
 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,12 +1,18 @@
 import { useEffect } from 'react';
-import { createSliceHooks } from '../../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSecurityPolicyState,
-  useSliceActions: useSecurityPolicyActions
-} = createSliceHooks({
-  getState: s => s.auth.securityPolicyState,
-  getActions: a => a.auth.securityPolicyActions
-});
+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;
+};
 export const usePublicPolicySettings = (loadOnMount = false) => {
   const {
     publicPolicy
@@ -15,10 +21,8 @@ export const usePublicPolicySettings = (loadOnMount = false) => {
     loadPublicSecurityPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    if ((loadOnMount || !publicPolicy.policy) && !publicPolicy.loading) {
-      loadPublicSecurityPolicy();
-    }
-  }, [loadOnMount, publicPolicy.policy, publicPolicy.loading, loadPublicSecurityPolicy]);
+    (loadOnMount || !publicPolicy.policy) && loadPublicSecurityPolicy();
+  }, [loadOnMount, loadPublicSecurityPolicy]);
   return publicPolicy;
 };
 export const usePublicAuthStrategiesPolicySettings = (loadOnMount = false) => {
@@ -29,9 +33,7 @@ export const usePublicAuthStrategiesPolicySettings = (loadOnMount = false) => {
     loadPublicAuthStrategiesPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    if ((loadOnMount || !publicAuthStrategyPolicy.policy) && !publicAuthStrategyPolicy.error && !publicAuthStrategyPolicy.loading) {
-      loadPublicAuthStrategiesPolicy();
-    }
-  }, [loadOnMount, publicAuthStrategyPolicy.policy, publicAuthStrategyPolicy.error, publicAuthStrategyPolicy.loading, loadPublicAuthStrategiesPolicy]);
+    (loadOnMount || !publicAuthStrategyPolicy.policy) && !publicAuthStrategyPolicy.error && loadPublicAuthStrategiesPolicy();
+  }, [loadOnMount, loadPublicAuthStrategiesPolicy]);
   return publicAuthStrategyPolicy;
 };

package/auth/security/sessionsPolicy.d.ts

@@ -1,7 +1,3 @@
-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>;
-};
+import type { SessionsPolicyState, SessionsPolicyActions } from '@frontegg/redux-store';
+export declare function useSessionsPolicyState(): SessionsPolicyState;
+export declare const useSessionsPolicyActions: () => SessionsPolicyActions;

package/auth/security/sessionsPolicy.js

@@ -1,8 +1,9 @@
-import { createSliceHooks } from '../../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSessionsPolicyState,
-  useSliceActions: useSessionsPolicyActions
-} = createSliceHooks({
-  getState: s => s.auth.sessionsPolicyState,
-  getActions: a => a.auth.sessionsPolicyActions
-});
+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;
+};

package/auth/sessions.d.ts

@@ -1,12 +1,3 @@
-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>;
-};
+import type { SessionsState, SessionsActions } from '@frontegg/redux-store';
+export declare function useSessionsState(): SessionsState;
+export declare const useSessionsActions: () => SessionsActions;

package/auth/sessions.js

@@ -1,8 +1,8 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSessionsState,
-  useSliceActions: useSessionsActions
-} = createSliceHooks({
-  getState: s => s.auth.sessionsState,
-  getActions: a => a.auth.sessionsActions
-});
+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;
+};

package/auth/signup.d.ts

@@ -1,10 +1,5 @@
-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>;
-};
+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;

package/auth/signup.js

@@ -1,8 +1,16 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSignUpState,
-  useSliceActions: useSignUpActions
-} = createSliceHooks({
-  getState: s => s.auth.signUpState,
-  getActions: a => a.auth.signUpActions
-});
+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;
+};

package/auth/sms.d.ts

@@ -1,13 +1,3 @@
-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>;
-};
+import type { SmsActions, SmsState } from '@frontegg/redux-store';
+export declare function useSmsState(): SmsState;
+export declare const useSmsActions: () => SmsActions;

package/auth/sms.js

@@ -1,8 +1,8 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSmsState,
-  useSliceActions: useSmsActions
-} = createSliceHooks({
-  getState: s => s.auth.smsState,
-  getActions: a => a.auth.smsActions
-});
+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;
+};

package/auth/socialLogin.d.ts

@@ -1,9 +1,5 @@
-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>;
-};
+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;

package/auth/socialLogin.js

@@ -1,8 +1,13 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSocialLoginState,
-  useSliceActions: useSocialLoginActions
-} = createSliceHooks({
-  getState: s => s.auth.socialLoginState,
-  getActions: a => a.auth.socialLoginActions
-});
+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;
+};

package/auth/sso.d.ts

@@ -1,31 +1,6 @@
-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>;
-};
+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 {};

package/auth/sso.js

@@ -1,8 +1,13 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useSSOState,
-  useSliceActions: useSSOActions
-} = createSliceHooks({
-  getState: s => s.auth.ssoState,
-  getActions: a => a.auth.ssoActions
-});
+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;
+};

package/auth/stepUp.d.ts

@@ -1,17 +1,16 @@
-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>;
-};
+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
+ */
 export declare const getMaxAgeFromQueryParam: () => number | undefined;
-export declare const useStepUp: () => (options?: StepUpOptions) => void;
+/**
+ * @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 useIsSteppedUp: (options?: IsSteppedUpOptions) => boolean;

package/auth/stepUp.js

@@ -1,18 +1,26 @@
 import { STEP_UP_MAX_AGE_PARAM_NAME, getSearchParam, redirectByStepUpUrl, isSteppedUp } from '@frontegg/redux-store';
-import { useCallback } from 'react';
-import { createSliceHooks } from '../useSnapshot/hookFactory';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
 import { useAuth, useAuthRoutes, useAuthUserOrNull, useOnRedirectTo } from './hooks';
-export const {
-  useSliceState: useStepUpState,
-  useSliceActions: useStepUpActions
-} = createSliceHooks({
-  getState: s => s.auth.stepUpState,
-  getActions: a => a.auth.stepUpActions
-});
+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
+ */
 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
@@ -32,6 +40,11 @@ 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,84 +1,13 @@
-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>;
-};
+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;

package/auth/team.js

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

package/auth/tenants.d.ts

@@ -1,9 +1,3 @@
-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>;
-};
+import type { TenantsState, TenantsActions } from '@frontegg/redux-store';
+export declare function useTenantsState(): TenantsState;
+export declare const useTenantsActions: () => TenantsActions;