diff --git a/lib/actions/message-actions.js b/lib/actions/message-actions.js
index 0372baef9..df34d7269 100644
--- a/lib/actions/message-actions.js
+++ b/lib/actions/message-actions.js
@@ -1,219 +1,226 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type {
   FetchMessageInfosPayload,
   SendMessageResult,
   SimpleMessagesPayload,
 } from '../types/message-types';
 import type { MediaMessageServerDBContent } from '../types/messages/media.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointResultInfo,
 } from '../utils/call-server-endpoint';
 
 const fetchMessagesBeforeCursorActionTypes = Object.freeze({
   started: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
   success: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
   failed: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
 });
 const fetchMessagesBeforeCursor = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   beforeMessageID: string,
 ) => Promise<FetchMessageInfosPayload>) => async (
   threadID,
   beforeMessageID,
 ) => {
   const response = await callServerEndpoint('fetch_messages', {
     cursors: {
       [threadID]: beforeMessageID,
     },
   });
   return {
     threadID,
     rawMessageInfos: response.rawMessageInfos,
     truncationStatus: response.truncationStatuses[threadID],
   };
 };
 
 const fetchMostRecentMessagesActionTypes = Object.freeze({
   started: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
   success: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
   failed: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
 });
 const fetchMostRecentMessages = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
 ) => Promise<FetchMessageInfosPayload>) => async threadID => {
   const response = await callServerEndpoint('fetch_messages', {
     cursors: {
       [threadID]: null,
     },
   });
   return {
     threadID,
     rawMessageInfos: response.rawMessageInfos,
     truncationStatus: response.truncationStatuses[threadID],
   };
 };
 
 const fetchSingleMostRecentMessagesFromThreadsActionTypes = Object.freeze({
   started: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
   success: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
   failed: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
 });
 const fetchSingleMostRecentMessagesFromThreads = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadIDs: $ReadOnlyArray<string>,
 ) => Promise<SimpleMessagesPayload>) => async threadIDs => {
   const cursors = Object.fromEntries(
     threadIDs.map(threadID => [threadID, null]),
   );
   const response = await callServerEndpoint('fetch_messages', {
     cursors,
     numberPerThread: 1,
   });
   return {
     rawMessageInfos: response.rawMessageInfos,
     truncationStatuses: response.truncationStatuses,
   };
 };
 
 const sendTextMessageActionTypes = Object.freeze({
   started: 'SEND_TEXT_MESSAGE_STARTED',
   success: 'SEND_TEXT_MESSAGE_SUCCESS',
   failed: 'SEND_TEXT_MESSAGE_FAILED',
 });
 const sendTextMessage = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   localID: string,
   text: string,
 ) => Promise<SendMessageResult>) => async (threadID, localID, text) => {
   let resultInfo;
   const getResultInfo = (passedResultInfo: CallServerEndpointResultInfo) => {
     resultInfo = passedResultInfo;
   };
   const response = await callServerEndpoint(
     'create_text_message',
     {
       threadID,
       localID,
       text,
     },
     { getResultInfo },
   );
   const resultInterface = resultInfo?.interface;
   invariant(
     resultInterface,
     'getResultInfo not called before callServerEndpoint resolves',
   );
   return {
     id: response.newMessageInfo.id,
     time: response.newMessageInfo.time,
     interface: resultInterface,
   };
 };
 
 const createLocalMessageActionType = 'CREATE_LOCAL_MESSAGE';
 
 const sendMultimediaMessageActionTypes = Object.freeze({
   started: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
   success: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
   failed: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
 });
 const sendMultimediaMessage = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   localID: string,
   mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
 ) => Promise<SendMessageResult>) => async (
   threadID,
   localID,
   mediaMessageContents,
 ) => {
   let resultInfo;
   const getResultInfo = (passedResultInfo: CallServerEndpointResultInfo) => {
     resultInfo = passedResultInfo;
   };
   const response = await callServerEndpoint(
     'create_multimedia_message',
     {
       threadID,
       localID,
       mediaMessageContents,
     },
     { getResultInfo },
   );
   const resultInterface = resultInfo?.interface;
   invariant(
     resultInterface,
     'getResultInfo not called before callServerEndpoint resolves',
   );
   return {
     id: response.newMessageInfo.id,
     time: response.newMessageInfo.time,
     interface: resultInterface,
   };
 };
 
 const legacySendMultimediaMessage = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   localID: string,
   mediaIDs: $ReadOnlyArray<string>,
 ) => Promise<SendMessageResult>) => async (threadID, localID, mediaIDs) => {
   let resultInfo;
   const getResultInfo = (passedResultInfo: CallServerEndpointResultInfo) => {
     resultInfo = passedResultInfo;
   };
   const response = await callServerEndpoint(
     'create_multimedia_message',
     {
       threadID,
       localID,
       mediaIDs,
     },
     { getResultInfo },
   );
   const resultInterface = resultInfo?.interface;
   invariant(
     resultInterface,
     'getResultInfo not called before callServerEndpoint resolves',
   );
   return {
     id: response.newMessageInfo.id,
     time: response.newMessageInfo.time,
     interface: resultInterface,
   };
 };
 
