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

package/mocks/audits-mocks/auditsMetadataActions.mocks.js

@@ -0,0 +1,28 @@
+import { mockActionsExpect } from '../helpers';
+import { auditLogsMetadataDemo } from './dummy';
+import { buildAuditsMetadataActions } from '../../audits/AuditsMetadataState';
+export default ((store, api, actions) => {
+  const originalActions = buildAuditsMetadataActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setAuditsMetadataState', 'resetAuditsMetadataState']);
+  mockedActions.loadAuditsMetadata = async () => {
+    mockedActions.setAuditsMetadataState({
+      loading: true,
+      error: null
+    });
+    try {
+      const {
+        properties
+      } = auditLogsMetadataDemo;
+      mockedActions.setAuditsMetadataState({
+        columns: properties,
+        loading: false
+      });
+    } catch (e) {
+      mockedActions.setAuditsMetadataState({
+        error: e,
+        loading: false
+      });
+    }
+  };
+  return mockedActions;
+});

package/mocks/audits-mocks/index.d.ts

@@ -0,0 +1,15 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+export declare const buildAuditsActions: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAuditsMetadataState: (state: Partial<import("../..").AuditsMetadataState>) => void;
+    resetAuditsMetadataState: () => void;
+    loadAuditsMetadata: () => Promise<void>;
+    setAuditLogsState: (state: Partial<import("../..").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>;
+};

package/mocks/audits-mocks/index.js

@@ -0,0 +1,8 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import buildAuditLogsActions from './auditLogsActions.mocks';
+import buildAuditsMetadataActions from './auditsMetadataActions.mocks';
+export const buildAuditsActions = (store, api, actions) => {
+  const auditLogsActions = buildAuditLogsActions(store, api, actions);
+  const auditsMetadataActions = buildAuditsMetadataActions(store, api, actions);
+  return _extends({}, auditLogsActions, auditsMetadataActions);
+};

package/mocks/auth-mocks/acceptInvitationActions.mocks.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAcceptInvitationState: (state: Partial<import("../..").AcceptInvitationState>) => {
+        readonly error?: string | undefined;
+        readonly step: import("../..").AcceptInvitationStep;
+    };
+    resetAcceptInvitationState: () => void;
+    acceptInvitation: (payload: import("@frontegg/rest-api").IAcceptInvitation) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/acceptInvitationActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildAcceptInvitationActions } from '../../auth/AcceptInvitationState';
+export default ((store, api, actions) => {
+  const originalActions = buildAcceptInvitationActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setAcceptInvitationState', 'resetAcceptInvitationState']);
+});

package/mocks/auth-mocks/accountSettingsActions.mocks.d.ts

@@ -0,0 +1,22 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { ISettingsResponse, IUpdateSettings } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAccountSettingsState: (state: Partial<import("../..").AccountSettingsState>) => {
+        readonly loading: boolean;
+        readonly name?: string | undefined;
+        readonly website?: string | undefined;
+        readonly error?: any;
+        readonly address?: string | undefined;
+        readonly timezone?: string | undefined;
+        readonly dateFormat?: string | undefined;
+        readonly timeFormat?: string | undefined;
+        readonly currency?: string | undefined;
+        readonly logo?: string | undefined;
+    };
+    resetAccountSettingsState: () => void;
+    saveAccountSettings: (payload: WithCallback<IUpdateSettings, ISettingsResponse>) => Promise<void>;
+    loadAccountSettings: (payload?: WithCallback<{
+        silentLoading?: boolean | undefined;
+    }, boolean> | undefined) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/accountSettingsActions.mocks.js

