@frontegg/redux-store 7.2.0-alpha.2 → 7.2.0

package/audits/AuditLogsState/interfaces.d.ts

@@ -1,6 +1,6 @@
 import { AuditRowData, QueryFilter, QuerySort } from '@frontegg/rest-api';
 import { WithCallback, WithSilentLoad } from '../../interfaces';
-export declare type LoadAuditLogsPayload = WithSilentLoad<WithCallback<{
+export type LoadAuditLogsPayload = WithSilentLoad<WithCallback<{
     pageOffset: number;
     pageSize?: number;
     filter?: QueryFilter[];

package/audits/AuditLogsState/state.d.ts

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

package/audits/AuditsMetadataState/state.d.ts

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

package/audits/index.d.ts

@@ -2,7 +2,7 @@ import { buildAuditLogsActions } from './AuditLogsState';
 import { buildAuditsMetadataActions } from './AuditsMetadataState';
 import { DeepPartial, FronteggState, RestApi, SharedActions } from '../interfaces';
 import { AuditsState } from './interfaces';
-export declare const createAuditsState: (overrideState?: DeepPartial<AuditsState> | undefined) => AuditsState;
+export declare const createAuditsState: (overrideState?: DeepPartial<AuditsState>) => AuditsState;
 export declare const buildAuditsActions: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
     setAuditsMetadataState: (state: Partial<import("./interfaces").AuditsMetadataState>) => void;
     resetAuditsMetadataState: () => void;
@@ -10,11 +10,6 @@ export declare const buildAuditsActions: (store: FronteggState, api: RestApi, sh
     setAuditLogsState: (state: Partial<import("./interfaces").AuditLogsState>) => void;
     resetAuditLogsState: () => void;
     exportAuditsCsv: () => Promise<void>;
-    loadAuditLogs: (payload: import("../interfaces").WithSilentLoad<import("../interfaces").WithCallback<{
-        pageOffset: number;
-        pageSize?: number | undefined;
-        filter?: import("@frontegg/rest-api").QueryFilter[] | undefined;
-        sort?: import("@frontegg/rest-api").QuerySort[] | undefined;
-    }, boolean>>) => Promise<void>;
+    loadAuditLogs: (payload: import("./interfaces").LoadAuditLogsPayload) => Promise<void>;
 };
-export declare type AuditsActions = ReturnType<typeof buildAuditLogsActions> & ReturnType<typeof buildAuditsMetadataActions>;
+export type AuditsActions = ReturnType<typeof buildAuditLogsActions> & ReturnType<typeof buildAuditsMetadataActions>;

package/audits-backward-compatibility/actions.d.ts

@@ -1,6 +1,7 @@
 import { FronteggState, RestApi, SharedActions } from '../interfaces';
 import { Filter, LoadAudits } from './interfaces';
 export declare const defaultItemsPerPage = 20;
+/** @deprecated use auditLogs instead of audits */
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
     initData: () => Promise<void>;
     loadAudits: (payload: LoadAudits) => Promise<void>;
@@ -8,5 +9,4 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     filterData: (payload: Filter) => Promise<void>;
     exportCSV: () => Promise<void>;
 };
-/** @deprecated use auditLogs instead of audits */
 export default _default;

package/audits-backward-compatibility/index.d.ts

@@ -1,5 +1,5 @@
 import createOldAuditsState from './state';
 import buildOldAuditsActions from './actions';
 /** @deprecated use auditLogs instead of audits */
-export declare type OldAuditsActions = ReturnType<typeof buildOldAuditsActions>;
+export type OldAuditsActions = ReturnType<typeof buildOldAuditsActions>;
 export { createOldAuditsState, buildOldAuditsActions };

package/audits-backward-compatibility/state.d.ts

@@ -1,5 +1,5 @@
 import { OldAuditsState } from './interfaces';
 export declare const initialState: OldAuditsState;
-declare const _default: (overrideState?: Partial<OldAuditsState> | undefined) => OldAuditsState;
 /** @deprecated use auditLogs instead of audits */
+declare const _default: (overrideState?: Partial<OldAuditsState>) => OldAuditsState;
 export default _default;

package/auth/AcceptInvitationState/state.d.ts

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

package/auth/AccountSettingsState/actions.d.ts

@@ -1,4 +1,4 @@
-import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { FronteggState, RestApi, SharedActions, WithCallback, WithSilentLoad } from '../../interfaces';
 import { ISettingsResponse, IUpdateSettings } from '@frontegg/rest-api';
 import { AccountSettingsState } from './interfaces';
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
@@ -16,8 +16,6 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     };
     resetAccountSettingsState: () => void;
     saveAccountSettings: (payload: WithCallback<IUpdateSettings, ISettingsResponse>) => Promise<void>;
