diff --git a/lib/keyserver-conn/keyserver-conn-types.js b/lib/keyserver-conn/keyserver-conn-types.js
index 1eea9429b..ed80c1417 100644
--- a/lib/keyserver-conn/keyserver-conn-types.js
+++ b/lib/keyserver-conn/keyserver-conn-types.js
@@ -1,96 +1,99 @@
 // @flow
 
 import type {
   LogInActionSource,
   LogInStartingPayload,
   LogInResult,
 } from '../types/account-types.js';
 import type { Endpoint } from '../types/endpoints.js';
 import type { Dispatch } from '../types/redux-types.js';
 import type {
   ClientSessionChange,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import type {
   CallSingleKeyserverEndpoint,
   CallSingleKeyserverEndpointOptions,
 } from '../utils/call-single-keyserver-endpoint.js';
 
 export type ActionTypes<
   STARTED_ACTION_TYPE: string,
   SUCCESS_ACTION_TYPE: string,
   FAILED_ACTION_TYPE: string,
 > = {
   started: STARTED_ACTION_TYPE,
   success: SUCCESS_ACTION_TYPE,
   failed: FAILED_ACTION_TYPE,
 };
 
 export type DispatchRecoveryAttempt = (
   actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
   promise: Promise<LogInResult>,
   startingPayload: LogInStartingPayload,
 ) => Promise<boolean>;
 
 const setNewSessionActionType = 'SET_NEW_SESSION';
 function setNewSession(
   dispatch: Dispatch,
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
   keyserverID: string,
 ) {
   dispatch({
     type: setNewSessionActionType,
     payload: {
       sessionChange,
       preRequestUserState,
       error,
       logInActionSource,
       keyserverID,
     },
   });
 }
 
 export type SingleKeyserverActionFunc<F> = (
   callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
 ) => F;
 
 export type CallKeyserverEndpoint = (
   endpoint: Endpoint,
   requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
   options?: ?CallSingleKeyserverEndpointOptions,
 ) => Promise<{ +[keyserverID: string]: any }>;
 export type ActionFunc<Args: mixed, Return> = (
   callSingleKeyserverEndpoint: CallKeyserverEndpoint,
   // The second argument is only used in actions that call all keyservers,
   // and the request to all keyservers are exactly the same.
   // An example of such action is fetchEntries.
   allKeyserverIDs: $ReadOnlyArray<string>,
 ) => Args => Promise<Return>;
 
 export const setConnectionIssueActionType = 'SET_CONNECTION_ISSUE';
 
 export const updateConnectionStatusActionType = 'UPDATE_CONNECTION_STATUS';
 export type UpdateConnectionStatusPayload = {
   +status: ConnectionStatus,
   +keyserverID: string,
 };
 
 export const setLateResponseActionType = 'SET_LATE_RESPONSE';
 export type SetLateResponsePayload = {
   +messageID: number,
   +isLate: boolean,
   +keyserverID: string,
 };
 
 export const updateKeyserverReachabilityActionType =
   'UPDATE_KEYSERVER_REACHABILITY';
 export type UpdateKeyserverReachabilityPayload = {
   +visible: boolean,
   +keyserverID: string,
 };
 
+export const setSessionRecoveryInProgressActionType =
+  'SET_SESSION_RECOVERY_IN_PROGRESS';
+
 export { setNewSessionActionType, setNewSession };
diff --git a/lib/reducers/keyserver-reducer.js b/lib/reducers/keyserver-reducer.js
index 18ff770f2..99970f899 100644
--- a/lib/reducers/keyserver-reducer.js
+++ b/lib/reducers/keyserver-reducer.js
@@ -1,628 +1,651 @@
 // @flow
 
 import { unsupervisedBackgroundActionType } from './lifecycle-state-reducer.js';
 import { updateActivityActionTypes } from '../actions/activity-actions.js';
 import {
   updateLastCommunicatedPlatformDetailsActionType,
   setDeviceTokenActionTypes,
 } from '../actions/device-actions.js';
 import {
   addKeyserverActionType,
   removeKeyserverActionType,
 } from '../actions/keyserver-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   keyserverAuthActionTypes,
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
   deleteAccountActionTypes,
   keyserverRegisterActionTypes,
   logInActionTypes,
   resetUserStateActionType,
 } from '../actions/user-actions.js';
 import {
   setNewSessionActionType,
   updateConnectionStatusActionType,
   setLateResponseActionType,
   updateKeyserverReachabilityActionType,
   setConnectionIssueActionType,
+  setSessionRecoveryInProgressActionType,
 } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   keyserverStoreOpsHandlers,
   type ReplaceKeyserverOperation,
   type RemoveKeyserversOperation,
   type KeyserverStoreOperation,
 } from '../ops/keyserver-store-ops.js';
 import { queueActivityUpdatesActionType } from '../types/activity-types.js';
 import type { KeyserverStore } from '../types/keyserver-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import { getConfig } from '../utils/config.js';
 import { setURLPrefix } from '../utils/url-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const { processStoreOperations: processStoreOps } = keyserverStoreOpsHandlers;
 
 export default function reduceKeyserverStore(
   state: KeyserverStore,
   action: BaseAction,
 ): {
   keyserverStore: KeyserverStore,
   keyserverStoreOperations: $ReadOnlyArray<KeyserverStoreOperation>,
 } {
   if (action.type === addKeyserverActionType) {
     const replaceOperation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: action.payload.keyserverAdminUserID,
         keyserverInfo: {
           ...action.payload.newKeyserverInfo,
         },
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [
           replaceOperation,
         ]),
       },
       keyserverStoreOperations: [replaceOperation],
     };
   } else if (action.type === removeKeyserverActionType) {
     const removeOperation: RemoveKeyserversOperation = {
       type: 'remove_keyservers',
       payload: {
         ids: [action.payload.keyserverAdminUserID],
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [
           removeOperation,
         ]),
       },
       keyserverStoreOperations: [removeOperation],
     };
   } else if (action.type === resetUserStateActionType) {
     // this action is only dispatched on native
     const replaceOperations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in state.keyserverInfos) {
       const stateCookie = state.keyserverInfos[keyserverID]?.cookie;
       if (stateCookie && stateCookie.startsWith('anonymous=')) {
         continue;
       }
       replaceOperations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             cookie: null,
           },
         },
       });
     }
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(
           state.keyserverInfos,
           replaceOperations,
         ),
       },
       keyserverStoreOperations: replaceOperations,
     };
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID, sessionChange } = action.payload;
     if (!state.keyserverInfos[keyserverID]) {
       if (sessionChange.cookie?.startsWith('user=')) {
         console.log(
           'received sessionChange with user cookie, ' +
             `but keyserver ${keyserverID} is not in KeyserverStore!`,
         );
       }
       return {
         keyserverStore: state,
         keyserverStoreOperations: [],
       };
     }
 
     let newKeyserverInfo = {
       ...state.keyserverInfos[keyserverID],
     };
     let keyserverUpdated = false;
 
     if (sessionChange.cookie !== undefined) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         cookie: sessionChange.cookie,
       };
       keyserverUpdated = true;
     }
     if (sessionChange.cookieInvalidated) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         connection: {
           ...newKeyserverInfo.connection,
           queuedActivityUpdates: [],
         },
       };
       keyserverUpdated = true;
     }
 
     const operations: ReplaceKeyserverOperation[] = [];
     if (keyserverUpdated) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: newKeyserverInfo,
         },
       });
     }
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === keyserverAuthActionTypes.success
   ) {
     const { updatesCurrentAsOf } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in updatesCurrentAsOf) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             updatesCurrentAsOf: updatesCurrentAsOf[keyserverID],
             lastCommunicatedPlatformDetails: getConfig().platformDetails,
             connection: {
               ...state.keyserverInfos[keyserverID].connection,
               connectionIssue: null,
             },
           },
         },
       });
     }
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (action.type === fullStateSyncActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesCurrentAsOf,
         },
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === incrementalStateSyncActionType) {
     const { keyserverID } = action.payload;
     let { deviceToken } = state.keyserverInfos[keyserverID];
     for (const update of action.payload.updatesResult.newUpdates) {
       if (
         update.type === updateTypes.BAD_DEVICE_TOKEN &&
         update.deviceToken === state.keyserverInfos[keyserverID].deviceToken
       ) {
         deviceToken = null;
         break;
       }
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesResult.currentAsOf,
           deviceToken,
         },
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === processUpdatesActionType) {
     const { keyserverID } = action.payload;
     const updatesCurrentAsOf = Math.max(
       action.payload.updatesResult.currentAsOf,
       state.keyserverInfos[keyserverID].updatesCurrentAsOf,
     );
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf,
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setURLPrefix) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           urlPrefix: action.payload,
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateLastCommunicatedPlatformDetailsActionType) {
     const { keyserverID, platformDetails } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           lastCommunicatedPlatformDetails: platformDetails,
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === keyserverRegisterActionTypes.success) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           lastCommunicatedPlatformDetails: getConfig().platformDetails,
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateConnectionStatusActionType) {
     const { keyserverID, status } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status,
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === unsupervisedBackgroundActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status: 'disconnected',
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === queueActivityUpdatesActionType) {
     const { activityUpdates, keyserverID } = action.payload;
     const oldConnection = state.keyserverInfos[keyserverID].connection;
     const connection = {
       ...oldConnection,
       queuedActivityUpdates: [
         ...oldConnection.queuedActivityUpdates.filter(existingUpdate => {
           for (const activityUpdate of activityUpdates) {
             if (
               ((existingUpdate.focus && activityUpdate.focus) ||
                 (existingUpdate.focus === false &&
                   activityUpdate.focus !== undefined)) &&
               existingUpdate.threadID === activityUpdate.threadID
             ) {
               return false;
             }
           }
           return true;
         }),
         ...activityUpdates,
       ],
     };
 
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection,
         },
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const { activityUpdates } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in activityUpdates) {
       const oldConnection = state.keyserverInfos[keyserverID].connection;
       const queuedActivityUpdates = oldConnection.queuedActivityUpdates.filter(
         activityUpdate =>
           !activityUpdates[keyserverID].includes(activityUpdate),
       );
 
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             connection: { ...oldConnection, queuedActivityUpdates },
           },
         },
       });
     }
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success
   ) {
     // We want to remove all keyservers but Ashoat's keyserver
     const oldConnection = state.keyserverInfos[ashoatKeyserverID].connection;
     const operations: KeyserverStoreOperation[] = [
       { type: 'remove_all_keyservers' },
     ];
     operations.push({
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           connection: {
             ...oldConnection,
             connectionIssue: null,
             queuedActivityUpdates: [],
             lateResponses: [],
           },
           cookie: null,
         },
       },
     });
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     const operations: KeyserverStoreOperation[] = [
       {
         type: 'remove_keyservers',
         payload: { ids: action.payload.keyserverIDs },
       },
     ];
     if (action.payload.keyserverIDs.includes(ashoatKeyserverID)) {
       const oldConnection = state.keyserverInfos[ashoatKeyserverID].connection;
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: ashoatKeyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[ashoatKeyserverID],
             connection: {
               ...oldConnection,
               connectionIssue: null,
               queuedActivityUpdates: [],
               lateResponses: [],
             },
             cookie: null,
           },
         },
       });
     }
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setLateResponseActionType) {
     const { messageID, isLate, keyserverID } = action.payload;
     const lateResponsesSet = new Set<number>(
       state.keyserverInfos[keyserverID].connection.lateResponses,
     );
     if (isLate) {
       lateResponsesSet.add(messageID);
     } else {
       lateResponsesSet.delete(messageID);
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             lateResponses: [...lateResponsesSet],
           },
         },
       },
     };
 
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateKeyserverReachabilityActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             unreachable: action.payload.visible,
           },
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setDeviceTokenActionTypes.success) {
     const { deviceTokens } = action.payload;
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in deviceTokens) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             deviceToken: deviceTokens[keyserverID],
           },
         },
       });
     }
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, operations),
       },
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setConnectionIssueActionType) {
     const { connectionIssue, keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             connectionIssue,
           },
         },
       },
     };
     return {
       keyserverStore: {
         ...state,
         keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
       },
       keyserverStoreOperations: [operation],
     };