@@ -0,0 +1,52 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { buildAccountSettingsActions } from '../../auth/AccountSettingsState';
+import { delay } from '../../helpers';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildAccountSettingsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setAccountSettingsState', 'resetAccountSettingsState']);
+  mockedActions.saveAccountSettings = async payload => {
+    var _payload$callback;
+    mockedActions.setAccountSettingsState({
+      loading: true
+    });
+    await delay();
+    const accountSettingsState = store.auth.accountSettingsState;
+    const {
+      address,
+      timezone,
+      dateFormat,
+      timeFormat,
+      currency,
+      logo
+    } = accountSettingsState;
+    const body = _extends({
+      address,
+      timezone,
+      dateFormat,
+      timeFormat,
+      currency,
+      logo
+    }, payload);
+    mockedActions.setAccountSettingsState(_extends({}, body, {
+      loading: false
+    }));
+    (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, body);
+  };
+  mockedActions.loadAccountSettings = async payload => {
+    mockedActions.setAccountSettingsState({
+      loading: !(payload != null && payload.silentLoading),
+      error: null
+    });
+    await delay();
+    mockedActions.setAccountSettingsState(_extends({
+      address: 'Tel-aviv',
+      timezone: 'Asia/Jerusalem',
+      dateFormat: 'DD/MM/YYYY',
+      timeFormat: 'HH:mm',
+      currency: 'USD',
+      loading: false
+    }, payload));
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/activateAccountActions.mocks.d.ts

@@ -0,0 +1,24 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setActivateState: (state: Partial<import("../..").ActivateAccountState>) => {
+        readonly loading: boolean;
+        readonly error?: any;
+        readonly step: import("../..").ActivateAccountStep;
+        readonly resentEmail: boolean;
+        readonly activationStrategy: {
+            readonly loading: boolean;
+            readonly error?: any;
+            readonly saving?: boolean | undefined;
+            readonly strategy?: {
+                readonly shouldSetPassword: boolean;
+            } | undefined;
+        };
+    };
+    resetActivateState: () => void;
+    setActivateStrategyState: (state: Partial<import("../..").ActivateAccountStrategyState>) => void;
+    activateAccount: (_payload: import("../../interfaces").WithCallback<import("../..").IActivateAccountPayload, boolean>) => Promise<void>;
+    preActivateAccount: (payload: import("../..").IPreActivateAccount) => Promise<void>;
+    getActivateAccountStrategy: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IGetActivateAccountStrategy, import("@frontegg/rest-api").IGetActivateAccountStrategyResponse>) => Promise<void>;
+    resendActivationEmail: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IResendActivationEmail, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/activateAccountActions.mocks.js

@@ -0,0 +1,7 @@
+import { buildActivateAccountActions } from '../../auth/ActivateAccountState';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildActivateAccountActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setActivateState', 'resetActivateState', 'setActivateStrategyState']);
+  return mockedActions;
+});

package/mocks/auth-mocks/allAccountsActions.mocks.d.ts