-    loadAccountSettings: (payload?: WithCallback<{
-        silentLoading?: boolean | undefined;
-    }, boolean> | undefined) => Promise<void>;
+    loadAccountSettings: (payload?: WithCallback<WithSilentLoad>) => Promise<void>;
 };
 export default _default;

package/auth/AccountSettingsState/state.d.ts

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

package/auth/ActivateAccountState/actions.d.ts

@@ -17,7 +17,7 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
         };
     };
     resetActivateState: () => void;
-    setActivateStrategyState: (state: Partial<ActivateAccountState['activationStrategy']>) => void;
+    setActivateStrategyState: (state: Partial<ActivateAccountState["activationStrategy"]>) => void;
     activateAccount: (_payload: WithCallback<IActivateAccountPayload>) => Promise<void>;
     preActivateAccount: (payload: IPreActivateAccount) => Promise<void>;
     getActivateAccountStrategy: (payload: WithCallback<IGetActivateAccountStrategy, IGetActivateAccountStrategyResponse>) => Promise<void>;

package/auth/ActivateAccountState/actions.js

@@ -107,7 +107,7 @@ export default ((store, api, sharedActions) => {
         };
         events == null ? void 0 : (_events$userVerified = events.userVerified) == null ? void 0 : _events$userVerified.call(events, userVerifiedPayload);
         reportGTMEvent(GTMEventAction.USER_VERIFIED, userVerifiedPayload);
-        await actions.__afterAuthenticationStateUpdate(_extends({
+        await actions.afterAuthenticationStateUpdate(_extends({
           user
         }, rest), {
           isAuthenticated: true

package/auth/ActivateAccountState/interfaces.d.ts

@@ -14,13 +14,13 @@ export interface ActivateAccountState {
     resentEmail: boolean;
     activationStrategy: ActivateAccountStrategyState;
 }
-export declare type IPreActivateAccount = {
+export type IPreActivateAccount = {
     userId: string;
     token: string;
 };
 export interface IActivateAccountPayload extends IActivateAccount {
     events?: CustomEventsOptions;
 }
-export declare type ActivateAccountStrategyState = WithStatus & {
+export type ActivateAccountStrategyState = WithStatus & {
     strategy?: IGetActivateAccountStrategyResponse;
 };

package/auth/ActivateAccountState/state.d.ts

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

package/auth/ApiTokensState/actions.d.ts

@@ -5,9 +5,9 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     setApiTokensError: (payload: ApiStateIndicator) => void;
     setApiTokensState: (state: Partial<ApiTokensState>) => void;
     resetApiTokensState: () => void;
-    loadApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
-    loadUserApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
-    loadTenantApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
+    loadApiTokens: (payload?: WithSilentLoad<WithCallback>) => Promise<void>;
+    loadUserApiTokens: (payload?: WithSilentLoad<WithCallback>) => Promise<void>;
+    loadTenantApiTokens: (payload?: WithSilentLoad<WithCallback>) => Promise<void>;
     addTenantApiToken: (payload: AddTenantApiTokenPayload) => Promise<void>;
     addUserApiToken: (payload: AddUserApiTokenPayload) => Promise<void>;
     deleteUserApiToken: (payload: string) => Promise<void>;

package/auth/ApiTokensState/interfaces.d.ts

@@ -22,8 +22,8 @@ export interface ApiTokensState {
     permissions: ITeamUserPermission[];
     errors?: any;
 }
-export declare type ApiTokenType = 'user' | 'tenant' | null;
-export declare type createdByUserIdColumn = 'show' | 'hide' | undefined;
+export type ApiTokenType = 'user' | 'tenant' | null;
+export type createdByUserIdColumn = 'show' | 'hide' | undefined;
 export { MachineToMachineAuthStrategy };
 export interface IApiTokensData {
     clientId?: string;
@@ -50,7 +50,7 @@ export interface ITenantApiTokensData extends IApiTokensData {
 export interface ITenantApiAccessTokensData {
     accessTokens: ITenantApiTokensData[];
 }
-export declare type ApiStateIndicator = {
+export type ApiStateIndicator = {
     key: ApiStateKeys;
     value: string | boolean;
 };
@@ -59,5 +59,5 @@ export declare enum ApiStateKeys {
     ADD_API_TOKEN = "ADD_API_TOKEN",
     DELETE_API_TOKEN = "DELETE_API_TOKEN"
 }
-export declare type AddTenantApiTokenPayload = WithCallback<Pick<ITenantApiTokensData, 'description' | 'roleIds' | 'expires'>>;
-export declare type AddUserApiTokenPayload = WithCallback<Pick<IApiTokensData, 'description' | 'expires'>>;
+export type AddTenantApiTokenPayload = WithCallback<Pick<ITenantApiTokensData, 'description' | 'roleIds' | 'expires'>>;
+export type AddUserApiTokenPayload = WithCallback<Pick<IApiTokensData, 'description' | 'expires'>>;

package/auth/ApiTokensState/state.d.ts

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

package/auth/ApplicationsState/actions.d.ts

@@ -12,13 +12,13 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     assignUserToApps: (payload: WithCallback<UserAppsAssignmentPayload>) => Promise<void>;
     unassignUserFromApps: (payload: WithCallback<UserAppsAssignmentPayload>) => Promise<void>;
     assignNewUserToApps: ({ appIds, user }: {
-        appIds?: string[] | undefined;
+        appIds?: string[];
         user: ITeamUser;
     }) => Promise<((IApplicationsResponse & {
-        userIds?: string[] | undefined;
+        userIds?: string[];
     }) | never[])[] | undefined>;
     mapUsersWithApplicationData: ({ shouldLoadApps, users, }: {
-        shouldLoadApps?: boolean | undefined;
+        shouldLoadApps?: boolean;
         users: ITeamUser[];
     }) => Promise<ITeamUser[]>;
 };

package/auth/ApplicationsState/helpers.d.ts

@@ -1,3 +1,3 @@
 export declare const getFlattenAppIds: <T extends {
-    appIds?: string[] | undefined;
+    appIds?: string[];
 }>(listWithAppIds: T[]) => string[];

package/auth/ApplicationsState/interfaces.d.ts

@@ -9,4 +9,4 @@ export interface ApplicationsState {
         userIds?: string[];
     })[];
 }
-export declare type UserAppsAssignmentPayload = Pick<IAssignUserToApplicationsBody, 'userId' | 'appIds'>;
+export type UserAppsAssignmentPayload = Pick<IAssignUserToApplicationsBody, 'userId' | 'appIds'>;

package/auth/ApplicationsState/state.d.ts

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

package/auth/CustomLoginState/state.d.ts

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

package/auth/Entitlements/actions.d.ts

@@ -4,6 +4,6 @@ import { LoadEntitlementsActionPayload } from './interfaces';
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
     setEntitlements: (entitlements: UserEntitlementsResponseV2) => void;
     handleFetchedEntitlements: (newEntitlementsResponse: UserEntitlementsResponseV2) => void;
-    loadEntitlements: (payload?: LoadEntitlementsActionPayload | undefined) => Promise<void>;
+    loadEntitlements: (payload?: LoadEntitlementsActionPayload) => Promise<void>;
 };
 export default _default;

package/auth/Entitlements/helpers.d.ts

@@ -9,7 +9,7 @@ import type { Attributes } from '@frontegg/entitlements-javascript-commons';
  @returns if the user is entitled to the given permission. Attaching the justification if not
  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getPermissionEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined, appName?: string) => Entitlement;
+export declare const getPermissionEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes, isV2?: boolean, appName?: string) => Entitlement;
 /**
  @param entitlements
  @param key feature key
@@ -19,7 +19,7 @@ export declare const getPermissionEntitlements: (entitlements: UserEntitlementsR
  @returns if the user is entitled to the given feature. Attaching the justification if not
  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getFeatureEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined, appName?: string) => Entitlement;
+export declare const getFeatureEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes, isV2?: boolean, appName?: string) => Entitlement;
 /**
  @param entitlements
  @param options including permission or feature
@@ -29,7 +29,7 @@ export declare const getFeatureEntitlements: (entitlements: UserEntitlementsResp
  @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, options: EntitledToOptions, attributes?: Attributes | undefined, isV2?: boolean | undefined, appName?: string) => Entitlement;
+export declare const getEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, options: EntitledToOptions, attributes?: Attributes, isV2?: boolean, appName?: string) => Entitlement;
 /**
  * @param oldEntitlements
  * @param newEntitlements

package/auth/Entitlements/interfaces.d.ts

@@ -9,7 +9,7 @@ export interface EntitlementsOptions {
  * Load entitlements callback
  * @param isSucceeded true will be passed when completed successfully, false when failed
  */
-export declare type LoadEntitlementsCallback = (isSucceeded: boolean) => void;
+export type LoadEntitlementsCallback = (isSucceeded: boolean) => void;
 /**
  * Load entitlements saga action payload
  */
@@ -20,7 +20,7 @@ export interface Entitlement {
     isEntitled: boolean;
     justification?: NotEntitledJustification;
 }
-export declare type EntitledToOptions = EntitledToFeature | EntitledToPermission;
+export type EntitledToOptions = EntitledToFeature | EntitledToPermission;
 export interface EntitledToFeature {
     featureKey: string;
 }

package/auth/ForgotPasswordState/actions.d.ts

@@ -6,6 +6,6 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     resetForgotPasswordState: () => void;
     forgotPassword: (payload: IForgotPasswordPayload) => Promise<void>;
     resetPassword: (payload: IResetPasswordPayload) => Promise<void>;
-    loadPasswordConfig: (payload?: IGetUserPasswordConfig | undefined) => Promise<void>;
+    loadPasswordConfig: (payload?: IGetUserPasswordConfig) => Promise<void>;
 };
 export default _default;

package/auth/ForgotPasswordState/state.d.ts

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

package/auth/GroupsDialogsState/actions.d.ts

@@ -7,11 +7,11 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     closeAddGroupDialog: () => void;
     openAddMembersToGroupDialog: () => void;
     closeAddMembersToGroupDialog: () => void;
-    openEditGroupDialog: (payload: Partial<Pick<EditGroupDialogState, 'group'>>) => void;
+    openEditGroupDialog: (payload: Partial<Pick<EditGroupDialogState, "group">>) => void;
     closeEditGroupDialog: () => void;
-    openDeleteGroupDialog: (payload: Partial<Pick<EditGroupDialogState, 'group'>>) => void;
+    openDeleteGroupDialog: (payload: Partial<Pick<EditGroupDialogState, "group">>) => void;
     closeDeleteGroupDialog: () => void;
-    openDeleteMemberFromGroupDialog: (payload: Pick<DeleteMemberFromGroupDialogState, 'userId' | 'email'>) => void;
+    openDeleteMemberFromGroupDialog: (payload: Pick<DeleteMemberFromGroupDialogState, "userId" | "email">) => void;
     closeDeleteMemberFromGroupDialog: () => void;
 };
 export default _default;

package/auth/GroupsDialogsState/interfaces.d.ts

@@ -1,25 +1,25 @@
 import type { IUpdateGroupRoles, IUpdateGroupUsers } from '@frontegg/rest-api';
 import type { IGroup } from '../GroupsState/interfaces';
-declare type BaseDialogState = {
+type BaseDialogState = {
     open?: boolean;
     loading?: boolean;
     error?: boolean;
     onClose?: (data?: any) => void;
 };
-declare type AddGroupDialogState = BaseDialogState & {
+type AddGroupDialogState = BaseDialogState & {
     group?: Omit<IGroup, 'id' | 'roles' | 'users' | 'managedBy'> & Partial<IUpdateGroupRoles & IUpdateGroupUsers>;
 };
-export declare type AddMembersToGroupDialogState = BaseDialogState & {
+export type AddMembersToGroupDialogState = BaseDialogState & {
     userIds: string[];
 };
-export declare type EditGroupDialogState = BaseDialogState & {
+export type EditGroupDialogState = BaseDialogState & {
     group?: IGroup;
 };
-export declare type DeleteMemberFromGroupDialogState = BaseDialogState & {
+export type DeleteMemberFromGroupDialogState = BaseDialogState & {
     userId?: string;
     email?: string;
 };
-declare type DeleteGroupDialogState = BaseDialogState & {
+type DeleteGroupDialogState = BaseDialogState & {
     group?: IGroup;
 };
 export interface GroupsDialogsState {

package/auth/GroupsDialogsState/state.d.ts

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

package/auth/GroupsState/actions.d.ts

@@ -6,16 +6,16 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     setGroupsState: (payload: Partial<GroupsState>) => void;
     resetUsersGroupsState: () => void;
     loadGroups: () => Promise<void>;
-    getGroupById: (payload: IGroupsStateActionsPayloads['getGroupById']) => Promise<void>;
-    createGroup: (payload: IGroupsStateActionsPayloads['createGroup']) => Promise<void>;
-    updateGroup: (payload: IGroupsStateActionsPayloads['updateGroup']) => Promise<void>;
-    deleteGroup: (payload: IGroupsStateActionsPayloads['deleteGroup']) => Promise<void>;
-    addRolesToGroup: (payload: IGroupsStateActionsPayloads['addRolesToGroup']) => Promise<void>;
-    deleteRolesFromGroup: (payload: IGroupsStateActionsPayloads['deleteRolesFromGroup']) => Promise<void>;
-    addUsersToGroup: (payload: IGroupsStateActionsPayloads['addUsersToGroup']) => Promise<void>;
-    deleteUsersFromGroup: (payload: IGroupsStateActionsPayloads['deleteUsersFromGroup']) => Promise<void>;
+    getGroupById: (payload: IGroupsStateActionsPayloads["getGroupById"]) => Promise<void>;
+    createGroup: (payload: IGroupsStateActionsPayloads["createGroup"]) => Promise<void>;
+    updateGroup: (payload: IGroupsStateActionsPayloads["updateGroup"]) => Promise<void>;
+    deleteGroup: (payload: IGroupsStateActionsPayloads["deleteGroup"]) => Promise<void>;
+    addRolesToGroup: (payload: IGroupsStateActionsPayloads["addRolesToGroup"]) => Promise<void>;
+    deleteRolesFromGroup: (payload: IGroupsStateActionsPayloads["deleteRolesFromGroup"]) => Promise<void>;
+    addUsersToGroup: (payload: IGroupsStateActionsPayloads["addUsersToGroup"]) => Promise<void>;
+    deleteUsersFromGroup: (payload: IGroupsStateActionsPayloads["deleteUsersFromGroup"]) => Promise<void>;
     getGroupConfiguration: () => Promise<void>;
-    updateGroupConfiguration: (payload: IGroupsStateActionsPayloads['updateGroupConfiguration']) => Promise<void>;
-    getTeamUsers: (payload: IGroupsStateActionsPayloads['getTeamUsers']) => Promise<void>;
+    updateGroupConfiguration: (payload: IGroupsStateActionsPayloads["updateGroupConfiguration"]) => Promise<void>;
+    getTeamUsers: (payload: IGroupsStateActionsPayloads["getTeamUsers"]) => Promise<void>;
 };
 export default _default;

package/auth/GroupsState/interfaces.d.ts

@@ -15,13 +15,13 @@ export declare enum GroupsStateKeys {
     UPDATE_GROUP_CONFIGURATION = "UPDATE_GROUP_CONFIGURATION",
     GET_TEAM_USERS = "GET_TEAM_USERS"
 }
-export declare type GroupsStateIndicator = {
+export type GroupsStateIndicator = {
     key: GroupsStateKeys;
     value: string | boolean;
 };
-export declare type IGroup = IGroupResponse;
-export declare type IGroupConfig = IGroupConfigResponse;
-export declare type IGroupMember = IGroupUser;
+export type IGroup = IGroupResponse;
+export type IGroupConfig = IGroupConfigResponse;
+export type IGroupMember = IGroupUser;
 export interface GroupsState {
     loaders: LoaderIndicatorState<GroupsStateKeys>;
     errors: LoaderIndicatorState<GroupsStateKeys>;

package/auth/GroupsState/state.d.ts

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

package/auth/ImpersonateState/state.d.ts

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

package/auth/LoginState/actions/afterAuthNavigation.actions.d.ts

@@ -4,8 +4,8 @@ import { AfterAuthNavigationUtilOptions } from '../interfaces';
 import { AuthState } from '../../interfaces';
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
     afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: AfterAuthNavigationUtilOptions) => Promise<void>;
-    afterAuthNavigation: (payload?: Pick<AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning"> | undefined) => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning">) => Promise<void>;
     afterStepUpAuthNavigation: () => Promise<void>;
-    __afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => void;
+    afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => void;
 };
 export default _default;

package/auth/LoginState/actions/afterAuthNavigation.actions.js

@@ -30,7 +30,7 @@ export default ((store, api, sharedActions) => {
    *
    * @protected
    */
-  function __afterAuthenticationStateUpdate({
+  function afterAuthenticationStateUpdate({
     user,
     tenants = [],
     activeTenant
@@ -178,6 +178,6 @@ export default ((store, api, sharedActions) => {
     afterAuthNavigationUtil,
     afterAuthNavigation,
     afterStepUpAuthNavigation,
-    __afterAuthenticationStateUpdate
+    afterAuthenticationStateUpdate
   };
 });

package/auth/LoginState/actions/hostedLoginAuthorize.actions.d.ts

@@ -1,14 +1,14 @@
 import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
 import { HostedLoginCallback, LoginDirectAction } from '../interfaces';
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
-    requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+    requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
     requestHostedLoginAuthorizeV2: (payload?: {
-        additionalParams?: Record<string, string> | undefined;
-        shouldRedirectToLogin?: boolean | undefined;
-        firstTime?: boolean | undefined;
-        loginDirectAction?: LoginDirectAction | undefined;
-    } | undefined) => Promise<void>;
-    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+        additionalParams?: Record<string, string>;
+        shouldRedirectToLogin?: boolean;
+        firstTime?: boolean;
+        loginDirectAction?: LoginDirectAction;
+    }) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
     __requestHostedLoginSilentAuthorize: () => Promise<void>;
     handleHostedLoginCallback: (payload: HostedLoginCallback) => Promise<void>;
 };

package/auth/LoginState/actions/hostedLoginAuthorize.actions.js

@@ -13,7 +13,7 @@ export default ((store, api, sharedActions) => {
   const __requestHostedLoginSilentAuthorize = async () => {
     const response = await api.auth.silentOAuthRefreshTokenV2();
     if (response != null && response.user) {
-      await actions.__afterAuthenticationStateUpdate(response, {
+      await actions.afterAuthenticationStateUpdate(response, {
         isAuthenticated: true,
         isLoading: false
       });
@@ -171,7 +171,7 @@ export default ((store, api, sharedActions) => {
     };
     try {
       const response = await api.auth.exchangeOAuthTokensV2(body);
-      actions.__afterAuthenticationStateUpdate(response, {
+      actions.afterAuthenticationStateUpdate(response, {
         isAuthenticated: true,
         isLoading: false
       });

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

@@ -8,17 +8,17 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     verifyMFAWebAuthn: ({ callback, deviceId, ...payload }: import("../interfaces").IVerifyMFAWebAuthnPayload, setLoadingAction: import("../interfaces").SetLoadingAction, isStepUp: boolean) => Promise<void>;
     preVerifyMFAWebAuthnForLogin: (payload: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, import("../interfaces").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
     verifyMFAWebAuthnForLogin: (payload: import("../interfaces").IVerifyMFAWebAuthnPayload) => Promise<void>;
-    preVerifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, boolean>, setLoadingAction: import("../interfaces").SetLoadingAction) => Promise<void>;
-    verifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>, boolean>, setLoadingAction: import("../interfaces").SetLoadingAction, isStepUp?: boolean) => Promise<void>;
-    preVerifyMFASMSForLogin: (payload: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, boolean>) => Promise<void>;
-    verifyMFASMSForLogin: (payload: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>, boolean>) => Promise<void>;
-    preVerifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA, boolean>, setLoadingAction?: import("../interfaces").SetLoadingAction | undefined) => Promise<void>;
-    verifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode, boolean>, setLoadingAction?: import("../interfaces").SetLoadingAction | undefined) => Promise<void>;
-    preVerifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA, boolean>) => Promise<void>;
-    verifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode, boolean>) => Promise<void>;
-    mfaWithAuthenticator: ({ callback, ...loginWithMfaPayload }: WithCallback<import("@frontegg/rest-api").ILoginWithMfa, boolean>, setLoadingAction: import("../interfaces").SetLoadingAction, isStepUp: boolean) => Promise<void>;
-    loginWithMfa: (payload: WithCallback<import("@frontegg/rest-api").ILoginWithMfa, boolean>) => Promise<void>;
-    getMfaRequiredState: (user: any) => Promise<Partial<AuthState> & {
+    preVerifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>>, setLoadingAction: import("../interfaces").SetLoadingAction) => Promise<void>;
+    verifyMFASMS: ({ callback, deviceId, ...payload }: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>>, setLoadingAction: import("../interfaces").SetLoadingAction, isStepUp?: boolean) => Promise<void>;
+    preVerifyMFASMSForLogin: (payload: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>>) => Promise<void>;
+    verifyMFASMSForLogin: (payload: WithCallback<import("../interfaces").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>>) => Promise<void>;
+    preVerifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA>, setLoadingAction?: import("../interfaces").SetLoadingAction) => Promise<void>;
+    verifyMFAEmailCode: ({ callback, ...payload }: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode>, setLoadingAction?: import("../interfaces").SetLoadingAction) => Promise<void>;
+    preVerifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IPreVerifyMFA>) => Promise<void>;
+    verifyMFAEmailCodeForLogin: (payload: WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode>) => Promise<void>;
+    mfaWithAuthenticator: ({ callback, ...loginWithMfaPayload }: WithCallback<import("@frontegg/rest-api").ILoginWithMfa>, setLoadingAction: import("../interfaces").SetLoadingAction, isStepUp: boolean) => Promise<void>;
+    loginWithMfa: (payload: WithCallback<import("@frontegg/rest-api").ILoginWithMfa>) => Promise<void>;
+    getMfaRequiredState: (user: import("../../interfaces").User | any) => Promise<Partial<AuthState> & {
         mfaState: Partial<MFAState>;
         loginState: Partial<LoginState>;
     }>;
@@ -27,22 +27,22 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     handleVerifyMFAResponse: (payload: ILoginResponseV3, isStepUp?: boolean) => Promise<void>;
     getFeatureFlags: (flags: string[]) => Promise<boolean[]>;
     afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: import("../interfaces").AfterAuthNavigationUtilOptions) => Promise<void>;
-    afterAuthNavigation: (payload?: Pick<import("../interfaces").AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning"> | undefined) => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<import("../interfaces").AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning">) => Promise<void>;
     afterStepUpAuthNavigation: () => Promise<void>;
-    __afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => void;
-    requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+    afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => void;
+    requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
     requestHostedLoginAuthorizeV2: (payload?: {
-        additionalParams?: Record<string, string> | undefined;
-        shouldRedirectToLogin?: boolean | undefined;
-        firstTime?: boolean | undefined;
-        loginDirectAction?: import("../interfaces").LoginDirectAction | undefined;
-    } | undefined) => Promise<void>;
-    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+        additionalParams?: Record<string, string>;
+        shouldRedirectToLogin?: boolean;
+        firstTime?: boolean;
+        loginDirectAction?: import("../interfaces").LoginDirectAction;
+    }) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string>) => Promise<void>;
     __requestHostedLoginSilentAuthorize: () => Promise<void>;
     handleHostedLoginCallback: (payload: import("../interfaces").HostedLoginCallback) => Promise<void>;
     setLoginState: (state: Partial<LoginState>) => void;
     resetLoginState: () => void;
-    requestAuthorize: (firstTime?: boolean | undefined) => Promise<void>;
+    requestAuthorize: (firstTime?: boolean) => Promise<void>;
     requestAuthorizeSSR: (payload: FronteggNextJSSession) => Promise<void>;
     preLogin: (payload: WithCallback<IPreLogin & {
         recaptchaToken?: string;
@@ -50,10 +50,10 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     }, void>) => Promise<void>;
     postLogin: (payload: IPostLogin) => Promise<void>;
     login: (payload: WithCallback<ILogin>) => Promise<void>;
-    logout: (payload?: (() => void) | undefined) => Promise<void>;
+    logout: (payload?: () => void) => Promise<void>;
     silentLogout: (payload?: WithCallback<{
-        callbackTimeout?: number | undefined;
-    }, boolean> | undefined) => Promise<void>;
+        callbackTimeout?: number;
+    }>) => Promise<void>;
     recoverMfa: (payload: IRecoverMFATokenPayload) => Promise<void>;
     quickSmsPasswordlessPreLogin: (_payload: WithCallback<IQuickSmsPasswordlessPreLoginPayload>) => Promise<void>;
     changePhoneNumberWithVerification: (_payload: WithCallback<IChangePhoneNumberWithVerification>) => Promise<void>;