+  } else if (action.type === setSessionRecoveryInProgressActionType) {
+    const { sessionRecoveryInProgress, keyserverID } = action.payload;
+    const operation: ReplaceKeyserverOperation = {
+      type: 'replace_keyserver',
+      payload: {
+        id: keyserverID,
+        keyserverInfo: {
+          ...state.keyserverInfos[keyserverID],
+          connection: {
+            ...state.keyserverInfos[keyserverID].connection,
+            sessionRecoveryInProgress,
+          },
+        },
+      },
+    };
+    return {
+      keyserverStore: {
+        ...state,
+        keyserverInfos: processStoreOps(state.keyserverInfos, [operation]),
+      },
+      keyserverStoreOperations: [operation],
+    };
   }
 
   return {
     keyserverStore: state,
     keyserverStoreOperations: [],
   };
 }
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 7c588e018..cedffc6c3 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1360 +1,1364 @@
 // @flow
 
 import type {
   LogOutResult,
   KeyserverLogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
   KeyserverAuthResult,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type { DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   CalendarQuery,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IdentityAuthResult } from './identity-service-types.js';
 import type { IntegrityStore } from './integrity-types.js';
 import type {
   KeyserverStore,
   AddKeyserverPayload,
   RemoveKeyserverPayload,
 } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   SimpleMessagesPayload,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo, WebNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types.js';
 import type {
   ProcessServerRequestAction,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionIssue,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   LegacyThreadStore,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserInfos, UserStore } from './user-types.js';
 import type { SetDeviceTokenActionPayload } from '../actions/device-actions.js';
 import type {
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateKeyserverReachabilityPayload,
 } from '../keyserver-conn/keyserver-conn-types.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type ClientWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +commServicesAccessToken: null,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type ServerWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: LegacyThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +commServicesAccessToken: null,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type WebInitialKeyserverInfo = {
   +sessionID: ?string,
   +updatesCurrentAsOf: number,
 };
 
 export type BaseAction =
   | {
       +type: '@@redux/INIT',
       +payload?: void,
     }
   | {
       +type: 'FETCH_ENTRIES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_SUCCESS',
       +payload: FetchEntryInfosResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_SUCCESS',
       +payload: KeyserverLogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_SUCCESS',
       +payload: ClaimUsernameResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
       +payload: KeyserverLogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_LOCAL_ENTRY',
       +payload: RawEntryInfo,
     }
   | {
       +type: 'CREATE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_SUCCESS',
       +payload: CreateEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_SUCCESS',
       +payload: SaveEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CONCURRENT_MODIFICATION_RESET',
       +payload: {
         +id: string,
         +dbText: string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: {
         +localID: ?string,
         +serverID: ?string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ENTRY_SUCCESS',
       +payload: ?DeleteEntryResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TEMP_IDENTITY_LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TEMP_IDENTITY_LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TEMP_IDENTITY_LOG_IN_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'KEYSERVER_AUTH_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'KEYSERVER_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'KEYSERVER_AUTH_SUCCESS',
       +payload: KeyserverAuthResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'KEYSERVER_REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'KEYSERVER_REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'KEYSERVER_REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'IDENTITY_REGISTER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'IDENTITY_REGISTER_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'IDENTITY_REGISTER_SUCCESS',
       +payload: IdentityAuthResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_SUCCESS',
       +payload: NewThreadResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
       +payload: FetchRevisionsForEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_SUCCESS',
       +payload: RestoreEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_SUCCESS',
       +payload: ThreadJoinPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_NEW_SESSION',
       +payload: SetSessionPayload,
     }
   | {
       +type: 'persist/REHYDRATE',
       +payload: ?BaseAppState<>,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
       +payload: SimpleMessagesPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawTextMessageInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawMultimediaMessageInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawReactionMessageInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
         +targetMessageID: string,
         +reaction: string,
         +action: string,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_SUCCESS',
       +payload: UserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_SUCCESS',
       +payload: ExactUserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: ClientStore,
     }
   | {
       +type: 'UPDATE_ACTIVITY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_SUCCESS',
       +payload: ActivityUpdateSuccessPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: SetDeviceTokenActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'QUEUE_REPORTS',
       +payload: QueueReportsPayload,
     }
   | {
       +type: 'SET_URL_PREFIX',
       +payload: string,
     }
   | {
       +type: 'SAVE_MESSAGES',
       +payload: SaveMessagesPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_THREAD_FILTER',
       +payload: CalendarThreadFilter,
     }
   | {
       +type: 'CLEAR_CALENDAR_THREAD_FILTER',
       +payload?: void,
     }
   | {
       +type: 'SET_CALENDAR_DELETED_FILTER',
       +payload: SetCalendarDeletedFilterPayload,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
       +payload: SubscriptionUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: CalendarQueryUpdateStartingPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
       +payload: CalendarQueryUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FULL_STATE_SYNC',
       +payload: StateSyncFullActionPayload,
     }
   | {
       +type: 'INCREMENTAL_STATE_SYNC',
       +payload: StateSyncIncrementalActionPayload,
     }
   | ProcessServerRequestAction
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload: { +keyserverID: string },
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Partial<EnabledReports>,
     }
   | {
       +type: 'PROCESS_UPDATES',
       +payload: ClientUpdatesResultWithUserInfos,
     }
   | {
       +type: 'PROCESS_MESSAGES',
       +payload: NewMessagesPayload,
     }
   | {
       +type: 'MESSAGE_STORE_PRUNE',
       +payload: MessageStorePrunePayload,
     }
   | {
       +type: 'SET_LATE_RESPONSE',
       +payload: SetLateResponsePayload,
     }
   | {
       +type: 'UPDATE_KEYSERVER_REACHABILITY',
       +payload: UpdateKeyserverReachabilityPayload,
     }
   | {
       +type: 'REQUEST_ACCESS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       +payload: UpdateMultimediaMessageMediaPayload,
     }
   | {
       +type: 'CREATE_LOCAL_MESSAGE',
       +payload: LocallyComposedMessageInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
       +payload: RelationshipErrors,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
       +payload: {
         +threadID: string,
         +unread: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
       +payload: SetThreadUnreadStatusPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_USER_SETTINGS_SUCCESS',
       +payload: DefaultNotificationPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_SUCCESS',
       +payload: MessageReportCreationResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
       +payload: ForcePolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
       +payload: PolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +type: 'UPDATE_USER_AVATAR_STARTED',
       +payload: UpdateUserAvatarRequest,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_SUCCESS',
       +payload: UpdateUserAvatarResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_SUCCESS',
       +payload: EditMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
       +payload: ToggleMessagePinResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
       +payload: FetchPinnedMessagesResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_SUCCESS',
       +payload: InviteLinkVerificationResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
       +payload: FetchInviteLinksResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'SEARCH_MESSAGES_STARTED',
       +payload: void,
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_SUCCESS',
       +payload: SearchMessagesResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
       +payload: InviteLink,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_SUCCESS',
       +payload: DisableInviteLinkPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
       +payload: GetOlmSessionInitializationDataResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DATA_LOADED',
       +payload: {
         +dataLoaded: boolean,
       },
     }
   | {
       +type: 'GET_VERSION_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_VERSION_SUCCESS',
       +payload: GetVersionActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_VERSION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
       +payload: LastCommunicatedPlatformDetails,
     }
   | { +type: 'RESET_USER_STATE', +payload?: void }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleModificationPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleDeletionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_ACCESS_TOKEN',
       +payload: string,
     }
   | {
       +type: 'UPDATE_THREAD_LAST_NAVIGATED',
       +payload: { +threadID: string, +time: number },
     }
   | {
       +type: 'UPDATE_INTEGRITY_STORE',
       +payload: {
         +threadIDsToHash?: $ReadOnlyArray<string>,
         +threadHashingStatus?: 'starting' | 'running' | 'completed',
       },
     }
   | {
       +type: 'UPDATE_THEME_INFO',
       +payload: Partial<GlobalThemeInfo>,
     }
   | {
       +type: 'ADD_KEYSERVER',
       +payload: AddKeyserverPayload,
     }
   | {
       +type: 'REMOVE_KEYSERVER',
       +payload: RemoveKeyserverPayload,
     }
   | {
       +type: 'SET_CUSTOM_SERVER',
       +payload: string,
     }
   | {
       +type: 'SET_CONNECTION_ISSUE',
       +payload: { +connectionIssue: ?ConnectionIssue, +keyserverID: string },
+    }
+  | {
+      +type: 'SET_SESSION_RECOVERY_IN_PROGRESS',
+      +payload: { +sessionRecoveryInProgress: boolean, +keyserverID: string },
     };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';