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

package/auth/forgotPassword.js

@@ -1,9 +1,10 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useForgotPasswordState() {
-  const state = useStore().store.auth.forgotPasswordState;
-  return useSnapshot(state);
-}
-export const useForgotPasswordActions = () => {
-  return useStore().stateActions.auth.forgotPasswordActions;
-};
+// forgotPasswordHooks.ts
+
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useForgotPasswordState,
+  useSliceActions: useForgotPasswordActions
+} = createSliceHooks({
+  getState: s => s.auth.forgotPasswordState,
+  getActions: a => a.auth.forgotPasswordActions
+});

package/auth/groups.d.ts

@@ -1,5 +1,32 @@
-import { GroupsState, GroupsActions, GroupsDialogsState, GroupsDialogsActions } from '@frontegg/redux-store';
-export declare function useGroupsState(): GroupsState;
-export declare const useGroupsActions: () => GroupsActions;
-export declare function useGroupsDialogsState(): GroupsDialogsState;
-export declare const useGroupsDialogsActions: () => GroupsDialogsActions;
+import type { GroupsState, GroupsDialogsState } from '@frontegg/redux-store';
+export declare const useGroupsState: <S = GroupsState>(selector?: (s: GroupsState) => S) => S, useGroupsActions: () => {
+    setUsersGroupsLoader: (payload: import("@frontegg/redux-store").GroupsStateIndicator) => void;
+    setUsersGroupsError: (payload: import("@frontegg/redux-store").GroupsStateIndicator) => void;
+    setGroupsState: (payload: Partial<GroupsState>) => void;
+    resetUsersGroupsState: () => void;
+    loadGroups: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    getGroupById: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["getGroupById"]) => Promise<void>;
+    createGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["createGroup"]) => Promise<void>;
+    updateGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["updateGroup"]) => Promise<void>;
+    deleteGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["deleteGroup"]) => Promise<void>;
+    addRolesToGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["addRolesToGroup"]) => Promise<void>;
+    deleteRolesFromGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["deleteRolesFromGroup"]) => Promise<void>;
+    addUsersToGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["addUsersToGroup"]) => Promise<void>;
+    deleteUsersFromGroup: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["deleteUsersFromGroup"]) => Promise<void>;
+    getGroupConfiguration: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    updateGroupConfiguration: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["updateGroupConfiguration"]) => Promise<void>;
+    getTeamUsers: (payload: import("@frontegg/redux-store").IGroupsStateActionsPayloads["getTeamUsers"]) => Promise<void>;
+}, useGroupsDialogsState: () => GroupsDialogsState, useGroupsDialogsActions: () => {
+    setGroupsDialogsState: (payload: Partial<GroupsDialogsState>) => void;
+    resetGroupsDialogsState: () => void;
+    openAddGroupDialog: () => void;
+    closeAddGroupDialog: () => void;
+    openAddMembersToGroupDialog: () => void;
+    closeAddMembersToGroupDialog: () => void;
+    openEditGroupDialog: (payload: Partial<Pick<import("@frontegg/redux-store").EditGroupDialogState, "group">>) => void;
+    closeEditGroupDialog: () => void;
+    openDeleteGroupDialog: (payload: Partial<Pick<import("@frontegg/redux-store").EditGroupDialogState, "group">>) => void;
+    closeDeleteGroupDialog: () => void;
+    openDeleteMemberFromGroupDialog: (payload: Pick<import("@frontegg/redux-store").DeleteMemberFromGroupDialogState, "userId" | "email">) => void;
+    closeDeleteMemberFromGroupDialog: () => void;
+};

package/auth/groups.js