+const sendReactionMessageActionTypes = Object.freeze({
+  started: 'SEND_REACTION_MESSAGE_STARTED',
+  success: 'SEND_REACTION_MESSAGE_SUCCESS',
+  failed: 'SEND_REACTION_MESSAGE_FAILED',
+});
+
 const saveMessagesActionType = 'SAVE_MESSAGES';
 const processMessagesActionType = 'PROCESS_MESSAGES';
 const messageStorePruneActionType = 'MESSAGE_STORE_PRUNE';
 
 export {
   fetchMessagesBeforeCursorActionTypes,
   fetchMessagesBeforeCursor,
   fetchMostRecentMessagesActionTypes,
   fetchMostRecentMessages,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
   fetchSingleMostRecentMessagesFromThreads,
   sendTextMessageActionTypes,
   sendTextMessage,
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   sendMultimediaMessage,
   legacySendMultimediaMessage,
+  sendReactionMessageActionTypes,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
 };
diff --git a/lib/types/message-types.js b/lib/types/message-types.js
index 0cd2ce449..600a55713 100644
--- a/lib/types/message-types.js
+++ b/lib/types/message-types.js
@@ -1,586 +1,593 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { CallServerEndpointResultInfoInterface } from '../utils/call-server-endpoint';
 import { type ClientDBMediaInfo } from './media-types';
 import type {
   AddMembersMessageData,
   AddMembersMessageInfo,
   RawAddMembersMessageInfo,
 } from './messages/add-members';
 import type {
   ChangeRoleMessageData,
   ChangeRoleMessageInfo,
   RawChangeRoleMessageInfo,
 } from './messages/change-role';
 import type {
   ChangeSettingsMessageData,
   ChangeSettingsMessageInfo,
   RawChangeSettingsMessageInfo,
 } from './messages/change-settings';
 import type {
   CreateEntryMessageData,
   CreateEntryMessageInfo,
   RawCreateEntryMessageInfo,
 } from './messages/create-entry';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from './messages/create-sidebar';
 import type {
   CreateSubthreadMessageData,
   CreateSubthreadMessageInfo,
   RawCreateSubthreadMessageInfo,
 } from './messages/create-subthread';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from './messages/create-thread';
 import type {
   DeleteEntryMessageData,
   DeleteEntryMessageInfo,
   RawDeleteEntryMessageInfo,
 } from './messages/delete-entry';
 import type {
   EditEntryMessageData,
   EditEntryMessageInfo,
   RawEditEntryMessageInfo,
 } from './messages/edit-entry';
 import type {
   ImagesMessageData,
   ImagesMessageInfo,
   RawImagesMessageInfo,
 } from './messages/images';
 import type {
   JoinThreadMessageData,
   JoinThreadMessageInfo,
   RawJoinThreadMessageInfo,
 } from './messages/join-thread';
 import type {
   LeaveThreadMessageData,
   LeaveThreadMessageInfo,
   RawLeaveThreadMessageInfo,
 } from './messages/leave-thread';
 import type {
   MediaMessageData,
   MediaMessageInfo,
   MediaMessageServerDBContent,
   RawMediaMessageInfo,
 } from './messages/media';
 import type {
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageData,
   RemoveMembersMessageInfo,
 } from './messages/remove-members';
 import type {
   RawRestoreEntryMessageInfo,
   RestoreEntryMessageData,
   RestoreEntryMessageInfo,
 } from './messages/restore-entry';
 import type {
   RawTextMessageInfo,
   TextMessageData,
   TextMessageInfo,
 } from './messages/text';
 import type {
   RawUnsupportedMessageInfo,
   UnsupportedMessageInfo,
 } from './messages/unsupported';
 import type {
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageData,
   UpdateRelationshipMessageInfo,
 } from './messages/update-relationship';
 import { type RelativeUserInfo, type UserInfos } from './user-types';
 
 export const messageTypes = Object.freeze({
   TEXT: 0,
   // Appears in the newly created thread
   CREATE_THREAD: 1,
   ADD_MEMBERS: 2,
   // Appears in the parent when a child thread is created
   // (historically also when a sidebar was created)
   CREATE_SUB_THREAD: 3,
   CHANGE_SETTINGS: 4,
   REMOVE_MEMBERS: 5,
   CHANGE_ROLE: 6,
   LEAVE_THREAD: 7,
   JOIN_THREAD: 8,
   CREATE_ENTRY: 9,
   EDIT_ENTRY: 10,
   DELETE_ENTRY: 11,
   RESTORE_ENTRY: 12,
   // When the server has a message to deliver that the client can't properly
   // render because the client is too old, the server will send this message
   // type instead. Consequently, there is no MessageData for UNSUPPORTED - just
   // a RawMessageInfo and a MessageInfo. Note that native/persist.js handles
   // converting these MessageInfos when the client is upgraded.
   UNSUPPORTED: 13,
   IMAGES: 14,
   MULTIMEDIA: 15,
   UPDATE_RELATIONSHIP: 16,
   SIDEBAR_SOURCE: 17,
   // Appears in the newly created sidebar
   CREATE_SIDEBAR: 18,
   REACTION: 19,
 });
 export type MessageType = $Values<typeof messageTypes>;
 export function assertMessageType(ourMessageType: number): MessageType {
   invariant(
     ourMessageType === 0 ||
       ourMessageType === 1 ||
       ourMessageType === 2 ||
       ourMessageType === 3 ||
       ourMessageType === 4 ||
       ourMessageType === 5 ||
       ourMessageType === 6 ||
       ourMessageType === 7 ||
       ourMessageType === 8 ||
       ourMessageType === 9 ||
       ourMessageType === 10 ||
       ourMessageType === 11 ||
       ourMessageType === 12 ||
       ourMessageType === 13 ||
       ourMessageType === 14 ||
       ourMessageType === 15 ||
       ourMessageType === 16 ||
       ourMessageType === 17 ||
       ourMessageType === 18 ||
       ourMessageType === 19,
     'number is not MessageType enum',
   );
   return ourMessageType;
 }
 
 const composableMessageTypes = new Set([
   messageTypes.TEXT,
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
 ]);
 export function isComposableMessageType(ourMessageType: MessageType): boolean {
   return composableMessageTypes.has(ourMessageType);
 }
 export function assertComposableMessageType(
   ourMessageType: MessageType,
 ): MessageType {
   invariant(
     isComposableMessageType(ourMessageType),
     'MessageType is not composed',
   );
   return ourMessageType;
 }
 export function assertComposableRawMessage(
   message: RawMessageInfo,
 ): RawComposableMessageInfo {
   invariant(
     message.type === messageTypes.TEXT ||
       message.type === messageTypes.IMAGES ||
       message.type === messageTypes.MULTIMEDIA,
     'Message is not composable',
   );
   return message;
 }
 export function messageDataLocalID(messageData: MessageData): ?string {
   if (
     messageData.type !== messageTypes.TEXT &&
     messageData.type !== messageTypes.IMAGES &&
     messageData.type !== messageTypes.MULTIMEDIA
   ) {
     return null;
   }
   return messageData.localID;
 }
 
 const mediaMessageTypes = new Set([
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
 ]);
 export function isMediaMessageType(ourMessageType: MessageType): boolean {
   return mediaMessageTypes.has(ourMessageType);
 }
 export function assertMediaMessageType(
   ourMessageType: MessageType,
 ): MessageType {
   invariant(isMediaMessageType(ourMessageType), 'MessageType is not media');
   return ourMessageType;
 }
 
 // *MessageData = passed to createMessages function to insert into database
 // Raw*MessageInfo = used by server, and contained in client's local store
 // *MessageInfo = used by client in UI code
 
 export type SidebarSourceMessageData = {
   +type: 17,
   +threadID: string,
   +creatorID: string,
   +time: number,
   +sourceMessage?: RawComposableMessageInfo | RawRobotextMessageInfo,
 };
 
 export type ReactionMessageData = {
   +type: 19,
   +threadID: string,
   +creatorID: string,
   +time: number,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 
 export type MessageData =
   | TextMessageData
   | CreateThreadMessageData
   | AddMembersMessageData
   | CreateSubthreadMessageData
   | ChangeSettingsMessageData
   | RemoveMembersMessageData
   | ChangeRoleMessageData
   | LeaveThreadMessageData
   | JoinThreadMessageData
   | CreateEntryMessageData
   | EditEntryMessageData
   | DeleteEntryMessageData
   | RestoreEntryMessageData
   | ImagesMessageData
   | MediaMessageData
   | UpdateRelationshipMessageData
   | SidebarSourceMessageData
   | CreateSidebarMessageData
   | ReactionMessageData;
 
 export type MultimediaMessageData = ImagesMessageData | MediaMessageData;
 
 export type RawMultimediaMessageInfo =
   | RawImagesMessageInfo
   | RawMediaMessageInfo;
 export type RawComposableMessageInfo =
   | RawTextMessageInfo
   | RawMultimediaMessageInfo;
 
 export type RawRobotextMessageInfo =
   | RawCreateThreadMessageInfo
   | RawAddMembersMessageInfo
   | RawCreateSubthreadMessageInfo
   | RawChangeSettingsMessageInfo
   | RawRemoveMembersMessageInfo
   | RawChangeRoleMessageInfo
   | RawLeaveThreadMessageInfo
   | RawJoinThreadMessageInfo
   | RawCreateEntryMessageInfo
   | RawEditEntryMessageInfo
   | RawDeleteEntryMessageInfo
   | RawRestoreEntryMessageInfo
   | RawUpdateRelationshipMessageInfo
   | RawCreateSidebarMessageInfo
   | RawUnsupportedMessageInfo;
 export type RawSidebarSourceMessageInfo = {
   ...SidebarSourceMessageData,
   id: string,
 };
 
 export type RawReactionMessageInfo = {
   ...ReactionMessageData,
   id: string,
 };
 
 export type RawMessageInfo =
   | RawComposableMessageInfo
   | RawRobotextMessageInfo
   | RawSidebarSourceMessageInfo
   | RawReactionMessageInfo;
 
 export type LocallyComposedMessageInfo =
   | ({
       ...RawImagesMessageInfo,
       +localID: string,
     } & RawImagesMessageInfo)
   | ({
       ...RawMediaMessageInfo,
       +localID: string,
     } & RawMediaMessageInfo)
   | ({
       ...RawTextMessageInfo,
       +localID: string,
     } & RawTextMessageInfo);
 
 export type MultimediaMessageInfo = ImagesMessageInfo | MediaMessageInfo;
 export type ComposableMessageInfo = TextMessageInfo | MultimediaMessageInfo;
 
 export type RobotextMessageInfo =
   | CreateThreadMessageInfo
   | AddMembersMessageInfo
   | CreateSubthreadMessageInfo
   | ChangeSettingsMessageInfo
   | RemoveMembersMessageInfo
   | ChangeRoleMessageInfo
   | LeaveThreadMessageInfo
   | JoinThreadMessageInfo
   | CreateEntryMessageInfo
   | EditEntryMessageInfo
   | DeleteEntryMessageInfo
   | RestoreEntryMessageInfo
   | UnsupportedMessageInfo
   | UpdateRelationshipMessageInfo
   | CreateSidebarMessageInfo;
 export type PreviewableMessageInfo =
   | RobotextMessageInfo
   | MultimediaMessageInfo
   | ReactionMessageInfo;
 
 export type SidebarSourceMessageInfo = {
   +type: 17,
   +id: string,
   +threadID: string,
   +creator: RelativeUserInfo,
   +time: number,
   +sourceMessage: ComposableMessageInfo | RobotextMessageInfo,
 };
 
 export type ReactionMessageInfo = {
   +type: 19,
   +id: string,
   +threadID: string,
   +creator: RelativeUserInfo,
   +time: number,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 
 export type MessageInfo =
   | ComposableMessageInfo
   | RobotextMessageInfo
   | SidebarSourceMessageInfo
   | ReactionMessageInfo;
 
 export type ThreadMessageInfo = {
   messageIDs: string[],
   startReached: boolean,
   lastNavigatedTo: number, // millisecond timestamp
   lastPruned: number, // millisecond timestamp
 };
 
 // Tracks client-local information about a message that hasn't been assigned an
 // ID by the server yet. As soon as the client gets an ack from the server for
 // this message, it will clear the LocalMessageInfo.
 export type LocalMessageInfo = {
   +sendFailed?: boolean,
 };
 
 export type MessageStore = {
   +messages: { +[id: string]: RawMessageInfo },
   +threads: { +[threadID: string]: ThreadMessageInfo },
   +local: { +[id: string]: LocalMessageInfo },
   +currentAsOf: number,
 };
 
 export type RemoveMessageOperation = {
   +type: 'remove',
   +payload: { +ids: $ReadOnlyArray<string> },
 };
 
 export type RemoveMessagesForThreadsOperation = {
   +type: 'remove_messages_for_threads',
   +payload: { +threadIDs: $ReadOnlyArray<string> },
 };
 
 export type ReplaceMessageOperation = {
   +type: 'replace',
   +payload: { +id: string, +messageInfo: RawMessageInfo },
 };
 
 export type RekeyMessageOperation = {
   +type: 'rekey',
   +payload: { +from: string, +to: string },
 };
 
 export type RemoveAllMessagesOperation = {
   +type: 'remove_all',
 };
 
 // We were initially using `number`s` for `thread`, `type`, `future_type`, etc.
 // However, we ended up changing `thread` to `string` to account for thread IDs
 // including information about the keyserver (eg 'GENESIS|123') in the future.
 //
 // At that point we discussed whether we should switch the remaining `number`
 // fields to `string`s for consistency and flexibility. We researched whether
 // there was any performance cost to using `string`s instead of `number`s and
 // found the differences to be negligible. We also concluded using `string`s
 // may be safer after considering `jsi::Number` and the various C++ number
 // representations on the CommCoreModule side.
 export type ClientDBMessageInfo = {
   +id: string,
   +local_id: ?string,
   +thread: string,
   +user: string,
   +type: string,
   +future_type: ?string,
   +content: ?string,
   +time: string,
   +media_infos: ?$ReadOnlyArray<ClientDBMediaInfo>,
 };
 
 export type ClientDBReplaceMessageOperation = {
   +type: 'replace',
   +payload: ClientDBMessageInfo,
 };
 
 export type MessageStoreOperation =
   | RemoveMessageOperation
   | ReplaceMessageOperation
   | RekeyMessageOperation
   | RemoveMessagesForThreadsOperation
   | RemoveAllMessagesOperation;
 
 export type ClientDBMessageStoreOperation =
   | RemoveMessageOperation
   | ClientDBReplaceMessageOperation
   | RekeyMessageOperation
   | RemoveMessagesForThreadsOperation
   | RemoveAllMessagesOperation;
 
 export const messageTruncationStatus = Object.freeze({
   // EXHAUSTIVE means we've reached the start of the thread. Either the result
   // set includes the very first message for that thread, or there is nothing
   // behind the cursor you queried for. Given that the client only ever issues
   // ranged queries whose range, when unioned with what is in state, represent
   // the set of all messages for a given thread, we can guarantee that getting
   // EXHAUSTIVE means the start has been reached.
   EXHAUSTIVE: 'exhaustive',
   // TRUNCATED is rare, and means that the server can't guarantee that the
   // result set for a given thread is contiguous with what the client has in its
   // state. If the client can't verify the contiguousness itself, it needs to
   // replace its Redux store's contents with what it is in this payload.
   //  1) getMessageInfosSince: Result set for thread is equal to max, and the
   //     truncation status isn't EXHAUSTIVE (ie. doesn't include the very first
   //     message).
   //  2) getMessageInfos: MessageSelectionCriteria does not specify cursors, the
   //     result set for thread is equal to max, and the truncation status isn't
   //     EXHAUSTIVE. If cursors are specified, we never return truncated, since
   //     the cursor given us guarantees the contiguousness of the result set.
   // Note that in the reducer, we can guarantee contiguousness if there is any
   // intersection between messageIDs in the result set and the set currently in
   // the Redux store.
   TRUNCATED: 'truncated',
   // UNCHANGED means the result set is guaranteed to be contiguous with what the
   // client has in its state, but is not EXHAUSTIVE. Basically, it's anything
   // that isn't either EXHAUSTIVE or TRUNCATED.
   UNCHANGED: 'unchanged',
 });
 export type MessageTruncationStatus = $Values<typeof messageTruncationStatus>;
 export function assertMessageTruncationStatus(
   ourMessageTruncationStatus: string,
 ): MessageTruncationStatus {
   invariant(
     ourMessageTruncationStatus === 'truncated' ||
       ourMessageTruncationStatus === 'unchanged' ||
       ourMessageTruncationStatus === 'exhaustive',
     'string is not ourMessageTruncationStatus enum',
   );
   return ourMessageTruncationStatus;
 }
 export type MessageTruncationStatuses = {
   [threadID: string]: MessageTruncationStatus,
 };
 
 export type ThreadCursors = { +[threadID: string]: ?string };
 
 export type MessageSelectionCriteria = {
   +threadCursors?: ?ThreadCursors,
   +joinedThreads?: ?boolean,
   +newerThan?: ?number,
 };
 
 export type FetchMessageInfosRequest = {
   +cursors: ThreadCursors,
   +numberPerThread?: ?number,
 };
 export type FetchMessageInfosResponse = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type FetchMessageInfosResult = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 export type FetchMessageInfosPayload = {
   +threadID: string,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatus: MessageTruncationStatus,
 };
 export type MessagesResponse = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +currentAsOf: number,
 };
 export type SimpleMessagesPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 export const defaultNumberPerThread = 20;
 export const defaultMaxMessageAge = 14 * 24 * 60 * 60 * 1000; // 2 weeks
 
 export type SendMessageResponse = {
   +newMessageInfo: RawMessageInfo,
 };
 export type SendMessageResult = {
   +id: string,
   +time: number,
   +interface: CallServerEndpointResultInfoInterface,
 };
 export type SendMessagePayload = {
   +localID: string,
   +serverID: string,
   +threadID: string,
   +time: number,
   +interface: CallServerEndpointResultInfoInterface,
 };
 
+export type SendReactionMessagePayload = {
+  +serverID: string,
+  +threadID: string,
+  +time: number,
+  +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
+};
+
 export type SendTextMessageRequest = {
   +threadID: string,
   +localID?: string,
   +text: string,
 };
 export type SendMultimediaMessageRequest =
   | {
       +threadID: string,
       +localID: string,
       +mediaIDs: $ReadOnlyArray<string>,
     }
   | {
       +threadID: string,
       +localID: string,
       +mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
     };
 
 export type SendReactionMessageRequest = {
   +threadID: string,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 
 // Used for the message info included in log-in type actions
 export type GenericMessagesResult = {
   +messageInfos: RawMessageInfo[],
   +truncationStatus: MessageTruncationStatuses,
   +watchedIDsAtRequestTime: $ReadOnlyArray<string>,
   +currentAsOf: number,
 };
 
 export type SaveMessagesPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +updatesCurrentAsOf: number,
 };
 
 export type NewMessagesPayload = {
   +messagesResult: MessagesResponse,
 };
 
 export type MessageStorePrunePayload = {
   +threadIDs: $ReadOnlyArray<string>,
 };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 68a46a037..30a660862 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,876 +1,898 @@
 // @flow
 
 import type { Shape } from '../types/core';
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
 } from './account-types';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types';
 import type { EnabledApps, SupportedApps } from './enabled-apps';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from './entry-types';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types';
 import type { LifecycleState } from './lifecycle-state-types';
 import type { LoadingStatus, LoadingInfo } from './loading-types';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types';
 import type { MessageReportCreationResult } from './message-report-types';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
