diff --git a/lib/reducers/dm-operations-queue-reducer.js b/lib/reducers/dm-operations-queue-reducer.js
index 8fb5ccda5..286a7a974 100644
--- a/lib/reducers/dm-operations-queue-reducer.js
+++ b/lib/reducers/dm-operations-queue-reducer.js
@@ -1,61 +1,145 @@
 // @flow
 
 import _mapValues from 'lodash/fp/mapValues.js';
 
 import {
+  clearQueuedEntryDMOpsActionType,
+  clearQueuedMembershipDMOpsActionType,
+  clearQueuedMessageDMOpsActionType,
   clearQueuedThreadDMOpsActionType,
   type OperationsQueue,
   pruneDMOpsQueueActionType,
   type QueuedDMOperations,
   queueDMOpsActionType,
 } from '../types/dm-ops.js';
 import type { BaseAction } from '../types/redux-types.js';
 
 function reduceDMOperationsQueue(
   store: QueuedDMOperations,
   action: BaseAction,
 ): QueuedDMOperations {
   if (action.type === queueDMOpsActionType) {
-    const { threadID, operation, timestamp } = action.payload;
+    const { condition, operation, timestamp } = action.payload;
+
+    if (condition.type === 'thread') {
+      return {
+        ...store,
+        threadQueue: {
+          ...store.threadQueue,
+          [condition.threadID]: [
+            ...(store.threadQueue[condition.threadID] ?? []),
+            { operation, timestamp },
+          ],
+        },
+      };
+    }
+
+    if (condition.type === 'entry') {
+      return {
+        ...store,
+        entryQueue: {
+          ...store.entryQueue,
+          [condition.entryID]: [
+            ...(store.entryQueue[condition.entryID] ?? []),
+            { operation, timestamp },
+          ],
+        },
+      };
+    }
+
+    if (condition.type === 'message') {
+      return {
+        ...store,
+        messageQueue: {
+          ...store.messageQueue,
+          [condition.messageID]: [
+            ...(store.messageQueue[condition.messageID] ?? []),
+            { operation, timestamp },
+          ],
+        },
+      };
+    }
+
     return {
       ...store,
-      threadQueue: {
-        ...store.threadQueue,
-        [threadID]: [
-          ...(store.threadQueue[threadID] ?? []),
-          { operation, timestamp },
-        ],
+      membershipQueue: {
+        ...store.membershipQueue,
+        [condition.threadID]: {
+          ...(store.membershipQueue[condition.threadID] ?? {}),
+          [condition.userID]: [
+            ...(store.membershipQueue[condition.threadID]?.[condition.userID] ??
+              []),
+            { operation, timestamp },
+          ],
+        },
       },
     };
   } else if (action.type === pruneDMOpsQueueActionType) {
     const filterOperations = (queue: OperationsQueue) =>
       queue.filter(op => op.timestamp >= action.payload.pruneMaxTimestamp);
     return {
       ...store,
       threadQueue: _mapValues(operations => filterOperations(operations))(
         store.threadQueue,
       ),
       messageQueue: _mapValues(operations => filterOperations(operations))(
         store.messageQueue,
       ),
       entryQueue: _mapValues(operations => filterOperations(operations))(
         store.entryQueue,
       ),
       membershipQueue: _mapValues(threadMembershipQueue =>
         _mapValues(operations => filterOperations(operations))(
           threadMembershipQueue,
         ),
       )(store.membershipQueue),
     };
   } else if (action.type === clearQueuedThreadDMOpsActionType) {
     const { [action.payload.threadID]: removed, ...threadQueue } =
       store.threadQueue;
     return {
       ...store,
       threadQueue,
     };
+  } else if (action.type === clearQueuedMessageDMOpsActionType) {
+    const { [action.payload.messageID]: removed, ...messageQueue } =
+      store.messageQueue;
+    return {
+      ...store,
+      messageQueue,
+    };
+  } else if (action.type === clearQueuedEntryDMOpsActionType) {
+    const { [action.payload.entryID]: removed, ...entryQueue } =
+      store.entryQueue;
+    return {
+      ...store,
+      entryQueue,
+    };
+  } else if (action.type === clearQueuedMembershipDMOpsActionType) {
+    const threadQueue = store.membershipQueue[action.payload.threadID];
+    if (!threadQueue) {
+      return store;
+    }
+
+    const { [action.payload.userID]: removed, ...queue } = threadQueue;
+    if (Object.keys(queue).length === 0) {
+      const { [action.payload.threadID]: removedThread, ...membershipQueue } =
+        store.membershipQueue;
+      return {
+        ...store,
+        membershipQueue,
+      };
+    }
+
+    return {
+      ...store,
+      membershipQueue: {
+        ...store.membershipQueue,
+        [action.payload.userID]: queue,
+      },
+    };
   }
   return store;
 }
 
 export { reduceDMOperationsQueue };
diff --git a/lib/shared/dm-ops/process-dm-ops.js b/lib/shared/dm-ops/process-dm-ops.js
index b193d565d..2f603a75a 100644
--- a/lib/shared/dm-ops/process-dm-ops.js
+++ b/lib/shared/dm-ops/process-dm-ops.js
@@ -1,426 +1,429 @@
 // @flow
 
 import invariant from 'invariant';
 import _groupBy from 'lodash/fp/groupBy.js';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import type { ProcessDMOperationUtilities } from './dm-op-spec.js';
 import { dmOpSpecs } from './dm-op-specs.js';
 import {
   type OutboundDMOperationSpecification,
   type DMOperationSpecification,
   createMessagesToPeersFromDMOp,
   dmOperationSpecificationTypes,
   type OutboundComposableDMOperationSpecification,
 } from './dm-op-utils.js';
 import { processNewUserIDsActionType } from '../../actions/user-actions.js';
 import { useLoggedInUserInfo } from '../../hooks/account-hooks.js';
 import { useGetLatestMessageEdit } from '../../hooks/latest-message-edit.js';
 import { useDispatchWithMetadata } from '../../hooks/ops-hooks.js';
 import { mergeUpdatesWithMessageInfos } from '../../reducers/message-reducer.js';
 import { getAllPeerUserIDAndDeviceIDs } from '../../selectors/user-selectors.js';
 import {
   usePeerToPeerCommunication,
   type ProcessOutboundP2PMessagesResult,
 } from '../../tunnelbroker/peer-to-peer-context.js';
 import {
   processDMOpsActionType,
   queueDMOpsActionType,
   dmOperationValidator,
 } from '../../types/dm-ops.js';
 import type { RawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
 import type { DispatchMetadata } from '../../types/redux-types.js';
 import type { OutboundP2PMessage } from '../../types/sqlite-types.js';
 import type { LegacyRawThreadInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { extractUserIDsFromPayload } from '../../utils/conversion-utils.js';
 import { useSelector, useDispatch } from '../../utils/redux-utils.js';
 import { messageSpecs } from '../messages/message-specs.js';
 import { updateSpecs } from '../updates/update-specs.js';
 
 function useSendDMOperationUtils(): ProcessDMOperationUtilities {
   const fetchMessage = useGetLatestMessageEdit();
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
   const entryInfos = useSelector(state => state.entryStore.entryInfos);
   return React.useMemo(
     () => ({
       fetchMessage,
       threadInfos,
       entryInfos,
     }),
     [fetchMessage, threadInfos, entryInfos],
   );
 }
 
 function useProcessDMOperation(): (
   dmOperationSpecification: DMOperationSpecification,
   dmOpID: ?string,
 ) => Promise<void> {
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
   const utilities = useSendDMOperationUtils();
   const dispatchWithMetadata = useDispatchWithMetadata();
   const loggedInUserInfo = useLoggedInUserInfo();
   const viewerID = loggedInUserInfo?.id;
   const allPeerUserIDAndDeviceIDs = useSelector(getAllPeerUserIDAndDeviceIDs);
   const currentUserInfo = useSelector(state => state.currentUserInfo);
 
   const dispatch = useDispatch();
 
   return React.useCallback(
     async (
       dmOperationSpecification: DMOperationSpecification,
       dmOpID: ?string,
     ) => {
       if (!viewerID) {
         console.log('ignored DMOperation because logged out');
         return;
       }
 
       const { op: dmOp } = dmOperationSpecification;
 
       let outboundP2PMessages: ?$ReadOnlyArray<OutboundP2PMessage> = null;
       if (
         dmOperationSpecification.type === dmOperationSpecificationTypes.OUTBOUND
       ) {
         outboundP2PMessages = await createMessagesToPeersFromDMOp(
           dmOp,
           dmOperationSpecification.recipients,
           allPeerUserIDAndDeviceIDs,
           currentUserInfo,
           threadInfos,
         );
       }
 
       let dispatchMetadata: ?DispatchMetadata = null;
       if (
         dmOperationSpecification.type ===
           dmOperationSpecificationTypes.OUTBOUND &&
         dmOpID
       ) {
         dispatchMetadata = {
           dmOpID,
         };
       } else if (
         dmOperationSpecification.type === dmOperationSpecificationTypes.INBOUND
       ) {
         dispatchMetadata = dmOperationSpecification.metadata;
       }
 
       let composableMessageID: ?string = null;
       if (
         dmOperationSpecification.type ===
           dmOperationSpecificationTypes.OUTBOUND &&
         !dmOpSpecs[dmOp.type].supportsAutoRetry
       ) {
         composableMessageID = dmOp.messageID;
       }
 
       if (
         dmOperationSpecification.type ===
           dmOperationSpecificationTypes.OUTBOUND &&
         dmOperationSpecification.sendOnly
       ) {
         const notificationsCreationData = await dmOpSpecs[
           dmOp.type
         ].notificationsCreationData?.(dmOp, utilities);
 
         dispatchWithMetadata(
           {
             type: processDMOpsActionType,
             payload: {
               rawMessageInfos: [],
               updateInfos: [],
               outboundP2PMessages,
               composableMessageID,
               notificationsCreationData,
             },
           },
           dispatchMetadata,
         );
 
         return;
       }
 
       const processingCheckResult = dmOpSpecs[dmOp.type].canBeProcessed(
         dmOp,
         viewerID,
         utilities,
       );
       if (!processingCheckResult.isProcessingPossible) {
         if (processingCheckResult.reason.type === 'missing_thread') {
           dispatchWithMetadata(
             {
               type: queueDMOpsActionType,
               payload: {
                 operation: dmOp,
-                threadID: processingCheckResult.reason.threadID,
                 timestamp: Date.now(),
+                condition: {
+                  type: 'thread',
+                  threadID: processingCheckResult.reason.threadID,
+                },
               },
             },
             dispatchMetadata,
           );
         }
         return;
       }
 
       const newUserIDs = extractUserIDsFromPayload(dmOperationValidator, dmOp);
       if (newUserIDs.length > 0) {
         dispatch({
           type: processNewUserIDsActionType,
           payload: { userIDs: newUserIDs },
         });
       }
 
       const dmOpSpec = dmOpSpecs[dmOp.type];
       const notificationsCreationDataPromise = (async () => {
         return await dmOpSpec.notificationsCreationData?.(dmOp, utilities);
       })();
 
       const [{ rawMessageInfos, updateInfos }, notificationsCreationData] =
         await Promise.all([
           dmOpSpec.processDMOperation(dmOp, viewerID, utilities),
           notificationsCreationDataPromise,
         ]);
 
       const { rawMessageInfos: allNewMessageInfos } =
         mergeUpdatesWithMessageInfos(rawMessageInfos, updateInfos);
       const messagesByThreadID = _groupBy(message => message.threadID)(
         allNewMessageInfos,
       );
 
       const updatedThreadInfosByThreadID: {
         [string]: RawThreadInfo | LegacyRawThreadInfo,
       } = {};
       for (const threadID in messagesByThreadID) {
         updatedThreadInfosByThreadID[threadID] = threadInfos[threadID];
       }
       for (const update of updateInfos) {
         const updatedThreadInfo = updateSpecs[
           update.type
         ].getUpdatedThreadInfo?.(update, updatedThreadInfosByThreadID);
         if (updatedThreadInfo) {
           updatedThreadInfosByThreadID[updatedThreadInfo.id] =
             updatedThreadInfo;
         }
       }
 
       for (const threadID in messagesByThreadID) {
         const repliesCountIncreasingMessages = messagesByThreadID[
           threadID
         ].filter(message => messageSpecs[message.type].includedInRepliesCount);
 
         const threadInfo = updatedThreadInfosByThreadID[threadID];
 
         if (repliesCountIncreasingMessages.length > 0) {
           const repliesCountIncreaseTime = Math.max(
             repliesCountIncreasingMessages.map(message => message.time),
           );
           updateInfos.push({
             type: updateTypes.UPDATE_THREAD,
             id: uuid.v4(),
             time: repliesCountIncreaseTime,
             threadInfo: {
               ...threadInfo,
               repliesCount:
                 threadInfo.repliesCount + repliesCountIncreasingMessages.length,
             },
           });
         }
 
         const messagesFromOtherPeers = messagesByThreadID[threadID].filter(
           message => message.creatorID !== viewerID,
         );
         if (messagesFromOtherPeers.length === 0) {
           continue;
         }
         // We take the most recent timestamp to make sure that
         // change_thread_read_status operation older
         // than it won't flip the status to read.
         const time = Math.max(
           messagesFromOtherPeers.map(message => message.time),
         );
         invariant(threadInfo.thick, 'Thread should be thick');
 
         // We aren't checking if the unread timestamp is lower than the time.
         // We're doing this because we want to flip the thread to unread after
         // any new message from a non-viewer.
         const updatedThreadInfo = threadInfo.minimallyEncoded
           ? {
               ...threadInfo,
               currentUser: {
                 ...threadInfo.currentUser,
                 unread: true,
               },
               timestamps: {
                 ...threadInfo.timestamps,
                 currentUser: {
                   ...threadInfo.timestamps.currentUser,
                   unread: time,
                 },
               },
             }
           : {
               ...threadInfo,
               currentUser: {
                 ...threadInfo.currentUser,
                 unread: true,
               },
               timestamps: {
                 ...threadInfo.timestamps,
                 currentUser: {
                   ...threadInfo.timestamps.currentUser,
                   unread: time,
                 },
               },
             };
 
         updateInfos.push({
           type: updateTypes.UPDATE_THREAD,
           id: uuid.v4(),
           time,
           threadInfo: updatedThreadInfo,
         });
       }
 
       dispatchWithMetadata(
         {
           type: processDMOpsActionType,
           payload: {
             rawMessageInfos,
             updateInfos,
             outboundP2PMessages,
             composableMessageID,
             notificationsCreationData,
           },
         },
         dispatchMetadata,
       );
     },
     [
       viewerID,
       utilities,
       dispatchWithMetadata,
       allPeerUserIDAndDeviceIDs,
       currentUserInfo,
       threadInfos,
       dispatch,
     ],
   );
 }
 
 function useProcessAndSendDMOperation(): (
   dmOperationSpecification: OutboundDMOperationSpecification,
 ) => Promise<void> {
   const processDMOps = useProcessDMOperation();
   const { getDMOpsSendingPromise } = usePeerToPeerCommunication();
 
   return React.useCallback(
     async (dmOperationSpecification: OutboundDMOperationSpecification) => {
       const { promise, dmOpID } = getDMOpsSendingPromise();
       await processDMOps(dmOperationSpecification, dmOpID);
       await promise;
     },
     [getDMOpsSendingPromise, processDMOps],
   );
 }
 
 function useSendComposableDMOperation(): (
   dmOperationSpecification: OutboundComposableDMOperationSpecification,
 ) => Promise<ProcessOutboundP2PMessagesResult> {
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
   const { getDMOpsSendingPromise } = usePeerToPeerCommunication();
   const dispatchWithMetadata = useDispatchWithMetadata();
   const allPeerUserIDAndDeviceIDs = useSelector(getAllPeerUserIDAndDeviceIDs);
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const utilities = useSendDMOperationUtils();
   const { processOutboundMessages } = usePeerToPeerCommunication();
   const localMessageInfos = useSelector(state => state.messageStore.local);
 
   return React.useCallback(
     async (
       dmOperationSpecification: OutboundComposableDMOperationSpecification,
     ): Promise<ProcessOutboundP2PMessagesResult> => {
       const { promise, dmOpID } = getDMOpsSendingPromise();
 
       const { op, composableMessageID, recipients } = dmOperationSpecification;
 
       const localMessageInfo = localMessageInfos[composableMessageID];
       if (
         localMessageInfo?.outboundP2PMessageIDs &&
         localMessageInfo.outboundP2PMessageIDs.length > 0
       ) {
         processOutboundMessages(localMessageInfo.outboundP2PMessageIDs, dmOpID);
         try {
           // This code should never throw.
           return await promise;
         } catch (e) {
           invariant(
             localMessageInfo.outboundP2PMessageIDs,
             'outboundP2PMessageIDs should be defined',
           );
           return {
             result: 'failure',
             failedMessageIDs: localMessageInfo.outboundP2PMessageIDs,
           };
         }
       }
 
       const outboundP2PMessages = await createMessagesToPeersFromDMOp(
         op,
         recipients,
         allPeerUserIDAndDeviceIDs,
         currentUserInfo,
         threadInfos,
       );
 
       const notificationsCreationData = await dmOpSpecs[
         op.type
       ].notificationsCreationData?.(op, utilities);
 
       dispatchWithMetadata(
         {
           type: processDMOpsActionType,
           payload: {
             rawMessageInfos: [],
             updateInfos: [],
             outboundP2PMessages,
             composableMessageID,
             notificationsCreationData,
           },
         },
         {
           dmOpID,
         },
       );
 
       try {
         // This code should never throw.
         return await promise;
       } catch (e) {
         return {
           result: 'failure',
           failedMessageIDs: outboundP2PMessages.map(
             message => message.messageID,
           ),
         };
       }
     },
     [
       allPeerUserIDAndDeviceIDs,
       currentUserInfo,
       dispatchWithMetadata,
       getDMOpsSendingPromise,
       localMessageInfos,
       processOutboundMessages,
       threadInfos,
       utilities,
     ],
   );
 }
 
 export {
   useProcessDMOperation,
   useProcessAndSendDMOperation,
   useSendComposableDMOperation,
 };
diff --git a/lib/types/dm-ops.js b/lib/types/dm-ops.js
index 22f1ca5bf..fb239fb00 100644
--- a/lib/types/dm-ops.js
+++ b/lib/types/dm-ops.js
@@ -1,544 +1,578 @@
 // @flow
 
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import { clientAvatarValidator, type ClientAvatar } from './avatar-types.js';
 import { type Media, mediaValidator } from './media-types.js';
 import type { RawMessageInfo } from './message-types.js';
 import type { NotificationsCreationData } from './notif-types.js';
 import type { OutboundP2PMessage } from './sqlite-types.js';
 import {
   type ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type NonSidebarThickThreadType,
   nonSidebarThickThreadTypes,
   type ThickThreadType,
   thickThreadTypeValidator,
 } from './thread-types-enum.js';
 import {
   threadTimestampsValidator,
   type ThreadTimestamps,
 } from './thread-types.js';
 import type { ClientUpdateInfo } from './update-types.js';
 import { values } from '../utils/objects.js';
 import { tColor, tShape, tString, tUserID } from '../utils/validation-utils.js';
 
 export const dmOperationTypes = Object.freeze({
   CREATE_THREAD: 'create_thread',
   CREATE_SIDEBAR: 'create_sidebar',
   SEND_TEXT_MESSAGE: 'send_text_message',
   SEND_MULTIMEDIA_MESSAGE: 'send_multimedia_message',
   SEND_REACTION_MESSAGE: 'send_reaction_message',
   SEND_EDIT_MESSAGE: 'send_edit_message',
   ADD_MEMBERS: 'add_members',
   ADD_VIEWER_TO_THREAD_MEMBERS: 'add_viewer_to_thread_members',
   JOIN_THREAD: 'join_thread',
   LEAVE_THREAD: 'leave_thread',
   REMOVE_MEMBERS: 'remove_members',
   CHANGE_THREAD_SETTINGS: 'change_thread_settings',
   CHANGE_THREAD_SUBSCRIPTION: 'change_thread_subscription',
   CHANGE_THREAD_READ_STATUS: 'change_thread_read_status',
   CREATE_ENTRY: 'create_entry',
   DELETE_ENTRY: 'delete_entry',
   EDIT_ENTRY: 'edit_entry',
 });
 export type DMOperationType = $Values<typeof dmOperationTypes>;
 
 type MemberIDWithSubscription = {
   +id: string,
   +subscription: ThreadSubscription,
 };
 export const memberIDWithSubscriptionValidator: TInterface<MemberIDWithSubscription> =
   tShape<MemberIDWithSubscription>({
     id: tUserID,
     subscription: threadSubscriptionValidator,
   });
 
 export type CreateThickRawThreadInfoInput = {
   +threadID: string,
   +threadType: ThickThreadType,
   +creationTime: number,
   +parentThreadID?: ?string,
   +allMemberIDsWithSubscriptions: $ReadOnlyArray<MemberIDWithSubscription>,
   +roleID: string,
   +unread: boolean,
   +timestamps: ThreadTimestamps,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color?: ?string,
   +containingThreadID?: ?string,
   +sourceMessageID?: ?string,
   +repliesCount?: ?number,
   +pinnedCount?: ?number,
 };
 export const createThickRawThreadInfoInputValidator: TInterface<CreateThickRawThreadInfoInput> =
   tShape<CreateThickRawThreadInfoInput>({
     threadID: t.String,
     threadType: thickThreadTypeValidator,
     creationTime: t.Number,
     parentThreadID: t.maybe(t.String),
     allMemberIDsWithSubscriptions: t.list(memberIDWithSubscriptionValidator),
     roleID: t.String,
     unread: t.Boolean,
     timestamps: threadTimestampsValidator,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.maybe(t.String),
     containingThreadID: t.maybe(t.String),
     sourceMessageID: t.maybe(t.String),
     repliesCount: t.maybe(t.Number),
     pinnedCount: t.maybe(t.Number),
   });
 
 export type DMCreateThreadOperation = {
   +type: 'create_thread',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +threadType: NonSidebarThickThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +roleID: string,
   +newMessageID: string,
 };
 export const dmCreateThreadOperationValidator: TInterface<DMCreateThreadOperation> =
   tShape<DMCreateThreadOperation>({
     type: tString(dmOperationTypes.CREATE_THREAD),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     threadType: t.enums.of(values(nonSidebarThickThreadTypes)),
     memberIDs: t.list(tUserID),
     roleID: t.String,
     newMessageID: t.String,
   });
 
 export type DMCreateSidebarOperation = {
   +type: 'create_sidebar',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +parentThreadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: string,
   +roleID: string,
   +newSidebarSourceMessageID: string,
   +newCreateSidebarMessageID: string,
 };
 export const dmCreateSidebarOperationValidator: TInterface<DMCreateSidebarOperation> =
   tShape<DMCreateSidebarOperation>({
     type: tString(dmOperationTypes.CREATE_SIDEBAR),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     parentThreadID: t.String,
     memberIDs: t.list(tUserID),
     sourceMessageID: t.String,
     roleID: t.String,
     newSidebarSourceMessageID: t.String,
     newCreateSidebarMessageID: t.String,
   });
 
 export type DMSendTextMessageOperation = {
   +type: 'send_text_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +text: string,
 };
 export const dmSendTextMessageOperationValidator: TInterface<DMSendTextMessageOperation> =
   tShape<DMSendTextMessageOperation>({
     type: tString(dmOperationTypes.SEND_TEXT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     text: t.String,
   });
 
 export type DMSendMultimediaMessageOperation = {
   +type: 'send_multimedia_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +media: $ReadOnlyArray<Media>,
 };
 export const dmSendMultimediaMessageOperationValidator: TInterface<DMSendMultimediaMessageOperation> =
   tShape<DMSendMultimediaMessageOperation>({
     type: tString(dmOperationTypes.SEND_MULTIMEDIA_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     media: t.list(mediaValidator),
   });
 
 export type DMSendReactionMessageOperation = {
   +type: 'send_reaction_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 export const dmSendReactionMessageOperationValidator: TInterface<DMSendReactionMessageOperation> =
   tShape<DMSendReactionMessageOperation>({
     type: tString(dmOperationTypes.SEND_REACTION_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     reaction: t.String,
     action: t.enums.of(['add_reaction', 'remove_reaction']),
   });
 
 export type DMSendEditMessageOperation = {
   +type: 'send_edit_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +text: string,
 };
 export const dmSendEditMessageOperationValidator: TInterface<DMSendEditMessageOperation> =
   tShape<DMSendEditMessageOperation>({
     type: tString(dmOperationTypes.SEND_EDIT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     text: t.String,
   });
 
 type DMAddMembersBase = {
   +editorID: string,
   +time: number,
   +addedUserIDs: $ReadOnlyArray<string>,
 };
 const dmAddMembersBaseValidatorShape = {
   editorID: tUserID,
   time: t.Number,
   addedUserIDs: t.list(tUserID),
 };
 
 export type DMAddMembersOperation = $ReadOnly<{
   +type: 'add_members',
   +threadID: string,
   +messageID: string,
   ...DMAddMembersBase,
 }>;
 export const dmAddMembersOperationValidator: TInterface<DMAddMembersOperation> =
   tShape<DMAddMembersOperation>({
     type: tString(dmOperationTypes.ADD_MEMBERS),
     threadID: t.String,
     messageID: t.String,
     ...dmAddMembersBaseValidatorShape,
   });
 
 export type DMAddViewerToThreadMembersOperation = $ReadOnly<{
   +type: 'add_viewer_to_thread_members',
   +messageID: ?string,
   +existingThreadDetails: CreateThickRawThreadInfoInput,
   ...DMAddMembersBase,
 }>;
 export const dmAddViewerToThreadMembersValidator: TInterface<DMAddViewerToThreadMembersOperation> =
   tShape<DMAddViewerToThreadMembersOperation>({
     type: tString(dmOperationTypes.ADD_VIEWER_TO_THREAD_MEMBERS),
     messageID: t.maybe(t.String),
     existingThreadDetails: createThickRawThreadInfoInputValidator,
     ...dmAddMembersBaseValidatorShape,
   });
 
 export type DMJoinThreadOperation = {
   +type: 'join_thread',
   +joinerID: string,
   +time: number,
   +messageID: string,
   +existingThreadDetails: CreateThickRawThreadInfoInput,
 };
 export const dmJoinThreadOperationValidator: TInterface<DMJoinThreadOperation> =
   tShape<DMJoinThreadOperation>({
     type: tString(dmOperationTypes.JOIN_THREAD),
     joinerID: tUserID,
     time: t.Number,
     messageID: t.String,
     existingThreadDetails: createThickRawThreadInfoInputValidator,
   });
 
 export type DMLeaveThreadOperation = {
   +type: 'leave_thread',
   +editorID: string,
   +time: number,
   +messageID: string,
   +threadID: string,
 };
 export const dmLeaveThreadOperationValidator: TInterface<DMLeaveThreadOperation> =
   tShape<DMLeaveThreadOperation>({
     type: tString(dmOperationTypes.LEAVE_THREAD),
     editorID: tUserID,
     time: t.Number,
     messageID: t.String,
     threadID: t.String,
   });
 
 export type DMRemoveMembersOperation = {
   +type: 'remove_members',
   +editorID: string,
   +time: number,
   +messageID: string,
   +threadID: string,
   +removedUserIDs: $ReadOnlyArray<string>,
 };
 export const dmRemoveMembersOperationValidator: TInterface<DMRemoveMembersOperation> =
   tShape<DMRemoveMembersOperation>({
     type: tString(dmOperationTypes.REMOVE_MEMBERS),
     editorID: tUserID,
     time: t.Number,
     messageID: t.String,
     threadID: t.String,
     removedUserIDs: t.list(tUserID),
   });
 
 export type DMThreadSettingsChanges = {
   +name?: string,
   +description?: string,
   +color?: string,
   +avatar?: ClientAvatar | null,
 };
 
 export type DMChangeThreadSettingsOperation = $ReadOnly<{
   +type: 'change_thread_settings',
   +threadID: string,
   +editorID: string,
   +time: number,
   +changes: DMThreadSettingsChanges,
   +messageIDsPrefix: string,
 }>;
 export const dmChangeThreadSettingsOperationValidator: TInterface<DMChangeThreadSettingsOperation> =
   tShape<DMChangeThreadSettingsOperation>({
     type: tString(dmOperationTypes.CHANGE_THREAD_SETTINGS),
     threadID: t.String,
     editorID: tUserID,
     time: t.Number,
     changes: tShape({
       name: t.maybe(t.String),
       description: t.maybe(t.String),
       color: t.maybe(tColor),
       avatar: t.maybe(clientAvatarValidator),
     }),
     messageIDsPrefix: t.String,
   });
 
 export type DMChangeThreadSubscriptionOperation = {
   +type: 'change_thread_subscription',
   +time: number,
   +threadID: string,
   +creatorID: string,
   +subscription: ThreadSubscription,
 };
 export const dmChangeThreadSubscriptionOperationValidator: TInterface<DMChangeThreadSubscriptionOperation> =
   tShape<DMChangeThreadSubscriptionOperation>({
     type: tString(dmOperationTypes.CHANGE_THREAD_SUBSCRIPTION),
     time: t.Number,
     threadID: t.String,
     creatorID: tUserID,
     subscription: threadSubscriptionValidator,
   });
 
 export type DMChangeThreadReadStatusOperation = {
   +type: 'change_thread_read_status',
   +time: number,
   +threadID: string,
   +creatorID: string,
   +unread: boolean,
 };
 export const dmChangeThreadReadStatusOperationValidator: TInterface<DMChangeThreadReadStatusOperation> =
   tShape<DMChangeThreadReadStatusOperation>({
     type: tString(dmOperationTypes.CHANGE_THREAD_READ_STATUS),
     time: t.Number,
     threadID: t.String,
     creatorID: tUserID,
     unread: t.Boolean,
   });
 
 export type ComposableDMOperation =
   | DMSendTextMessageOperation
   | DMSendMultimediaMessageOperation;
 
 export type DMCreateEntryOperation = {
   +type: 'create_entry',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +entryID: string,
   +entryDate: string,
   +text: string,
   +messageID: string,
 };
 
 export const dmCreateEntryOperationValidator: TInterface<DMCreateEntryOperation> =
   tShape<DMCreateEntryOperation>({
     type: tString(dmOperationTypes.CREATE_ENTRY),
     threadID: t.String,
     creatorID: t.String,
     time: t.Number,
     entryID: t.String,
     entryDate: t.String,
     text: t.String,
     messageID: t.String,
   });
 
 export type DMDeleteEntryOperation = {
   +type: 'delete_entry',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +creationTime: number,
   +entryID: string,
   +entryDate: string,
   +prevText: string,
   +messageID: string,
 };
 
 export const dmDeleteEntryOperationValidator: TInterface<DMDeleteEntryOperation> =
   tShape<DMDeleteEntryOperation>({
     type: tString(dmOperationTypes.DELETE_ENTRY),
     threadID: t.String,
     creatorID: t.String,
     time: t.Number,
     creationTime: t.Number,
     entryID: t.String,
     entryDate: t.String,
     prevText: t.String,
     messageID: t.String,
   });
 
 export type DMEditEntryOperation = {
   +type: 'edit_entry',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +creationTime: number,
   +entryID: string,
   +entryDate: string,
   +text: string,
   +messageID: string,
 };
 
 export const dmEditEntryOperationValidator: TInterface<DMEditEntryOperation> =
   tShape<DMEditEntryOperation>({
     type: tString(dmOperationTypes.EDIT_ENTRY),
     threadID: t.String,
     creatorID: t.String,
     creationTime: t.Number,
     time: t.Number,
     entryID: t.String,
     entryDate: t.String,
     text: t.String,
     messageID: t.String,
   });
 
 export type DMOperation =
   | DMCreateThreadOperation
   | DMCreateSidebarOperation
   | DMSendTextMessageOperation
   | DMSendMultimediaMessageOperation
   | DMSendReactionMessageOperation
   | DMSendEditMessageOperation
   | DMAddMembersOperation
   | DMAddViewerToThreadMembersOperation
   | DMJoinThreadOperation
   | DMLeaveThreadOperation
   | DMRemoveMembersOperation
   | DMChangeThreadSettingsOperation
   | DMChangeThreadSubscriptionOperation
   | DMChangeThreadReadStatusOperation
   | DMCreateEntryOperation
   | DMDeleteEntryOperation
   | DMEditEntryOperation;
 export const dmOperationValidator: TUnion<DMOperation> = t.union([
   dmCreateThreadOperationValidator,
   dmCreateSidebarOperationValidator,
   dmSendTextMessageOperationValidator,
   dmSendMultimediaMessageOperationValidator,
   dmSendReactionMessageOperationValidator,
   dmSendEditMessageOperationValidator,
   dmAddMembersOperationValidator,
   dmAddViewerToThreadMembersValidator,
   dmJoinThreadOperationValidator,
   dmLeaveThreadOperationValidator,
   dmRemoveMembersOperationValidator,
   dmChangeThreadSettingsOperationValidator,
   dmChangeThreadSubscriptionOperationValidator,
   dmChangeThreadReadStatusOperationValidator,
   dmCreateEntryOperationValidator,
   dmDeleteEntryOperationValidator,
   dmEditEntryOperationValidator,
 ]);
 
 export type DMOperationResult = {
   rawMessageInfos: Array<RawMessageInfo>,
   updateInfos: Array<ClientUpdateInfo>,
 };
 
 export const processDMOpsActionType = 'PROCESS_DM_OPS';
 
 export type ProcessDMOpsPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
   +outboundP2PMessages: ?$ReadOnlyArray<OutboundP2PMessage>,
   // For messages that could be retried from UI, we need to bind DM `messageID`
   // with `outboundP2PMessages` to keep track of whether all P2P messages
   // were queued on Tunnelbroker.
   +composableMessageID: ?string,
   +notificationsCreationData: ?NotificationsCreationData,
 };
 
 export const queueDMOpsActionType = 'QUEUE_DM_OPS';
 export type QueueDMOpsPayload = {
   +operation: DMOperation,
-  +threadID: string,
   +timestamp: number,
+  +condition:
+    | {
+        +type: 'thread',
+        +threadID: string,
+      }
+    | {
+        +type: 'entry',
+        +entryID: string,
+      }
+    | {
+        +type: 'message',
+        +messageID: string,
+      }
+    | {
+        +type: 'membership',
+        +threadID: string,
+        +userID: string,
+      },
 };
 
 export const pruneDMOpsQueueActionType = 'PRUNE_DM_OPS_QUEUE';
 export type PruneDMOpsQueuePayload = {
   +pruneMaxTimestamp: number,
 };
 
 export const clearQueuedThreadDMOpsActionType = 'CLEAR_QUEUED_THREAD_DM_OPS';
 export type ClearQueuedThreadDMOpsPayload = {
   +threadID: string,
 };
 
+export const clearQueuedMessageDMOpsActionType = 'CLEAR_QUEUED_MESSAGE_DM_OPS';
+export type ClearQueuedMessageDMOpsPayload = {
+  +messageID: string,
+};
+
+export const clearQueuedEntryDMOpsActionType = 'CLEAR_QUEUED_ENTRY_DM_OPS';
+export type ClearQueuedEntryDMOpsPayload = {
+  +entryID: string,
+};
+
+export const clearQueuedMembershipDMOpsActionType =
+  'CLEAR_QUEUED_MEMBERSHIP_DM_OPS';
+export type ClearQueuedMembershipDMOpsPayload = {
+  +threadID: string,
+  +userID: string,
+};
+
 export type OperationsQueue = $ReadOnlyArray<{
   +operation: DMOperation,
   +timestamp: number,
 }>;
 
 export type QueuedDMOperations = {
   +threadQueue: {
     +[threadID: string]: OperationsQueue,
   },
   +messageQueue: {
     +[messageID: string]: OperationsQueue,
   },
   +entryQueue: {
     +[entryID: string]: OperationsQueue,
   },
   +membershipQueue: {
     +[threadID: string]: {
       +[memberID: string]: OperationsQueue,
     },
   },
 };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index fc82594bf..4682b7f91 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1628 +1,1643 @@
 // @flow
 
 import type { PersistState } from 'redux-persist/es/types';
 
 import type {
   LogOutResult,
   KeyserverLogOutResult,
   LegacyLogInStartingPayload,
   LegacyLogInResult,
   LegacyRegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
   KeyserverAuthResult,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type { AlertStore, RecordAlertActionPayload } from './alert-types.js';
 import type {
   AuxUserStore,
   SetAuxUserFIDsPayload,
   AddAuxUserFIDsPayload,
   RemovePeerUsersPayload,
   SetPeerDeviceListsPayload,
 } from './aux-user-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type {
   CommunityStore,
   AddCommunityPayload,
   FetchCommunityInfosResponse,
   CreateOrUpdateFarcasterChannelTagResponse,
   DeleteFarcasterChannelTagPayload,
 } from './community-types.js';
 import type { DBOpsStore } from './db-ops-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type {
   ProcessDMOpsPayload,
   QueuedDMOperations,
   QueueDMOpsPayload,
   PruneDMOpsQueuePayload,
   ClearQueuedThreadDMOpsPayload,
+  ClearQueuedMessageDMOpsPayload,
+  ClearQueuedEntryDMOpsPayload,
+  ClearQueuedMembershipDMOpsPayload,
 } from './dm-ops.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,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IdentityAuthResult } from './identity-service-types';
 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 { GetOlmSessionInitializationDataResponse } from './olm-session-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 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionIssue,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   SetActiveSessionRecoveryPayload,
   ClientStateSyncSocketResult,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   SyncedMetadataStore,
   SetSyncedMetadataEntryPayload,
   ClearSyncedMetadataEntryPayload,
 } from './synced-metadata-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 { TunnelbrokerDeviceToken } from './tunnelbroker-device-token-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type {
   CurrentUserInfo,
   UserInfos,
   UserStore,
   UserInfo,
 } from './user-types.js';
 import type {
   SetDeviceTokenActionPayload,
   SetDeviceTokenStartedPayload,
 } from '../actions/device-actions.js';
 import type {
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateKeyserverReachabilityPayload,
 } from '../keyserver-conn/keyserver-conn-types.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>,
   +alertStore: AlertStore,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
   +communityStore: CommunityStore,
   +dbOpsStore: DBOpsStore,
   +syncedMetadataStore: SyncedMetadataStore,
   +auxUserStore: AuxUserStore,
   +tunnelbrokerDeviceToken: TunnelbrokerDeviceToken,
   +_persist: ?PersistState,
   +queuedDMOperations: QueuedDMOperations,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type ClientWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type ServerWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: LegacyThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type WebInitialKeyserverInfo = {
   +sessionID: ?string,
   +updatesCurrentAsOf: number,
 };
 
 export type BaseAction = $ReadOnly<{
   +dispatchMetadata?: DispatchMetadata,
   ...
     | {
         +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: '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: 'IDENTITY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'IDENTITY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'KEYSERVER_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_SUCCESS',
         +payload: KeyserverAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
         +payload: LegacyRegisterResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_SUCCESS',
         +payload?: void,
         +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_IDENTITY_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_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,
           +failedOutboundP2PMessageIDs?: $ReadOnlyArray<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,
           +failedOutboundP2PMessageIDs?: $ReadOnlyArray<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: SetDeviceTokenStartedPayload,
         +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: 'LEGACY_SIWE_AUTH_STARTED',
         +payload: LegacyLogInStartingPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RECORD_ALERT',
         +payload: RecordAlertActionPayload,
       }
     | {
         +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: '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: 'ADD_COMMUNITY',
         +payload: AddCommunityPayload,
       }
     | {
         +type: 'SET_SYNCED_METADATA_ENTRY',
         +payload: SetSyncedMetadataEntryPayload,
       }
     | {
         +type: 'CLEAR_SYNCED_METADATA_ENTRY',
         +payload: ClearSyncedMetadataEntryPayload,
       }
     | {
         +type: 'SET_ACTIVE_SESSION_RECOVERY',
         +payload: SetActiveSessionRecoveryPayload,
       }
     | {
         +type: 'SET_AUX_USER_FIDS',
         +payload: SetAuxUserFIDsPayload,
       }
     | {
         +type: 'ADD_AUX_USER_FIDS',
         +payload: AddAuxUserFIDsPayload,
       }
     | {
         +type: 'CLEAR_AUX_USER_FIDS',
         +payload?: void,
       }
     | {
         +type: 'REMOVE_PEER_USERS',
         +payload: RemovePeerUsersPayload,
       }
     | {
         +type: 'SET_PEER_DEVICE_LISTS',
         +payload: SetPeerDeviceListsPayload,
       }
     | {
         +type: 'OPS_PROCESSING_FINISHED_ACTION_TYPE',
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_SUCCESS',
         +payload: FetchCommunityInfosResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: CreateOrUpdateFarcasterChannelTagResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: DeleteFarcasterChannelTagPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_NEW_USER_IDS',
         +payload: {
           +userIDs: $ReadOnlyArray<string>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_SUCCESS',
         +payload: {
           +userInfos: $ReadOnlyArray<UserInfo>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_SUCCESS',
         +payload: {
           +supported: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_SUCCESS',
         +payload: ClientStateSyncSocketResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_SUCCESS',
         +payload: {
           +deviceToken: string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_DM_OPS',
         +payload: ProcessDMOpsPayload,
       }
     | {
         +type: 'INVALIDATE_TUNNELBROKER_DEVICE_TOKEN',
         +payload: {
           +deviceToken: string,
         },
       }
     | { +type: 'QUEUE_DM_OPS', +payload: QueueDMOpsPayload }
     | { +type: 'PRUNE_DM_OPS_QUEUE', +payload: PruneDMOpsQueuePayload }
     | {
         +type: 'CLEAR_QUEUED_THREAD_DM_OPS',
         +payload: ClearQueuedThreadDMOpsPayload,
+      }
+    | {
+        +type: 'CLEAR_QUEUED_MESSAGE_DM_OPS',
+        +payload: ClearQueuedMessageDMOpsPayload,
+      }
+    | {
+        +type: 'CLEAR_QUEUED_ENTRY_DM_OPS',
+        +payload: ClearQueuedEntryDMOpsPayload,
+      }
+    | {
+        +type: 'CLEAR_QUEUED_MEMBERSHIP_DM_OPS',
+        +payload: ClearQueuedMembershipDMOpsPayload,
       },
 }>;
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type DispatchSource = 'tunnelbroker' | 'tab-sync';
 // Data added when dispatching action as a result of message received
 // from other peer. It is used to send processing confirmation.
 export type InboundActionMetadata = {
   +messageID: string,
   +senderDeviceID: string,
 };
 // Data added when dispatching action triggered locally, used to resolve
 // promise associated with sending messages and track failed messages.
 export type OutboundActionMetadata = {
   +dmOpID: string,
 };
 export type DispatchMetadata = InboundActionMetadata | OutboundActionMetadata;
 export type SuperAction = {
   +type: string,
   +payload?: ActionPayload,
   +loadingInfo?: LoadingInfo,
   +error?: boolean,
   +dispatchSource?: DispatchSource,
   +dispatchMetadata?: DispatchMetadata,
 };
 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';