@@ -1,14 +1,14 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useGroupsState() {
-  return useSnapshot(useStore().store.auth.groupsState);
-}
-export const useGroupsActions = () => {
-  return useStore().stateActions.auth.groupsActions;
-};
-export function useGroupsDialogsState() {
-  return useSnapshot(useStore().store.auth.groupsDialogsState);
-}
-export const useGroupsDialogsActions = () => {
-  return useStore().stateActions.auth.groupsDialogsActions;
-};
+// groupsHooks.ts
+
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useGroupsState,
+  useSliceActions: useGroupsActions,
+  useSliceDialogsState: useGroupsDialogsState,
+  useSliceDialogsActions: useGroupsDialogsActions
+} = createSliceHooks({
+  getState: s => s.auth.groupsState,
+  getActions: a => a.auth.groupsActions,
+  getDialogsState: s => s.auth.groupsDialogsState,
+  getDialogsActions: a => a.auth.groupsDialogsActions
+});

package/auth/impersonate.d.ts

@@ -1,3 +1,6 @@
-import { ImpersonateState, ImpersonateActions } from '@frontegg/redux-store';
-export declare function useImpersonateState(): ImpersonateState;
-export declare const useImpersonateActions: () => ImpersonateActions;
+import type { ImpersonateState } from '@frontegg/redux-store';
+export declare const useImpersonateState: <S = ImpersonateState>(selector?: (s: ImpersonateState) => S) => S, useImpersonateActions: () => {
+    setImpersonateState: (state: Partial<ImpersonateState>) => void;
+    resetImpersonateState: () => void;
+    impersonate: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IImpersonatePayload>) => Promise<void>;
+};

package/auth/impersonate.js

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

package/auth/login.d.ts