@@ -0,0 +1,37 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAllAccountsLoader: (payload: import("../..").AllAccountsStateIndicator) => void;
+    setAllAccountsError: (payload: import("../..").AllAccountsStateIndicator) => void;
+    setAllAccountsState: (state: Partial<import("../..").IAllAccountsState>) => void;
+    setSelectedAccountState: (payload: Partial<import("../..").ISelectedAccount>) => void;
+    resetAllAccountsState: () => void;
+    clearSelectedAccount: () => void;
+    loadAccounts: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").SearchSubTenantsParams & {
+        _links?: import("@frontegg/rest-api").FronteggPaginationLinks | undefined;
+    } & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    searchAccounts: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").SearchSubTenantsParams & {
+        _links?: import("@frontegg/rest-api").FronteggPaginationLinks | undefined;
+    } & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    updateSubAccountAccessForUser: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").UpdateSubAccountAccessRequestDto & {
+        userId: string;
+    } & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    createSubAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").CreateSubTenantRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    updateSubAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").CreateSubTenantRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    deleteSubAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").RemoveUserFromSubTenantsRequestTenantDto & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    updateSubAccountSettings: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").UpdateSubTenantRequestParams & import("@frontegg/rest-api").UpdateSubTenantRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    updateSubAccountManagement: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").UpdateSubTenantRequestParams & import("@frontegg/rest-api").UpdateSubTenantManagementRequest & import("../..").TUserJwtPayload & {
+        shouldUpdateSelectedAccount?: boolean | undefined;
+    }, boolean>) => Promise<void>;
+    updateSubAccountHierarchySettings: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").UpdateSubTenantRequestParams & import("@frontegg/rest-api").UpdateSubTenantHierarchySettingsRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    addUsersToAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").AddUsersToSubTenantRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    getAccountUsers: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").ISearchUserQueryParamsV3 & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    deleteUsersFromAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").RemoveUserFromSubTenantsRequest & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    setUserRolesForSubAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").UpdateUserRolesForSubTenantsRequestDto & {
+        userId: string;
+    } & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    getUserJwtForSubAccount: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").GetUserJwtRequestDto, boolean>) => Promise<void>;
+    setRootAccountData: () => Promise<void>;
+    setSelectedSubAccountData: (payload: import("../../interfaces").WithCallback<import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+    loadNumberOfUsersForSelectedSubAccount: (payload: import("../../interfaces").WithCallback<import("../..").TLoadNumberOfUsersForSelectedSubAccount & import("../..").TUserJwtPayload, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/allAccountsActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildAllAccountsActions } from '../../auth/MSP';
+export default ((store, api, actions) => {
+  const originalActions = buildAllAccountsActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setAllAccountsLoader', 'setAllAccountsError', 'setAllAccountsState', 'setSelectedAccountState', 'resetAllAccountsState', 'clearSelectedAccount']);
+});

package/mocks/auth-mocks/apiTokensActions.mocks.d.ts

@@ -0,0 +1,17 @@
+import { FronteggState, RestApi, SharedActions, WithCallback, WithSilentLoad } from '../../interfaces';
+import { ITenantApiTokensData } from '../../auth/ApiTokensState/interfaces';
+import { IApiTokensData } from '../../auth';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setApiTokensLoader: (payload: import("../../auth").ApiStateIndicator) => void;
+    setApiTokensError: (payload: import("../../auth").ApiStateIndicator) => void;
+    setApiTokensState: (state: Partial<import("../../auth").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>;
+    addTenantApiToken: (payload: WithCallback<Pick<ITenantApiTokensData, "description" | "roleIds" | "expires">, boolean>) => Promise<void>;
+    addUserApiToken: (payload: WithCallback<Pick<IApiTokensData, "description" | "expires">, boolean>) => Promise<void>;
+    deleteUserApiToken: (payload: string) => Promise<void>;
+    deleteTenantApiToken: (payload: string) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/apiTokensActions.mocks.js

@@ -0,0 +1,127 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { buildApiTokensActions } from '../../auth/ApiTokensState';
+import { apiTokensDataDemo, apiTokensDataTenantDemo } from '../dummy';
+import { v4 as uuidv4 } from 'uuid';
+import { delay } from '../../helpers';
+import { ApiStateKeys } from '../../auth';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildApiTokensActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setApiTokensState', 'resetApiTokensState', 'setApiTokensLoader', 'setApiTokensError']);
+  mockedActions.addTenantApiToken = async payload => {
+    const {
+      description,
+      roleIds,
+      callback
+    } = payload;
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.ADD_API_TOKEN,
+      value: true
+    });
+    const {
+      apiTokensDataTenant
+    } = store.auth.apiTokensState;
+    const newToken = _extends({}, apiTokensDataTenantDemo, {
+      description,
+      roleIds,
+      clientId: `CLIENT_ID_${uuidv4()}`
+    });
+    mockedActions.setApiTokensState({
+      showAddTokenDialog: false
+    });
+    await delay(200);
+    mockedActions.setApiTokensState({
+      apiTokensDataTenant: [...apiTokensDataTenant, newToken],
+      successDialog: {
+        open: true,
+        secret: newToken.secret,
+        clientId: newToken.clientId
+      }
+    });
+    await delay(200);
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.ADD_API_TOKEN,
+      value: false
+    });
+    callback == null ? void 0 : callback(null);
+  };
+  mockedActions.deleteTenantApiToken = async payload => {
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.DELETE_API_TOKEN,
+      value: true
+    });
+    await delay(200);
+    const apiTokensDataTenant = [apiTokensDataTenantDemo];
+    mockedActions.setApiTokensState({
+      apiTokensDataTenant: apiTokensDataTenant.filter(i => i.clientId !== payload),
+      deleteTokenDialog: {
+        open: false,
+        clientId: payload
+      }
+    });
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.DELETE_API_TOKEN,
+      value: false
+    });
+  };
+  mockedActions.loadApiTokens = async payload => {
+    var _payload$callback;
+    if (!(payload != null && payload.silentLoading)) {
+      mockedActions.setApiTokensLoader({
+        key: ApiStateKeys.LOAD_API_TOKENS,
+        value: true
+      });
+    }
+    const apiTokensDataUser = [apiTokensDataDemo];
+    const apiTokensDataTenant = [apiTokensDataTenantDemo];
+    mockedActions.setApiTokensState({
+      apiTokensDataUser,
+      apiTokensDataTenant
+    });
+    await delay(200);
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.LOAD_API_TOKENS,
+      value: false
+    });
+    payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+  };
+  mockedActions.loadUserApiTokens = async payload => {
+    var _payload$callback2;
+    if (!(payload != null && payload.silentLoading)) {
+      mockedActions.setApiTokensLoader({
+        key: ApiStateKeys.LOAD_API_TOKENS,
+        value: true
+      });
+    }
+    const apiTokensDataUser = [apiTokensDataDemo];
+    mockedActions.setApiTokensState({
+      apiTokensDataUser
+    });
+    await delay(200);
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.LOAD_API_TOKENS,
+      value: false
+    });
+    payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, true);
+  };
+  mockedActions.loadTenantApiTokens = async payload => {
+    var _payload$callback3;
+    if (!(payload != null && payload.silentLoading)) {
+      mockedActions.setApiTokensLoader({
+        key: ApiStateKeys.LOAD_API_TOKENS,
+        value: true
+      });
+    }
+    const apiTokensDataTenant = [apiTokensDataTenantDemo];
+    mockedActions.setApiTokensState({
+      apiTokensDataTenant
+    });
+    await delay(200);
+    mockedActions.setApiTokensLoader({
+      key: ApiStateKeys.LOAD_API_TOKENS,
+      value: false
+    });
+    payload == null ? void 0 : (_payload$callback3 = payload.callback) == null ? void 0 : _payload$callback3.call(payload, true);
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/applicationsActions.mocks.d.ts

@@ -0,0 +1,23 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setApplicationsState: (payload: Partial<import("../..").ApplicationsState>) => void;
+    resetApplicationsState: () => void;
+    loadUserApplications: () => Promise<void>;
+    loadAccountApplications: () => Promise<void>;
+    loadMultipleUsersApplications: ({ userIds }: {
+        userIds: string[];
+    }) => Promise<Record<string, import("@frontegg/rest-api").IApplicationsResponse[]> | undefined>;
+    assignUserToApps: (payload: import("../../interfaces").WithCallback<Pick<import("@frontegg/rest-api").IAssignUserToApplicationsBody, "userId" | "appIds">, boolean>) => Promise<void>;
+    unassignUserFromApps: (payload: import("../../interfaces").WithCallback<Pick<import("@frontegg/rest-api").IAssignUserToApplicationsBody, "userId" | "appIds">, boolean>) => Promise<void>;
+    assignNewUserToApps: ({ appIds, user }: {
+        appIds?: string[] | undefined;
+        user: import("@frontegg/rest-api").ITeamUser;
+    }) => Promise<((import("@frontegg/rest-api").IApplicationsResponse & {
+        userIds?: string[] | undefined;
+    }) | never[])[] | undefined>;
+    mapUsersWithApplicationData: ({ shouldLoadApps, users, }: {
+        shouldLoadApps?: boolean | undefined;
+        users: import("@frontegg/rest-api").ITeamUser[];
+    }) => Promise<import("@frontegg/rest-api").ITeamUser[]>;
+};
+export default _default;