+  RawReactionMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
+  SendReactionMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
 } from './message-types';
 import type { RawTextMessageInfo } from './messages/text';
 import type { BaseNavInfo } from './nav-types';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types';
 import type { ProcessServerRequestsPayload } from './request-types';
 import type { UserSearchResult } from './search-types';
 import type { SetSessionPayload } from './session-types';
 import type {
   ConnectionInfo,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types';
 import type { SubscriptionUpdateResult } from './subscription-types';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
 } from './thread-types';
 import type { ClientUpdatesResultWithUserInfos } from './update-types';
 import type { CurrentUserInfo, UserStore } from './user-types';
 
 export type BaseAppState<NavInfo: BaseNavInfo> = {
   navInfo: NavInfo,
   currentUserInfo: ?CurrentUserInfo,
   draftStore: DraftStore,
   entryStore: EntryStore,
   threadStore: ThreadStore,
   userStore: UserStore,
   messageStore: MessageStore,
   updatesCurrentAsOf: number, // millisecond timestamp
   loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   calendarFilters: $ReadOnlyArray<CalendarFilter>,
   urlPrefix: string,
   connection: ConnectionInfo,
   watchedThreadIDs: $ReadOnlyArray<string>,
   lifecycleState: LifecycleState,
   enabledApps: EnabledApps,
   reportStore: ReportStore,
   nextLocalID: number,
   dataLoaded: boolean,
   userPolicies: UserPolicies,
   ...
 };
 
 // Web JS runtime doesn't have access to the cookie for security reasons.
 // Native JS doesn't have a sessionID because the cookieID is used instead.
 // Web JS doesn't have a device token because it's not a device...
 export type NativeAppState = BaseAppState<*> & {
   sessionID?: void,
   deviceToken: ?string,
   cookie: ?string,
   ...
 };
 export type WebAppState = BaseAppState<*> & {
   sessionID: ?string,
   deviceToken?: void,
   cookie?: void,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 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: LogOutResult,
       +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: '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: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_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: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +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 & {
+        +targetMessageID: string,
+        +threadID: string,
+        +reaction: string,
+      },
+      +loadingInfo: LoadingInfo,
+    }
+  | {
+      +type: 'SEND_REACTION_MESSAGE_SUCCESS',
+      +payload: SendReactionMessagePayload,
+      +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: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
         +messages: $ReadOnlyArray<ClientDBMessageInfo>,
         +threadStore: ThreadStore,
       },
     }
   | {
       +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: ?string,
       +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,
     }
   | {
       +type: 'PROCESS_SERVER_REQUESTS',
       +payload: ProcessServerRequestsPayload,
     }
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<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_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +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,
     };
 
 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';