@@ -1,3 +1,74 @@
-import type { LoginState, LoginActions } from '@frontegg/redux-store';
-export declare function useLoginState(): LoginState;
-export declare const useLoginActions: () => LoginActions;
+import type { LoginState } from '@frontegg/redux-store';
+export declare const useLoginState: <S = LoginState>(selector?: (s: LoginState) => S) => S, useLoginActions: () => {
+    preVerifyMFAWebAuthn: ({ callback, deviceId, ...payload }: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>, import("@frontegg/redux-store").IPreVerifyMFAWebAuthNForLoginResponse>, setLoadingAction: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction) => Promise<void>;
+    verifyMFAWebAuthn: ({ callback, deviceId, ...payload }: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").IVerifyMFAWebAuthnPayload, setLoadingAction: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    preVerifyMFAWebAuthnForLogin: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>, import("@frontegg/redux-store").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForLogin: (payload: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").IVerifyMFAWebAuthnPayload) => Promise<void>;
+    preVerifyMFASMS: ({ callback, deviceId, ...payload }: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>>, setLoadingAction: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction) => Promise<void>;
+    verifyMFASMS: ({ callback, deviceId, ...payload }: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IVerifyMFASMS>>, setLoadingAction: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction, isStepUp?: boolean) => Promise<void>;
+    preVerifyMFASMSForLogin: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IPreVerifyMFA>>) => Promise<void>;
+    verifyMFASMSForLogin: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithDeviceId<import("dist/@frontegg/rest-api").IVerifyMFASMS>>) => Promise<void>;
+    preVerifyMFAEmailCode: ({ callback, ...payload }: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreVerifyMFA>, setLoadingAction?: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction) => Promise<void>;
+    verifyMFAEmailCode: ({ callback, ...payload }: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyMFAEmailCode>, setLoadingAction?: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction) => Promise<void>;
+    preVerifyMFAEmailCodeForLogin: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreVerifyMFA>) => Promise<void>;
+    verifyMFAEmailCodeForLogin: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyMFAEmailCode>) => Promise<void>;
+    mfaWithAuthenticator: ({ callback, ...loginWithMfaPayload }: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ILoginWithMfa>, setLoadingAction: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    loginWithMfa: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ILoginWithMfa>) => Promise<void>;
+    getMfaRequiredState: (user: import("dist/@frontegg/redux-store/auth/interfaces").User | any, retryConfig?: import("dist/@frontegg/redux-store/interfaces").RetryConfig, shouldContinueWhenFailing?: boolean, emailFromSignup?: string) => Promise<Partial<import("@frontegg/redux-store").AuthState> & {
+        mfaState: Partial<import("@frontegg/redux-store").MFAState>;
+        loginState: Partial<LoginState>;
+    }>;
+    postHandleVerifyMFAResponseForStepUp: () => Promise<void>;
+    postHandleVerifyMFAResponseForLogin: (isAuthenticated: boolean, user: import("dist/@frontegg/rest-api").ILoginResponse) => Promise<void>;
+    handleVerifyMFAResponse: (payload: import("dist/@frontegg/rest-api").ILoginResponseV3, isStepUp?: boolean) => Promise<void>;
+    getFeatureFlags: (flags: string[]) => Promise<boolean[]>;
+    afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").AfterAuthNavigationUtilOptions) => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<import("@frontegg/redux-store").AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning">) => Promise<void>;
+    afterStepUpAuthNavigation: () => Promise<void>;
+    afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: import("dist/@frontegg/rest-api").ILoginResponseV3, additionalUpdate?: Partial<import("@frontegg/redux-store").AuthState>) => void;
+    requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
+    requestHostedLoginAuthorizeV2: (payload?: {
+        additionalParams?: Record<string, string>;
+        shouldRedirectToLogin?: boolean;
+        firstTime?: boolean;
+        loginDirectAction?: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").LoginDirectAction;
+    }) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
+    __requestHostedLoginSilentAuthorize: () => Promise<void>;
+    handleHostedLoginCallback: (payload: import("dist/@frontegg/redux-store/auth/LoginState/interfaces").HostedLoginCallback) => Promise<void>;
+    setLoginState: (state: Partial<LoginState>) => void;
+    resetLoginState: () => void;
+    requestAuthorize: (firstTime?: boolean) => Promise<void>;
+    requestAuthorizeSSR: (payload: import("@frontegg/redux-store").FronteggNextJSSession) => Promise<void>;
+    preLogin: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreLogin & {
+        recaptchaToken?: string;
+        invitationToken?: string;
+    }, void>) => Promise<void>;
+    postLogin: (payload: import("dist/@frontegg/rest-api").IPostLogin) => Promise<void>;
+    login: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").ILogin>) => Promise<void>;
+    logout: (payload?: () => void) => Promise<void>;
+    silentLogout: (payload?: import("@frontegg/redux-store").WithCallback<{
+        callbackTimeout?: number;
+    }>) => Promise<void>;
+    recoverMfa: (payload: import("@frontegg/redux-store").IRecoverMFATokenPayload) => Promise<void>;
+    quickSmsPasswordlessPreLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IQuickSmsPasswordlessPreLoginPayload>) => Promise<void>;
+    changePhoneNumberWithVerification: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IChangePhoneNumberWithVerification>) => Promise<void>;
+    verifyChangePhoneNumber: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyChangePhoneNumber>) => Promise<void>;
+    passwordlessPreLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPasswordlessPreLogin, void>) => Promise<void>;
+    passwordlessPostLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IPasswordlessPostLoginPayload>) => Promise<void>;
+    verifyInviteToken: (payload: import("dist/@frontegg/rest-api").IVerifyInviteToken) => Promise<void>;
+    webAuthnPrelogin: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IWebAuthnPreLogin, import("dist/@frontegg/rest-api").IWebAuthnPreLoginResponse | null>) => Promise<void>;
+    webAuthnPostLogin: (payload: import("@frontegg/redux-store").IWebAuthnPostLoginPayload) => Promise<void>;
+    webAuthnCreateNewDeviceSession: (payload: import("@frontegg/redux-store").WithCallback<{}, import("dist/@frontegg/rest-api").ICreateNewDeviceSessionResponse | null>) => Promise<void>;
+    webAuthnVerifyNewDeviceSession: (payload: import("@frontegg/redux-store").IVerifyNewWebAuthnDevicePayload) => Promise<void>;
+    getUserIP: (payload: import("@frontegg/redux-store").WithCallback<{}, import("@frontegg/redux-store").UserIPData | boolean>) => Promise<void>;
+    preEnrollMFAWebAuthnForLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreEnrollMFA, import("@frontegg/redux-store").IPreEnrollMFAWebAuthNForLoginResponse>) => Promise<void>;
+    enrollMFAWebAuthnForLogin: (_payload: import("@frontegg/redux-store").IEnrollMFAWebAuthnPayload) => Promise<void>;
+    enrollMFAAuthenticatorAppForLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IEnrollMFAAuthenticatorApp>) => Promise<void>;
+    preEnrollMFASMSForLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPreEnrollMFASMS>) => Promise<void>;
+    enrollMFASMSForLogin: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IEnrollMFASMS>) => Promise<void>;
+    handleEnrollMFAResponse: (payload: import("dist/@frontegg/rest-api").ILoginResponseV3) => Promise<void>;
+    resetBreachedPassword: (payload: import("dist/@frontegg/rest-api").IForgotPassword) => Promise<void>;
+    refreshTokenForSocialLogins: () => Promise<void>;
+    __refreshToken: () => Promise<void>;
+};