package/mocks/auth-mocks/applicationsActions.mocks.js

@@ -0,0 +1,7 @@
+import { mockActionsExpect } from '../helpers';
+import { buildApplicationsActions } from '../../auth/ApplicationsState';
+export default ((store, api, actions) => {
+  const originalActions = buildApplicationsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setApplicationsState', 'resetApplicationsState']);
+  return mockedActions;
+});

package/mocks/auth-mocks/customLoginActions.mocks.d.ts

@@ -0,0 +1,11 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { UpdateTenantMetadataRequest } from '../../auth';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setCustomLoginState: (payload: Partial<import("../../auth").CustomLoginState>) => void;
+    resetCustomLoginState: () => void;
+    loadTenantMetadata: () => Promise<void>;
+    updateTenantMetadata: (payload: WithCallback<Partial<UpdateTenantMetadataRequest>, boolean>) => Promise<void>;
+    customLoginEnabled: () => Promise<boolean>;
+    loadCustomLoginRoutes: () => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/customLoginActions.mocks.js

@@ -0,0 +1,32 @@
+import { buildCustomLoginActions } from '../../auth/CustomLoginState';
+import { delay } from '../../helpers';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildCustomLoginActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setCustomLoginState', 'resetCustomLoginState']);
+  mockedActions.loadTenantMetadata = async () => {
+    mockedActions.setCustomLoginState({
+      loading: true
+    });
+    await delay();
+    mockedActions.setCustomLoginState({
+      loading: false
+    });
+  };
+  mockedActions.updateTenantMetadata = async payload => {
+    const {
+      callback
+    } = payload;
+    mockedActions.setCustomLoginState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setCustomLoginState({
+      loading: false,
+      error: null
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/entitlementsActions.mocks.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setEntitlements: (entitlements: import("@frontegg/entitlements-javascript-commons").UserEntitlementsContext) => void;
+    handleFetchedEntitlements: (newEntitlementsResponse: import("@frontegg/entitlements-javascript-commons").UserEntitlementsContext) => void;
+    loadEntitlements: (payload?: import("../..").LoadEntitlementsActionPayload | undefined) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/entitlementsActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildEntitlementsActions } from '../../auth/Entitlements';
+export default ((store, api, actions) => {
+  const originalActions = buildEntitlementsActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setEntitlements', 'handleFetchedEntitlements']);
+});

package/mocks/auth-mocks/forgotPasswordActions.mocks.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import type { IGetUserPasswordConfig } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setForgotPasswordState: (payload: Partial<import("../..").ForgotPasswordState>) => void;
+    resetForgotPasswordState: () => void;
+    forgotPassword: (payload: import("../..").IForgotPasswordPayload) => Promise<void>;
+    resetPassword: (payload: import("../..").IResetPasswordPayload) => Promise<void>;
+    loadPasswordConfig: (payload?: IGetUserPasswordConfig | undefined) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/forgotPasswordActions.mocks.js

@@ -0,0 +1,30 @@
+import { errorHandler } from '../../helpers';
+import { buildForgotPasswordActions } from '../../auth/ForgotPasswordState';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildForgotPasswordActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setForgotPasswordState', 'resetForgotPasswordState']);
+  mockedActions.loadPasswordConfig = async payload => {
+    mockedActions.setForgotPasswordState({
+      loading: true
+    });
+    try {
+      mockedActions.setForgotPasswordState({
+        loading: false,
+        passwordConfig: {
+          allowPassphrases: true,
+          maxLength: 128,
+          minLength: 6,
+          minPhraseLength: 6,
+          minOptionalTestsToPass: 1
+        }
+      });
+    } catch (e) {
+      mockedActions.setForgotPasswordState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/groupsActions.mocks.d.ts

@@ -0,0 +1,33 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { GroupsState } from '../../auth';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setUsersGroupsLoader: (payload: import("../../auth").GroupsStateIndicator) => void;
+    setUsersGroupsError: (payload: import("../../auth").GroupsStateIndicator) => void;
+    setGroupsState: (payload: Partial<GroupsState>) => void;
+    resetUsersGroupsState: () => void;
+    loadGroups: () => Promise<void>;
+    getGroupById: (payload: import("@frontegg/rest-api").IGetGroup) => Promise<void>;
+    createGroup: (payload: WithCallback<import("@frontegg/rest-api").ICreateGroup & Partial<import("@frontegg/rest-api").IUpdateGroupRoles> & Partial<import("@frontegg/rest-api").IUpdateGroupUsers>, boolean>) => Promise<void>;
+    updateGroup: (payload: WithCallback<import("@frontegg/rest-api").IUpdateGroup, boolean>) => Promise<void>;
+    deleteGroup: (payload: WithCallback<{
+        groupId: string;
+    }, boolean>) => Promise<void>;
+    addRolesToGroup: (payload: WithCallback<import("@frontegg/rest-api").IUpdateGroupRoles & {
+        groupId: string;
+    }, boolean>) => Promise<void>;
+    deleteRolesFromGroup: (payload: WithCallback<import("@frontegg/rest-api").IUpdateGroupRoles & {
+        groupId: string;
+    }, boolean>) => Promise<void>;
+    addUsersToGroup: (payload: WithCallback<import("@frontegg/rest-api").IUpdateGroupUsers & {
+        groupId: string;
+    }, boolean>) => Promise<void>;
+    deleteUsersFromGroup: (payload: WithCallback<import("@frontegg/rest-api").IUpdateGroupUsers & {
+        groupId: string;
+    }, boolean>) => Promise<void>;
+    getGroupConfiguration: () => Promise<void>;
+    updateGroupConfiguration: (payload: import("@frontegg/rest-api").IUpdateGroupConfig & {
+        groupId: string;
+    }) => Promise<void>;
+    getTeamUsers: (payload: import("../../auth").IGetUsersV2Payload) => Promise<void>;
+};
+export default _default;