package/auth/login.js

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

package/auth/passkeys.d.ts

@@ -1,3 +1,10 @@
-import type { PasskeysActions, PasskeysState } from '@frontegg/redux-store';
-export declare function usePasskeysState(): PasskeysState;
-export declare const usePasskeysActions: () => PasskeysActions;
+import type { PasskeysState } from '@frontegg/redux-store';
+export declare const usePasskeysState: <S = PasskeysState>(selector?: (s: PasskeysState) => S) => S, usePasskeysActions: () => {
+    setPasskeysState: (payload: Partial<PasskeysState>) => void;
+    resetPasskeysState: () => void;
+    loadWebAuthnDevices: () => Promise<void>;
+    deleteWebAuthnDevice: (_payload: import("@frontegg/redux-store").WithCallback<{
+        deviceId: string;
+    }>) => Promise<void>;
+    __shouldShowPromptPasskeys: () => Promise<boolean>;
+};

package/auth/passkeys.js

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

package/auth/passwordRotation.d.ts

@@ -1,3 +1,4 @@
-import { PasswordRotationState, PasswordRotationActions } from '@frontegg/redux-store';
-export declare function usePasswordRotationState(): PasswordRotationState;
-export declare const usePasswordRotationActions: () => PasswordRotationActions;
+import type { PasswordRotationState } from '@frontegg/redux-store';
+export declare const usePasswordRotationState: <S = PasswordRotationState>(selector?: (s: PasswordRotationState) => S) => S, usePasswordRotationActions: () => {
+    setStep: (step: import("@frontegg/redux-store").PasswordRotationStep) => void;
+};

package/auth/passwordRotation.js

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

package/auth/profile.d.ts

@@ -1,4 +1,20 @@
-import type { ProfileActions, ProfileState } from '@frontegg/redux-store';
-export declare function useProfileState(): ProfileState;
-export declare const useProfileActions: () => ProfileActions;
+import type { ProfileState } from '@frontegg/redux-store';
+export declare const useProfileState: <S = ProfileState>(selector?: (s: ProfileState) => S) => S, useProfileActions: () => {
+    setProfileState: (state: Partial<ProfileState>) => void;
+    resetProfileState: () => void;
+    loadProfile: () => Promise<void>;
+    saveProfile: (_payload: import("@frontegg/redux-store").SaveProfilePayload) => Promise<void>;
+    changePassword: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IChangePassword>) => Promise<void>;
+    updateEmail: (payload: import("@frontegg/redux-store").WithCallback<{
+        email: string;
+    }, boolean>) => Promise<void>;
+    verifyEmail: (payload: import("@frontegg/redux-store").WithCallback<{
+        email: string;
+        code: string;
+    }, boolean>) => Promise<void>;
+};
+export declare const useReloadProfileIfNeeded: () => void;
+/**
+ * @deprecated use `useReloadProfileIfNeeded` instead
+ */
 export declare const reloadProfileIfNeeded: () => void;

package/auth/profile.js

@@ -1,13 +1,13 @@
 import { useEffect } from 'react';
-import { useSnapshot } from '../useSnapshot';
-import { useStore } from '../FronteggStoreContext';
-export function useProfileState() {
-  return useSnapshot(useStore().store.auth.profileState);
-}
-export const useProfileActions = () => {
-  return useStore().stateActions.auth.profileActions;
-};
-export const reloadProfileIfNeeded = () => {
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useProfileState,
+  useSliceActions: useProfileActions
+} = createSliceHooks({
+  getState: s => s.auth.profileState,
+  getActions: a => a.auth.profileActions
+});
+export const useReloadProfileIfNeeded = () => {
   const {
     loading
   } = useProfileState();
@@ -15,6 +15,11 @@ export const reloadProfileIfNeeded = () => {
     loadProfile
   } = useProfileActions();
   useEffect(() => {
-    !loading && loadProfile();
-  }, []);
-};
+    if (!loading) loadProfile();
+  }, [loading, loadProfile]);
+};
+
+/**
+ * @deprecated use `useReloadProfileIfNeeded` instead
+ */
+export const reloadProfileIfNeeded = useReloadProfileIfNeeded;

package/auth/provisioning.d.ts

@@ -1,3 +1,20 @@
-import type { ProvisioningActions, ProvisioningState } from '@frontegg/redux-store';
-export declare function useProvisioningState(): ProvisioningState;
-export declare const useProvisioningActions: () => ProvisioningActions;
+import type { ProvisioningState } from '@frontegg/redux-store';
+export declare const useProvisioningState: <S = ProvisioningState>(selector?: (s: ProvisioningState) => S) => S, useProvisioningActions: () => {
+    setProvisioningState: (state: Partial<ProvisioningState>) => void;
+    resetProvisioningState: () => void;
+    __loadCountForConnection: (connection: import("dist/@frontegg/rest-api").Scim2ConnectionConfigResponse, retryConfig?: import("@frontegg/redux-store").RetryConfig) => Promise<{
+        count: number;
+        id: string;
+        connectionName: string;
+        source: import("dist/@frontegg/rest-api").ScimConnectionSource;
+        syncToUserManagement: boolean;
+        createdAt: Date;
+        lastSync?: Date | null;
+    }>;
+    loadProvisionConnections: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    createProvisionConnection: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").Scim2CreateConnectionConfigRequest, import("dist/@frontegg/rest-api").Scim2CreateConnectionConfigResponse>) => Promise<void>;
+    deleteProvisionConnection: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithId & {
+        deleteAll: boolean;
+    }>) => Promise<void>;
+    updateProvisionConnection: (payload: import("@frontegg/redux-store").WithId<import("dist/@frontegg/rest-api").Scim2PatchConnectionConfigRequest>) => Promise<void>;
+};

package/auth/provisioning.js

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

package/auth/resetPhoneNumber.d.ts

@@ -1,3 +1,8 @@
-import type { ResetPhoneNumberState, ResetPhoneNumberActions } from '@frontegg/redux-store';
-export declare function useResetPhoneNumberState(): ResetPhoneNumberState;
-export declare const useResetPhoneNumberActions: () => ResetPhoneNumberActions;
+import type { ResetPhoneNumberState } from '@frontegg/redux-store';
+export declare const useResetPhoneNumberState: <S = ResetPhoneNumberState>(selector?: (s: ResetPhoneNumberState) => S) => S, useResetPhoneNumberActions: () => {
+    setResetPhoneNumberState: (state: Partial<ResetPhoneNumberState>) => void;
+    resetResetPhoneNumberState: () => void;
+    resetPhoneNumber: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResetPhoneNumber>) => Promise<void>;
+    verifyResetPhoneNumber: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IVerifyResetPhoneNumber>) => Promise<void>;
+    changePhoneNumber: (payload: import("@frontegg/redux-store").ChangePhoneNumberPayload) => Promise<void>;
+};

package/auth/resetPhoneNumber.js

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

package/auth/roles.d.ts

@@ -1,3 +1,14 @@
-import type { RolesActions, RolesState } from '@frontegg/redux-store';
-export declare function useRolesState(): RolesState;
-export declare const useRolesActions: () => RolesActions;
+import type { RolesState } from '@frontegg/redux-store';
+export declare const useRolesState: <S = RolesState>(selector?: (s: RolesState) => S) => S, useRolesActions: () => {
+    setRolesState: (state: Partial<RolesState>) => void;
+    setRolesStateLoader: (payload: import("@frontegg/redux-store").RolesStateIndicator) => void;
+    setRolesStateError: (payload: import("@frontegg/redux-store").RolesStateIndicator) => void;
+    resetRolesState: () => void;
+    loadRolesAndPermissions: (payload?: import("@frontegg/redux-store").WithRetryConfig<import("@frontegg/redux-store").WithSilentLoad<{}>>) => Promise<void>;
+    addRole: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IAddRole, import("dist/@frontegg/rest-api").IRole>) => Promise<void>;
+    addRoleV2: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IAddRoleV2, import("dist/@frontegg/rest-api").IRole>) => Promise<void>;
+    updateRole: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IUpdateRole, import("dist/@frontegg/rest-api").IRole>) => Promise<void>;
+    deleteRole: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IDeleteRole>) => Promise<void>;
+    attachPermissionsToRole: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IAttachPermissionsToRole, import("dist/@frontegg/rest-api").IRole>) => Promise<void>;
+    attachPermissionToRoles: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IAttachPermissionToRoles>) => Promise<void>;
+};

package/auth/roles.js

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

package/auth/security/restrictions.d.ts

@@ -1,6 +1,24 @@
-import { RestrictionsActions, RestrictionsState } from '@frontegg/redux-store';
-export declare function useRestrictionsState(): RestrictionsState;
-export declare const useRestrictionsActions: () => RestrictionsActions;
+import type { RestrictionsState } from '@frontegg/redux-store';
+export declare const useRestrictionsState: <S = RestrictionsState>(selector?: (s: RestrictionsState) => S) => S, useRestrictionsActions: () => {
+    setRestrictionsState: (state: Partial<RestrictionsState>) => void;
+    setIpRestrictionsState: (state: Partial<import("@frontegg/redux-store").IPRestrictionsState>) => void;
+    setEmailDomainRestrictionsState: (state: Partial<import("@frontegg/redux-store").EmailDomainRestrictionsState>) => void;
+    __securityCenterSagaWrapper: <T>(action: T) => T;
+    loadIpRestrictions: () => Promise<void>;
+    saveIpRestriction: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").CreateIpRestriction>) => Promise<void>;
+    saveIpRestrictionsConfig: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IPRestrictionsConfig>) => Promise<void>;
+    deleteIpRestriction: (payload: import("@frontegg/redux-store").WithCallback<{
+        id: string;
+    }>) => Promise<void>;
+    checkIfUserIpValid: () => Promise<void>;
+    addCurrentUserIpAndActivate: (payload: import("@frontegg/redux-store").WithCallback) => Promise<void>;
+    loadEmailDomainRestrictions: () => Promise<void>;
+    saveEmailDomainRestriction: (payload: import("@frontegg/redux-store").SaveEmailDomainRestrictionsPayload) => Promise<void>;
+    saveEmailDomainRestrictionsConfig: (payload: import("@frontegg/redux-store").SaveEmailDomainRestrictionConfigPayload) => Promise<void>;
+    deleteEmailDomainRestriction: (payload: {
+        id: string;
+    }) => Promise<void>;
+};
 export declare const useIpRestrictions: () => {
     loading: boolean;
     saving: boolean | undefined;

package/auth/security/restrictions.js

@@ -1,14 +1,16 @@
 import { useEffect } from 'react';
-import { useStore } from '../../FronteggStoreContext';
-import { useSnapshot } from '../../useSnapshot';
-export function useRestrictionsState() {
-  const state = useStore().store.auth.restrictionsState;
-  return useSnapshot(state);
-}
-export const useRestrictionsActions = () => {
-  return useStore().stateActions.auth.restrictionsActions;
-};
+import { createSliceHooks } from '../../useSnapshot/hookFactory';
+export const {
+  useSliceState: useRestrictionsState,
+  useSliceActions: useRestrictionsActions
+} = createSliceHooks({
+  getState: s => s.auth.restrictionsState,
+  getActions: a => a.auth.restrictionsActions
+});
 export const useIpRestrictions = () => {
+  const {
+    ipRestrictions
+  } = useRestrictionsState();
   const {
     loading,
     data,
@@ -17,15 +19,13 @@ export const useIpRestrictions = () => {
     pagination,
     totalPages,
     userIpValid
-  } = useRestrictionsState().ipRestrictions;
+  } = ipRestrictions;
   const {
     loadIpRestrictions
   } = useRestrictionsActions();
   useEffect(() => {
-    if (!data && !loading) {
-      loadIpRestrictions();
-    }
-  }, [loadIpRestrictions, data, loading]);
+    if (!data && !loading) loadIpRestrictions();
+  }, [data, loading, loadIpRestrictions]);
   return {
     loading,
     saving,
@@ -37,20 +37,21 @@ export const useIpRestrictions = () => {
   };
 };
 export const useEmailDomainRestrictions = () => {
+  const {
+    emailDomainRestrictions
+  } = useRestrictionsState();
   const {
     loading,
     data,
     saving,
     error
-  } = useRestrictionsState().emailDomainRestrictions;
+  } = emailDomainRestrictions;
   const {
     loadEmailDomainRestrictions
   } = useRestrictionsActions();
   useEffect(() => {
-    if (!data && !loading) {
-      loadEmailDomainRestrictions();
-    }
-  }, [loadEmailDomainRestrictions, data, loading]);
+    if (!data && !loading) loadEmailDomainRestrictions();
+  }, [data, loading, loadEmailDomainRestrictions]);
   return {
     loading,
     saving,

package/auth/security/securityCenter.d.ts

@@ -1,3 +1,15 @@
-import type { SecurityCenterActions, SecurityCenterState } from '@frontegg/redux-store';
-export declare function useSecurityCenterState(): SecurityCenterState;
-export declare const useSecurityCenterActions: () => SecurityCenterActions;
+import type { SecurityCenterState } from '@frontegg/redux-store';
+export declare const useSecurityCenterState: <S = SecurityCenterState>(selector?: (s: SecurityCenterState) => S) => S, useSecurityCenterActions: () => {
+    setSecurityCenterState: (state: Partial<SecurityCenterState>) => void;
+    resetSecurityCenterState: () => void;
+    setSecurityCenterStateLoader: (payload: import("@frontegg/redux-store").SecurityCenterStateIndicator) => void;
+    setSecurityCenterStateError: (payload: import("@frontegg/redux-store").SecurityCenterStateIndicator) => void;
+    loadRecommendations: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadInsights: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    sendResetBreachedPasswordEmail: (_payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IForgotPassword>) => Promise<void>;
+    sendBulkResetBreachedPasswordEmails: (payload: import("@frontegg/redux-store").WithCallback) => Promise<void>;
+    loadBreachedPasswordUsers: (payload: import("dist/@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+    loadUnenrolledMfaUsers: (payload: import("dist/@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+    loadInactiveUsers: (payload: import("dist/@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+    markSecurityCenterStateAsChanged: (changed?: boolean) => void;
+};

package/auth/security/securityCenter.js

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