diff --git a/keyserver/src/creators/message-creator.js b/keyserver/src/creators/message-creator.js
index 256cae758..bdcdcdb3a 100644
--- a/keyserver/src/creators/message-creator.js
+++ b/keyserver/src/creators/message-creator.js
@@ -1,629 +1,632 @@
 // @flow
 
 import invariant from 'invariant';
 import _pickBy from 'lodash/fp/pickBy';
 
 import { permissionLookup } from 'lib/permissions/thread-permissions';
 import {
   rawMessageInfoFromMessageData,
   shimUnsupportedRawMessageInfos,
   stripLocalIDs,
 } from 'lib/shared/message-utils';
+import { pushTypes } from 'lib/shared/messages/message-spec';
 import { messageSpecs } from 'lib/shared/messages/message-specs';
 import {
   messageTypes,
   messageDataLocalID,
   type MessageData,
   type RawMessageInfo,
 } from 'lib/types/message-types';
 import { redisMessageTypes } from 'lib/types/redis-types';
 import { threadPermissions } from 'lib/types/thread-types';
 import { updateTypes } from 'lib/types/update-types';
 import { promiseAll } from 'lib/utils/promises';
 
 import {
   dbQuery,
   SQL,
   appendSQLArray,
   mergeOrConditions,
 } from '../database/database';
 import {
   fetchMessageInfoForLocalID,
   fetchMessageInfoByID,
 } from '../fetchers/message-fetchers';
 import { fetchOtherSessionsForViewer } from '../fetchers/session-fetchers';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers';
 import { sendPushNotifs } from '../push/send';
 import { handleAsyncPromise } from '../responders/handlers';
 import type { Viewer } from '../session/viewer';
 import { earliestFocusedTimeConsideredExpired } from '../shared/focused-times';
 import { publisher } from '../socket/redis';
 import { creationString } from '../utils/idempotent';
 import createIDs from './id-creator';
 import type { UpdatesForCurrentSession } from './update-creator';
 import { createUpdates } from './update-creator';
 
 type UserThreadInfo = {
   +devices: Map<
     string,
     {
       +deviceType: string,
       +deviceToken: string,
       +codeVersion: ?string,
     },
   >,
   +threadIDs: Set<string>,
   +notFocusedThreadIDs: Set<string>,
   +userNotMemberOfSubthreads: Set<string>,
   +subthreadsCanSetToUnread: Set<string>,
 };
 
 type LatestMessagesPerUser = Map<
   string,
   $ReadOnlyMap<
     string,
     {
       +latestMessage: string,
       +latestReadMessage?: string,
     },
   >,
 >;
 
 type LatestMessages = $ReadOnlyArray<{
   +userID: string,
   +threadID: string,
   +latestMessage: string,
   +latestReadMessage: ?string,
 }>;
 
 // Does not do permission checks! (checkThreadPermission)
 async function createMessages(
   viewer: Viewer,
   messageDatas: $ReadOnlyArray<MessageData>,
   updatesForCurrentSession?: UpdatesForCurrentSession = 'return',
 ): Promise<RawMessageInfo[]> {
   if (messageDatas.length === 0) {
     return [];
   }
 
   const messageInfos: RawMessageInfo[] = [];
   const newMessageDatas: MessageData[] = [];
   const existingMessages = await Promise.all(
     messageDatas.map(messageData =>
       fetchMessageInfoForLocalID(viewer, messageDataLocalID(messageData)),
     ),
   );
   for (let i = 0; i < existingMessages.length; i++) {
     const existingMessage = existingMessages[i];
     if (existingMessage) {
       messageInfos.push(existingMessage);
     } else {
       newMessageDatas.push(messageDatas[i]);
     }
   }
   if (newMessageDatas.length === 0) {
     return shimUnsupportedRawMessageInfos(messageInfos, viewer.platformDetails);
   }
 
   const ids = await createIDs('messages', newMessageDatas.length);
 
   const subthreadPermissionsToCheck: Set<string> = new Set();
   const threadsToMessageIndices: Map<string, number[]> = new Map();
   const messageInsertRows = [];
   for (let i = 0; i < newMessageDatas.length; i++) {
     const messageData = newMessageDatas[i];
     const threadID = messageData.threadID;
     const creatorID = messageData.creatorID;
 
     if (messageData.type === messageTypes.CREATE_SUB_THREAD) {
       subthreadPermissionsToCheck.add(messageData.childThreadID);
     }
 
     let messageIndices = threadsToMessageIndices.get(threadID);
     if (!messageIndices) {
       messageIndices = [];
       threadsToMessageIndices.set(threadID, messageIndices);
     }
     messageIndices.push(i);
 
     const content = messageSpecs[messageData.type].messageContentForServerDB?.(
       messageData,
     );
 
     const creation =
       messageData.localID && viewer.hasSessionInfo
         ? creationString(viewer, messageData.localID)
         : null;
 
     const targetMessageID = messageData.targetMessageID
       ? messageData.targetMessageID
       : null;
 
     messageInsertRows.push([
       ids[i],
       threadID,
       creatorID,
       messageData.type,
       content,
       messageData.time,
       creation,
       targetMessageID,
     ]);
     messageInfos.push(rawMessageInfoFromMessageData(messageData, ids[i]));
   }
 
   if (viewer.isScriptViewer) {
     await postMessageSend(
       viewer,
       threadsToMessageIndices,
       subthreadPermissionsToCheck,
       stripLocalIDs(messageInfos),
       updatesForCurrentSession,
     );
   } else {
     // We aren't awaiting because this function calls external services and we
     // don't want to delay the response
     handleAsyncPromise(
       postMessageSend(
         viewer,
         threadsToMessageIndices,
         subthreadPermissionsToCheck,
         stripLocalIDs(messageInfos),
         updatesForCurrentSession,
       ),
     );
   }
 
   const messageInsertQuery = SQL`
     INSERT INTO messages(id, thread, user, type, content, time,
       creation, target_message)
     VALUES ${messageInsertRows}
   `;
   await Promise.all([
     dbQuery(messageInsertQuery),
     updateRepliesCount(threadsToMessageIndices, newMessageDatas),
   ]);
 
   if (updatesForCurrentSession !== 'return') {
     return [];
   }
 
   return shimUnsupportedRawMessageInfos(messageInfos, viewer.platformDetails);
 }
 
 async function updateRepliesCount(
   threadsToMessageIndices: Map<string, number[]>,
   newMessageDatas: MessageData[],
 ) {
   const updatedThreads = [];
 
   const updateThreads = SQL`
     UPDATE threads
     SET replies_count = replies_count + (CASE `;
 
   const membershipConditions = [];
   for (const [threadID, messages] of threadsToMessageIndices.entries()) {
     const newRepliesIncrease = messages
       .map(i => newMessageDatas[i].type)
       .filter(type => messageSpecs[type].includedInRepliesCount).length;
     if (newRepliesIncrease === 0) {
       continue;
     }
 
     updateThreads.append(SQL`
       WHEN id = ${threadID} THEN ${newRepliesIncrease}
     `);
     updatedThreads.push(threadID);
 
     const senders = messages.map(i => newMessageDatas[i].creatorID);
     membershipConditions.push(
       SQL`thread = ${threadID} AND user IN (${senders})`,
     );
   }
   updateThreads.append(SQL`
       ELSE 0
       END)
     WHERE id IN (${updatedThreads})
       AND source_message IS NOT NULL
   `);
 
   const updateMemberships = SQL`
     UPDATE memberships
     SET sender = 1
     WHERE sender = 0 
       AND (
   `;
   updateMemberships.append(mergeOrConditions(membershipConditions));
   updateMemberships.append(SQL`
       )
   `);
 
   if (updatedThreads.length > 0) {
     const [{ threadInfos: serverThreadInfos }] = await Promise.all([
       fetchServerThreadInfos(SQL`t.id IN (${updatedThreads})`),
       dbQuery(updateThreads),
       dbQuery(updateMemberships),
     ]);
 
     const time = Date.now();
     const updates = [];
     for (const threadID in serverThreadInfos) {
       for (const member of serverThreadInfos[threadID].members) {
         updates.push({
           userID: member.id,
           time,
           threadID,
           type: updateTypes.UPDATE_THREAD,
         });
       }
     }
     await createUpdates(updates);
   }
 }
 
 // Handles:
 // (1) Sending push notifs
 // (2) Setting threads to unread and generating corresponding UpdateInfos
 // (3) Publishing to Redis so that active sockets pass on new messages
 async function postMessageSend(
   viewer: Viewer,
   threadsToMessageIndices: Map<string, number[]>,
   subthreadPermissionsToCheck: Set<string>,
   messageInfos: RawMessageInfo[],
   updatesForCurrentSession: UpdatesForCurrentSession,
 ) {
   let joinIndex = 0;
   let subthreadSelects = '';
   const subthreadJoins = [];
   for (const subthread of subthreadPermissionsToCheck) {
     const index = joinIndex++;
     subthreadSelects += `
       ,
       stm${index}.permissions AS subthread${subthread}_permissions,
       stm${index}.role AS subthread${subthread}_role
     `;
     const join = SQL`LEFT JOIN memberships `;
     join.append(`stm${index} ON stm${index}.`);
     join.append(SQL`thread = ${subthread} AND `);
     join.append(`stm${index}.user = m.user`);
     subthreadJoins.push(join);
   }
 
   const time = earliestFocusedTimeConsideredExpired();
   const visibleExtractString = `$.${threadPermissions.VISIBLE}.value`;
   const query = SQL`
     SELECT m.user, m.thread, c.platform, c.device_token, c.versions,
       f.user AS focused_user
   `;
   query.append(subthreadSelects);
   query.append(SQL`
     FROM memberships m
     LEFT JOIN cookies c ON c.user = m.user AND c.device_token IS NOT NULL
     LEFT JOIN focused f ON f.user = m.user AND f.thread = m.thread
       AND f.time > ${time}
   `);
   appendSQLArray(query, subthreadJoins, SQL` `);
   query.append(SQL`
     WHERE (m.role > 0 OR f.user IS NOT NULL) AND
       JSON_EXTRACT(m.permissions, ${visibleExtractString}) IS TRUE AND
       m.thread IN (${[...threadsToMessageIndices.keys()]})
   `);
 
   const perUserInfo = new Map<string, UserThreadInfo>();
   const [result] = await dbQuery(query);
   for (const row of result) {
     const userID = row.user.toString();
     const threadID = row.thread.toString();
     const deviceToken = row.device_token;
     const focusedUser = !!row.focused_user;
     const { platform } = row;
     const versions = JSON.parse(row.versions);
     let thisUserInfo = perUserInfo.get(userID);
     if (!thisUserInfo) {
       thisUserInfo = {
         devices: new Map(),
         threadIDs: new Set(),
         notFocusedThreadIDs: new Set(),
         userNotMemberOfSubthreads: new Set(),
         subthreadsCanSetToUnread: new Set(),
       };
       perUserInfo.set(userID, thisUserInfo);
       // Subthread info will be the same for each subthread, so we only parse
       // it once
       for (const subthread of subthreadPermissionsToCheck) {
         const isSubthreadMember = row[`subthread${subthread}_role`] > 0;
         const rawSubthreadPermissions =
           row[`subthread${subthread}_permissions`];
         const subthreadPermissions = JSON.parse(rawSubthreadPermissions);
         const canSeeSubthread = permissionLookup(
           subthreadPermissions,
           threadPermissions.KNOW_OF,
         );
         if (!canSeeSubthread) {
           continue;
         }
         thisUserInfo.subthreadsCanSetToUnread.add(subthread);
         // Only include the notification from the superthread if there is no
         // notification from the subthread
         if (
           !isSubthreadMember ||
           !permissionLookup(subthreadPermissions, threadPermissions.VISIBLE)
         ) {
           thisUserInfo.userNotMemberOfSubthreads.add(subthread);
         }
       }
     }
     if (deviceToken) {
       thisUserInfo.devices.set(deviceToken, {
         deviceType: platform,
         deviceToken,
         codeVersion: versions ? versions.codeVersion : null,
       });
     }
     thisUserInfo.threadIDs.add(threadID);
     if (!focusedUser) {
       thisUserInfo.notFocusedThreadIDs.add(threadID);
     }
   }
 
   const messageInfosPerUser = {};
   const latestMessagesPerUser: LatestMessagesPerUser = new Map();
   const userPushInfoPromises = {};
   for (const pair of perUserInfo) {
     const [userID, preUserPushInfo] = pair;
     const { userNotMemberOfSubthreads } = preUserPushInfo;
     const userDevices = [...preUserPushInfo.devices.values()];
     if (userDevices.length === 0) {
       continue;
     }
 
     const userPushInfoMessageInfoPromises = [];
     for (const threadID of preUserPushInfo.notFocusedThreadIDs) {
       const messageIndices = threadsToMessageIndices.get(threadID);
       invariant(messageIndices, `indices should exist for thread ${threadID}`);
       userPushInfoMessageInfoPromises.push(
         ...messageIndices.map(async messageIndex => {
           const messageInfo = messageInfos[messageIndex];
           const { type } = messageInfo;
           if (messageInfo.creatorID === userID) {
             // We never send a user notifs about their own activity
             return undefined;
           }
           const { generatesNotifs } = messageSpecs[type];
           const doesGenerateNotif = await generatesNotifs(messageInfo, {
             notifTargetUserID: userID,
             userNotMemberOfSubthreads,
             fetchMessageInfoByID: (messageID: string) =>
               fetchMessageInfoByID(viewer, messageID),
           });
-          return doesGenerateNotif ? messageInfo : undefined;
+          return doesGenerateNotif === pushTypes.NOTIF
+            ? messageInfo
+            : undefined;
         }),
       );
     }
     const userPushInfoPromise = (async () => {
       const userMessageInfos = await Promise.all(
         userPushInfoMessageInfoPromises,
       );
       const filteredMessageInfos = userMessageInfos.filter(Boolean);
       if (filteredMessageInfos.length === 0) {
         return undefined;
       }
       return {
         devices: userDevices,
         messageInfos: filteredMessageInfos,
       };
     })();
     userPushInfoPromises[userID] = userPushInfoPromise;
     const userMessageInfos = [];
     for (const threadID of preUserPushInfo.threadIDs) {
       const messageIndices = threadsToMessageIndices.get(threadID);
       invariant(messageIndices, `indices should exist for thread ${threadID}`);
       for (const messageIndex of messageIndices) {
         const messageInfo = messageInfos[messageIndex];
         userMessageInfos.push(messageInfo);
       }
     }
     if (userMessageInfos.length > 0) {
       messageInfosPerUser[userID] = userMessageInfos;
     }
 
     latestMessagesPerUser.set(
       userID,
       determineLatestMessagesPerThread(
         preUserPushInfo,
         userID,
         threadsToMessageIndices,
         messageInfos,
       ),
     );
   }
 
   const latestMessages = flattenLatestMessagesPerUser(latestMessagesPerUser);
 
   const [pushInfo] = await Promise.all([
     promiseAll(userPushInfoPromises),
     createReadStatusUpdates(latestMessages),
     redisPublish(viewer, messageInfosPerUser, updatesForCurrentSession),
     updateLatestMessages(latestMessages),
   ]);
 
   await sendPushNotifs(_pickBy(Boolean)(pushInfo));
 }
 
 async function redisPublish(
   viewer: Viewer,
   messageInfosPerUser: { [userID: string]: $ReadOnlyArray<RawMessageInfo> },
   updatesForCurrentSession: UpdatesForCurrentSession,
 ) {
   const avoidBroadcastingToCurrentSession =
     viewer.hasSessionInfo && updatesForCurrentSession !== 'broadcast';
   for (const userID in messageInfosPerUser) {
     if (userID === viewer.userID && avoidBroadcastingToCurrentSession) {
       continue;
     }
     const messageInfos = messageInfosPerUser[userID];
     publisher.sendMessage(
       { userID },
       {
         type: redisMessageTypes.NEW_MESSAGES,
         messages: messageInfos,
       },
     );
   }
   const viewerMessageInfos = messageInfosPerUser[viewer.userID];
   if (!viewerMessageInfos || !avoidBroadcastingToCurrentSession) {
     return;
   }
   const sessionIDs = await fetchOtherSessionsForViewer(viewer);
   for (const sessionID of sessionIDs) {
     publisher.sendMessage(
       { userID: viewer.userID, sessionID },
       {
         type: redisMessageTypes.NEW_MESSAGES,
         messages: viewerMessageInfos,
       },
     );
   }
 }
 
 function determineLatestMessagesPerThread(
   preUserPushInfo: UserThreadInfo,
   userID: string,
   threadsToMessageIndices: $ReadOnlyMap<string, $ReadOnlyArray<number>>,
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ) {
   const {
     threadIDs,
     notFocusedThreadIDs,
     subthreadsCanSetToUnread,
   } = preUserPushInfo;
   const latestMessagesPerThread = new Map();
   for (const threadID of threadIDs) {
     const messageIndices = threadsToMessageIndices.get(threadID);
     invariant(messageIndices, `indices should exist for thread ${threadID}`);
     for (const messageIndex of messageIndices) {
       const messageInfo = messageInfos[messageIndex];
       if (
         messageInfo.type === messageTypes.CREATE_SUB_THREAD &&
         !subthreadsCanSetToUnread.has(messageInfo.childThreadID)
       ) {
         continue;
       }
 
       const messageID = messageInfo.id;
       invariant(
         messageID,
         'message ID should exist in determineLatestMessagesPerThread',
       );
 
       if (
         notFocusedThreadIDs.has(threadID) &&
         messageInfo.creatorID !== userID
       ) {
         latestMessagesPerThread.set(threadID, {
           latestMessage: messageID,
         });
       } else {
         latestMessagesPerThread.set(threadID, {
           latestMessage: messageID,
           latestReadMessage: messageID,
         });
       }
     }
   }
   return latestMessagesPerThread;
 }
 
 function flattenLatestMessagesPerUser(
   latestMessagesPerUser: LatestMessagesPerUser,
 ): LatestMessages {
   const result = [];
   for (const [userID, latestMessagesPerThread] of latestMessagesPerUser) {
     for (const [threadID, latestMessages] of latestMessagesPerThread) {
       result.push({
         userID,
         threadID,
         latestMessage: latestMessages.latestMessage,
         latestReadMessage: latestMessages.latestReadMessage,
       });
     }
   }
   return result;
 }
 
 async function createReadStatusUpdates(latestMessages: LatestMessages) {
   const now = Date.now();
   const readStatusUpdates = latestMessages
     .filter(message => !message.latestReadMessage)
     .map(({ userID, threadID }) => ({
       type: updateTypes.UPDATE_THREAD_READ_STATUS,
       userID,
       time: now,
       threadID,
       unread: true,
     }));
 
   if (readStatusUpdates.length === 0) {
     return;
   }
 
   return await createUpdates(readStatusUpdates);
 }
 
 function updateLatestMessages(latestMessages: LatestMessages) {
   if (latestMessages.length === 0) {
     return;
   }
 
   const query = SQL`
     UPDATE memberships
     SET 
   `;
 
   const lastMessageExpression = SQL`
     last_message = GREATEST(last_message, CASE 
   `;
   const lastReadMessageExpression = SQL`
     , last_read_message = GREATEST(last_read_message, CASE 
   `;
   let shouldUpdateLastReadMessage = false;
   for (const {
     userID,
     threadID,
     latestMessage,
     latestReadMessage,
   } of latestMessages) {
     lastMessageExpression.append(SQL`
       WHEN user = ${userID} AND thread = ${threadID} THEN ${latestMessage}
     `);
     if (latestReadMessage) {
       shouldUpdateLastReadMessage = true;
       lastReadMessageExpression.append(SQL`
         WHEN user = ${userID} AND thread = ${threadID} THEN ${latestReadMessage}
       `);
     }
   }
   lastMessageExpression.append(SQL`
     ELSE last_message
     END)
   `);
   lastReadMessageExpression.append(SQL`
     ELSE last_read_message
     END)
   `);
 
   const conditions = latestMessages.map(
     ({ userID, threadID }) => SQL`(user = ${userID} AND thread = ${threadID})`,
   );
 
   query.append(lastMessageExpression);
   if (shouldUpdateLastReadMessage) {
     query.append(lastReadMessageExpression);
   }
   query.append(SQL`WHERE `);
   query.append(mergeOrConditions(conditions));
 
   return dbQuery(query);
 }
 
 export default createMessages;
diff --git a/lib/shared/messages/add-members-message-spec.js b/lib/shared/messages/add-members-message-spec.js
index 95d5fa6a1..93fcb2f3e 100644
--- a/lib/shared/messages/add-members-message-spec.js
+++ b/lib/shared/messages/add-members-message-spec.js
@@ -1,185 +1,185 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   AddMembersMessageData,
   AddMembersMessageInfo,
   RawAddMembersMessageInfo,
 } from '../../types/messages/add-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { values } from '../../utils/objects';
 import {
   robotextForMessageInfo,
   robotextToRawString,
   removeCreatorAsViewer,
 } from '../message-utils';
 import type {
   CreateMessageInfoParams,
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
   RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const addMembersMessageSpec: MessageSpec<
   AddMembersMessageData,
   RawAddMembersMessageInfo,
   AddMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: AddMembersMessageData | RawAddMembersMessageInfo,
   ): string {
     return JSON.stringify(data.addedUserIDs);
   },
 
   messageContentForClientDB(data: RawAddMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<AddMembersMessageInfo>) {
     let validMessageInfo: AddMembersMessageInfo = (messageInfo: AddMembersMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         addedMembers: validMessageInfo.addedMembers.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawAddMembersMessageInfo {
     return {
       type: messageTypes.ADD_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       addedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawAddMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawAddMembersMessageInfo: RawAddMembersMessageInfo = {
       type: messageTypes.ADD_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       addedUserIDs: JSON.parse(content),
     };
     return rawAddMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawAddMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): AddMembersMessageInfo {
     const addedMembers = params.createRelativeUserInfos(
       rawMessageInfo.addedUserIDs,
     );
     return {
       type: messageTypes.ADD_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       addedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: AddMembersMessageData,
     id: ?string,
   ): RawAddMembersMessageInfo {
     invariant(id, 'RawAddMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: AddMembersMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     const users = messageInfo.addedMembers;
     invariant(users.length !== 0, 'added who??');
     const addedUsersString = params.robotextForUsers(users);
     return `${creator} added ${addedUsersString}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const addedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.ADD_MEMBERS,
         'messageInfo should be messageTypes.ADD_MEMBERS!',
       );
       for (const member of messageInfo.addedMembers) {
         addedMembersObject[member.id] = member;
       }
     }
     const addedMembers = values(addedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.ADD_MEMBERS,
       'messageInfo should be messageTypes.ADD_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, addedMembers };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} to ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawAddMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
-  generatesNotifs: async () => false,
+  generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawAddMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.addedUserIDs;
   },
 });
diff --git a/lib/shared/messages/change-role-message-spec.js b/lib/shared/messages/change-role-message-spec.js
index f92cdf182..52f4e8eab 100644
--- a/lib/shared/messages/change-role-message-spec.js
+++ b/lib/shared/messages/change-role-message-spec.js
@@ -1,196 +1,197 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeRoleMessageData,
   ChangeRoleMessageInfo,
   RawChangeRoleMessageInfo,
 } from '../../types/messages/change-role';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { values } from '../../utils/objects';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  RobotextParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeRoleMessageSpec: MessageSpec<
   ChangeRoleMessageData,
   RawChangeRoleMessageInfo,
   ChangeRoleMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeRoleMessageData | RawChangeRoleMessageInfo,
   ): string {
     return JSON.stringify({
       userIDs: data.userIDs,
       newRole: data.newRole,
     });
   },
 
   messageContentForClientDB(data: RawChangeRoleMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<ChangeRoleMessageInfo>) {
     let validMessageInfo: ChangeRoleMessageInfo = (messageInfo: ChangeRoleMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         members: validMessageInfo.members.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeRoleMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeRoleMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawChangeRoleMessageInfo: RawChangeRoleMessageInfo = {
       type: messageTypes.CHANGE_ROLE,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
     return rawChangeRoleMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeRoleMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ChangeRoleMessageInfo {
     const members = params.createRelativeUserInfos(rawMessageInfo.userIDs);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       members,
       newRole: rawMessageInfo.newRole,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeRoleMessageData,
     id: ?string,
   ): RawChangeRoleMessageInfo {
     invariant(id, 'RawChangeRoleMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: ChangeRoleMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     const users = messageInfo.members;
     invariant(users.length !== 0, 'changed whose role??');
     const usersString = params.robotextForUsers(users);
 
     const { threadInfo } = params;
     invariant(threadInfo, 'ThreadInfo should be set for CHANGE_ROLE message');
     const verb = threadInfo.roles[messageInfo.newRole].isDefault
       ? 'removed'
       : 'added';
 
     const noun = users.length === 1 ? 'an admin' : 'admins';
     return `${creator} ${verb} ${usersString} as ${noun}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const membersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.CHANGE_ROLE,
         'messageInfo should be messageTypes.CHANGE_ROLE!',
       );
       for (const member of messageInfo.members) {
         membersObject[member.id] = member;
       }
     }
     const members = values(membersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_ROLE,
       'messageInfo should be messageTypes.CHANGE_ROLE!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, members };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawChangeRoleMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.newRole,
     );
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/change-settings-message-spec.js b/lib/shared/messages/change-settings-message-spec.js
index 054c3b695..f5e0679ea 100644
--- a/lib/shared/messages/change-settings-message-spec.js
+++ b/lib/shared/messages/change-settings-message-spec.js
@@ -1,194 +1,195 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeSettingsMessageData,
   ChangeSettingsMessageInfo,
   RawChangeSettingsMessageInfo,
 } from '../../types/messages/change-settings';
 import type { NotifTexts } from '../../types/notif-types';
 import { assertThreadType } from '../../types/thread-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { validHexColorRegex } from '../account-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { threadLabel } from '../thread-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  RobotextParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeSettingsMessageSpec: MessageSpec<
   ChangeSettingsMessageData,
   RawChangeSettingsMessageInfo,
   ChangeSettingsMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeSettingsMessageData | RawChangeSettingsMessageInfo,
   ): string {
     return JSON.stringify({
       [data.field]: data.value,
     });
   },
 
   messageContentForClientDB(data: RawChangeSettingsMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<ChangeSettingsMessageInfo>) {
     let validMessageInfo: ChangeSettingsMessageInfo = (messageInfo: ChangeSettingsMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeSettingsMessageInfo {
     const content = JSON.parse(row.content);
     const field = Object.keys(content)[0];
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       field,
       value: content[field],
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeSettingsMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const field = Object.keys(content)[0];
     const rawChangeSettingsMessageInfo: RawChangeSettingsMessageInfo = {
       type: messageTypes.CHANGE_SETTINGS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       field,
       value: content[field],
     };
     return rawChangeSettingsMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeSettingsMessageInfo,
     creator: RelativeUserInfo,
   ): ChangeSettingsMessageInfo {
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       field: rawMessageInfo.field,
       value: rawMessageInfo.value,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeSettingsMessageData,
     id: ?string,
   ): RawChangeSettingsMessageInfo {
     invariant(id, 'RawChangeSettingsMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: ChangeSettingsMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     if (
       (messageInfo.field === 'name' || messageInfo.field === 'description') &&
       messageInfo.value.toString() === ''
     ) {
       return `${creator} cleared ${params.encodedThreadEntity(
         messageInfo.threadID,
         'the chat',
       )}'s ${messageInfo.field}`;
     }
     let value;
     if (
       messageInfo.field === 'color' &&
       messageInfo.value.toString().match(validHexColorRegex)
     ) {
       value = `<#${messageInfo.value}|c${messageInfo.threadID}>`;
     } else if (messageInfo.field === 'type') {
       invariant(
         typeof messageInfo.value === 'number',
         'messageInfo.value should be number for thread type change ',
       );
       const newThreadType = assertThreadType(messageInfo.value);
       value = threadLabel(newThreadType);
     } else {
       value = messageInfo.value;
     }
     return (
       `${creator} updated ` +
       `${params.encodedThreadEntity(messageInfo.threadID, 'the chat')}'s ` +
       `${messageInfo.field} to "${value}"`
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_SETTINGS,
       'messageInfo should be messageTypes.CHANGE_SETTINGS!',
     );
     const body = params.strippedRobotextForMessageInfo(
       mostRecentMessageInfo,
       threadInfo,
     );
     return {
       merged: body,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawChangeSettingsMessageInfo,
   ): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.field,
     );
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/create-entry-message-spec.js b/lib/shared/messages/create-entry-message-spec.js
index 2b22ff2b7..889086672 100644
--- a/lib/shared/messages/create-entry-message-spec.js
+++ b/lib/shared/messages/create-entry-message-spec.js
@@ -1,183 +1,184 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateEntryMessageData,
   CreateEntryMessageInfo,
   RawCreateEntryMessageInfo,
 } from '../../types/messages/create-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const createEntryMessageSpec: MessageSpec<
   CreateEntryMessageData,
   RawCreateEntryMessageInfo,
   CreateEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateEntryMessageData | RawCreateEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawCreateEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateEntryMessageInfo>) {
     let validMessageInfo: CreateEntryMessageInfo = (messageInfo: CreateEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.CREATE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawCreateEntryMessageInfo: RawCreateEntryMessageInfo = {
       type: messageTypes.CREATE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawCreateEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateEntryMessageInfo,
     creator: RelativeUserInfo,
   ): CreateEntryMessageInfo {
     return {
       type: messageTypes.CREATE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateEntryMessageData,
     id: ?string,
   ): RawCreateEntryMessageInfo {
     invariant(id, 'RawCreateEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateEntryMessageInfo, creator: string): string {
     const date = prettyDate(messageInfo.date);
     return (
       `${creator} created an event scheduled for ${date}: ` +
       `"${encodeURI(messageInfo.text)}"`
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const hasCreateEntry = messageInfos.some(
       messageInfo => messageInfo.type === messageTypes.CREATE_ENTRY,
     );
     const messageInfo = messageInfos[0];
     if (!hasCreateEntry) {
       invariant(
         messageInfo.type === messageTypes.EDIT_ENTRY,
         'messageInfo should be messageTypes.EDIT_ENTRY!',
       );
       const body =
         `updated the text of an event in ` +
         `${params.notifThreadName(threadInfo)} scheduled for ` +
         `${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
       const prefix = stringForUser(messageInfo.creator);
       const merged = `${prefix} ${body}`;
       return {
         merged,
         title: threadInfo.uiName,
         body,
         prefix,
       };
     }
     invariant(
       messageInfo.type === messageTypes.CREATE_ENTRY ||
         messageInfo.type === messageTypes.EDIT_ENTRY,
       'messageInfo should be messageTypes.CREATE_ENTRY/EDIT_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `created an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawCreateEntryMessageInfo): string {
     return joinResult(rawMessageInfo.creatorID, rawMessageInfo.entryID);
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index fe9349836..6d0c41e61 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,251 +1,252 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from '../../types/messages/create-sidebar';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  MessageTitleParam,
-  RobotextParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type MessageTitleParam,
+  type RobotextParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSidebarMessageSpec: MessageSpec<
   CreateSidebarMessageData,
   RawCreateSidebarMessageInfo,
   CreateSidebarMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSidebarMessageData | RawCreateSidebarMessageInfo,
   ): string {
     return JSON.stringify({
       ...data.initialThreadState,
       sourceMessageAuthorID: data.sourceMessageAuthorID,
     });
   },
 
   messageContentForClientDB(data: RawCreateSidebarMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateSidebarMessageInfo>) {
     let validMessageInfo: CreateSidebarMessageInfo = (messageInfo: CreateSidebarMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         sourceMessageAuthor: {
           ...validMessageInfo.sourceMessageAuthor,
           isViewer: false,
         },
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateSidebarMessageInfo {
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       row.content,
     );
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessageAuthorID,
       initialThreadState,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSidebarMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
 
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       clientDBMessageInfo.content,
     );
     const rawCreateSidebarMessageInfo: RawCreateSidebarMessageInfo = {
       type: messageTypes.CREATE_SIDEBAR,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessageAuthorID: sourceMessageAuthorID,
       initialThreadState: initialThreadState,
     };
     return rawCreateSidebarMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSidebarMessageInfo {
     const { threadInfos } = params;
     const parentThreadInfo =
       threadInfos[rawMessageInfo.initialThreadState.parentThreadID];
 
     const sourceMessageAuthor = params.createRelativeUserInfos([
       rawMessageInfo.sourceMessageAuthorID,
     ])[0];
     if (!sourceMessageAuthor) {
       return null;
     }
 
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessageAuthor,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSidebarMessageData,
     id: ?string,
   ): RawCreateSidebarMessageInfo {
     invariant(id, 'RawCreateSidebarMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: CreateSidebarMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     let text = `started ${params.encodedThreadEntity(
       messageInfo.threadID,
       `this thread`,
     )}`;
     const users = messageInfo.initialThreadState.otherMembers.filter(
       member => member.id !== messageInfo.sourceMessageAuthor.id,
     );
     if (users.length !== 0) {
       const initialUsersString = params.robotextForUsers(users);
       text += ` and added ${initialUsersString}`;
     }
     return `${creator} ${text}`;
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawCreateSidebarMessageInfo | RawUnsupportedMessageInfo {
     // TODO determine min code version
     if (hasMinCodeVersion(platformDetails, 75)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'created a thread',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawCreateSidebarMessageInfo,
   ): RawCreateSidebarMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SIDEBAR,
       'messageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const sourceMessageAuthorPossessive = messageInfo.sourceMessageAuthor
       .isViewer
       ? 'your'
       : `${stringForUser(messageInfo.sourceMessageAuthor)}'s`;
     const body =
       `started a thread in response to ${sourceMessageAuthorPossessive} ` +
       `message "${messageInfo.initialThreadState.name ?? ''}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateSidebarMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSidebarMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return [parentThreadID];
   },
 });
diff --git a/lib/shared/messages/create-sub-thread-message-spec.js b/lib/shared/messages/create-sub-thread-message-spec.js
index 10a425e2c..b6b1027d6 100644
--- a/lib/shared/messages/create-sub-thread-message-spec.js
+++ b/lib/shared/messages/create-sub-thread-message-spec.js
@@ -1,176 +1,179 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { permissionLookup } from '../../permissions/thread-permissions';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSubthreadMessageData,
   CreateSubthreadMessageInfo,
   RawCreateSubthreadMessageInfo,
 } from '../../types/messages/create-subthread';
 import type { NotifTexts } from '../../types/notif-types';
 import { threadPermissions, threadTypes } from '../../types/thread-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  GeneratesNotifsParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type GeneratesNotifsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSubThreadMessageSpec: MessageSpec<
   CreateSubthreadMessageData,
   RawCreateSubthreadMessageInfo,
   CreateSubthreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSubthreadMessageData | RawCreateSubthreadMessageInfo,
   ): string {
     return data.childThreadID;
   },
 
   messageContentForClientDB(data: RawCreateSubthreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateSubthreadMessageInfo>) {
     let validMessageInfo: CreateSubthreadMessageInfo = (messageInfo: CreateSubthreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): ?RawCreateSubthreadMessageInfo {
     const subthreadPermissions = row.subthread_permissions;
     if (!permissionLookup(subthreadPermissions, threadPermissions.KNOW_OF)) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       childThreadID: row.content,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSubthreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateSubthreadMessageInfo: RawCreateSubthreadMessageInfo = {
       type: messageTypes.CREATE_SUB_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       childThreadID: content,
     };
     return rawCreateSubthreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSubthreadMessageInfo {
     const { threadInfos } = params;
     const childThreadInfo = threadInfos[rawMessageInfo.childThreadID];
     if (!childThreadInfo) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       childThreadInfo,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSubthreadMessageData,
     id: ?string,
   ): RawCreateSubthreadMessageInfo {
     invariant(id, 'RawCreateSubthreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateSubthreadMessageInfo, creator: string): string {
     const childName = messageInfo.childThreadInfo.name;
     const childNoun =
       messageInfo.childThreadInfo.type === threadTypes.SIDEBAR
         ? 'thread'
         : 'subchannel';
     if (childName) {
       return (
         `${creator} created a ${childNoun}` +
         ` named "<${encodeURI(childName)}|t${messageInfo.childThreadInfo.id}>"`
       );
     } else {
       return (
         `${creator} created a ` +
         `<${childNoun}|t${messageInfo.childThreadInfo.id}>`
       );
     }
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SUB_THREAD,
       'messageInfo should be messageTypes.CREATE_SUB_THREAD!',
     );
     return params.notifTextForSubthreadCreation(
       messageInfo.creator,
       messageInfo.childThreadInfo.type,
       threadInfo,
       messageInfo.childThreadInfo.name,
       messageInfo.childThreadInfo.uiName,
     );
   },
 
   generatesNotifs: async (
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     params: GeneratesNotifsParams,
   ) => {
     const { userNotMemberOfSubthreads } = params;
-    return userNotMemberOfSubthreads.has(rawMessageInfo.childThreadID);
+    return userNotMemberOfSubthreads.has(rawMessageInfo.childThreadID)
+      ? pushTypes.NOTIF
+      : undefined;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
   ): $ReadOnlyArray<string> {
     return [rawMessageInfo.childThreadID];
   },
 });
diff --git a/lib/shared/messages/create-thread-message-spec.js b/lib/shared/messages/create-thread-message-spec.js
index 4b45d10b7..456ac1dea 100644
--- a/lib/shared/messages/create-thread-message-spec.js
+++ b/lib/shared/messages/create-thread-message-spec.js
@@ -1,219 +1,220 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from '../../types/messages/create-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  RobotextParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type RobotextParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createThreadMessageSpec: MessageSpec<
   CreateThreadMessageData,
   RawCreateThreadMessageInfo,
   CreateThreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateThreadMessageData | RawCreateThreadMessageInfo,
   ): string {
     return JSON.stringify(data.initialThreadState);
   },
 
   messageContentForClientDB(data: RawCreateThreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateThreadMessageInfo>) {
     let validMessageInfo: CreateThreadMessageInfo = (messageInfo: CreateThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateThreadMessageInfo {
     return {
       type: messageTypes.CREATE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       initialThreadState: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateThreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateThreadMessageInfo: RawCreateThreadMessageInfo = {
       type: messageTypes.CREATE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       initialThreadState: JSON.parse(content),
     };
     return rawCreateThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateThreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): CreateThreadMessageInfo {
     const initialParentThreadID =
       rawMessageInfo.initialThreadState.parentThreadID;
     const parentThreadInfo = initialParentThreadID
       ? params.threadInfos[initialParentThreadID]
       : null;
 
     return {
       type: messageTypes.CREATE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         type: rawMessageInfo.initialThreadState.type,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateThreadMessageData,
     id: ?string,
   ): RawCreateThreadMessageInfo {
     invariant(id, 'RawCreateThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: CreateThreadMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     let text = `created ${params.encodedThreadEntity(
       messageInfo.threadID,
       `this chat`,
     )}`;
     const parentThread = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThread) {
       text +=
         ' as a child of ' +
         `<${encodeURI(parentThread.uiName)}|t${parentThread.id}>`;
     }
     if (messageInfo.initialThreadState.name) {
       text += ` with the name "${encodeURI(
         messageInfo.initialThreadState.name,
       )}"`;
     }
     const users = messageInfo.initialThreadState.otherMembers;
     if (users.length !== 0) {
       const initialUsersString = params.robotextForUsers(users);
       text += ` and added ${initialUsersString}`;
     }
     return `${creator} ${text}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_THREAD,
       'messageInfo should be messageTypes.CREATE_THREAD!',
     );
     const parentThreadInfo = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThreadInfo) {
       return params.notifTextForSubthreadCreation(
         messageInfo.creator,
         messageInfo.initialThreadState.type,
         parentThreadInfo,
         messageInfo.initialThreadState.name,
         threadInfo.uiName,
       );
     }
     const prefix = stringForUser(messageInfo.creator);
     const body = 'created a new chat';
     let merged = `${prefix} ${body}`;
     if (messageInfo.initialThreadState.name) {
       merged += ` called "${messageInfo.initialThreadState.name}"`;
     }
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateThreadMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   startsThread: true,
 
   threadIDs(
     rawMessageInfo: RawCreateThreadMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return parentThreadID ? [parentThreadID] : [];
   },
 });
diff --git a/lib/shared/messages/delete-entry-message-spec.js b/lib/shared/messages/delete-entry-message-spec.js
index 33f5fb1d5..4a94e05dc 100644
--- a/lib/shared/messages/delete-entry-message-spec.js
+++ b/lib/shared/messages/delete-entry-message-spec.js
@@ -1,157 +1,158 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   DeleteEntryMessageData,
   DeleteEntryMessageInfo,
   RawDeleteEntryMessageInfo,
 } from '../../types/messages/delete-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const deleteEntryMessageSpec: MessageSpec<
   DeleteEntryMessageData,
   RawDeleteEntryMessageInfo,
   DeleteEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: DeleteEntryMessageData | RawDeleteEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawDeleteEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<DeleteEntryMessageInfo>) {
     let validMessageInfo: DeleteEntryMessageInfo = (messageInfo: DeleteEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawDeleteEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.DELETE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawDeleteEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawDeleteEntryMessageInfo: RawDeleteEntryMessageInfo = {
       type: messageTypes.DELETE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawDeleteEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawDeleteEntryMessageInfo,
     creator: RelativeUserInfo,
   ): DeleteEntryMessageInfo {
     return {
       type: messageTypes.DELETE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: DeleteEntryMessageData,
     id: ?string,
   ): RawDeleteEntryMessageInfo {
     invariant(id, 'RawDeleteEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: DeleteEntryMessageInfo, creator: string): string {
     const date = prettyDate(messageInfo.date);
     return (
       `${creator} deleted an event scheduled for ${date}: ` +
       `"${encodeURI(messageInfo.text)}"`
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.DELETE_ENTRY,
       'messageInfo should be messageTypes.DELETE_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `deleted an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/edit-entry-message-spec.js b/lib/shared/messages/edit-entry-message-spec.js
index c7185dff1..4615fc4ec 100644
--- a/lib/shared/messages/edit-entry-message-spec.js
+++ b/lib/shared/messages/edit-entry-message-spec.js
@@ -1,183 +1,184 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   EditEntryMessageData,
   EditEntryMessageInfo,
   RawEditEntryMessageInfo,
 } from '../../types/messages/edit-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const editEntryMessageSpec: MessageSpec<
   EditEntryMessageData,
   RawEditEntryMessageInfo,
   EditEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: EditEntryMessageData | RawEditEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawEditEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<EditEntryMessageInfo>) {
     let validMessageInfo: EditEntryMessageInfo = (messageInfo: EditEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawEditEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.EDIT_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawEditEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== null &&
         clientDBMessageInfo.content !== undefined,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawEditEntryMessageInfo: RawEditEntryMessageInfo = {
       type: messageTypes.EDIT_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawEditEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawEditEntryMessageInfo,
     creator: RelativeUserInfo,
   ): EditEntryMessageInfo {
     return {
       type: messageTypes.EDIT_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: EditEntryMessageData,
     id: ?string,
   ): RawEditEntryMessageInfo {
     invariant(id, 'RawEditEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: EditEntryMessageInfo, creator: string): string {
     const date = prettyDate(messageInfo.date);
     return (
       `${creator} updated the text of an event scheduled for ` +
       `${date}: "${encodeURI(messageInfo.text)}"`
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const hasCreateEntry = messageInfos.some(
       messageInfo => messageInfo.type === messageTypes.CREATE_ENTRY,
     );
     const messageInfo = messageInfos[0];
     if (!hasCreateEntry) {
       invariant(
         messageInfo.type === messageTypes.EDIT_ENTRY,
         'messageInfo should be messageTypes.EDIT_ENTRY!',
       );
       const body =
         `updated the text of an event in ` +
         `${params.notifThreadName(threadInfo)} scheduled for ` +
         `${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
       const prefix = stringForUser(messageInfo.creator);
       const merged = `${prefix} ${body}`;
       return {
         merged,
         title: threadInfo.uiName,
         body,
         prefix,
       };
     }
     invariant(
       messageInfo.type === messageTypes.CREATE_ENTRY ||
         messageInfo.type === messageTypes.EDIT_ENTRY,
       'messageInfo should be messageTypes.CREATE_ENTRY/EDIT_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `created an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawEditEntryMessageInfo): string {
     return joinResult(rawMessageInfo.creatorID, rawMessageInfo.entryID);
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/join-thread-message-spec.js b/lib/shared/messages/join-thread-message-spec.js
index bc49210c4..26ce0e4be 100644
--- a/lib/shared/messages/join-thread-message-spec.js
+++ b/lib/shared/messages/join-thread-message-spec.js
@@ -1,138 +1,138 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   JoinThreadMessageData,
   JoinThreadMessageInfo,
   RawJoinThreadMessageInfo,
 } from '../../types/messages/join-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { values } from '../../utils/objects';
 import { pluralize } from '../../utils/text-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import type {
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
   RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const joinThreadMessageSpec: MessageSpec<
   JoinThreadMessageData,
   RawJoinThreadMessageInfo,
   JoinThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawJoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawJoinThreadMessageInfo {
     const rawJoinThreadMessageInfo: RawJoinThreadMessageInfo = {
       type: messageTypes.JOIN_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawJoinThreadMessageInfo;
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<JoinThreadMessageInfo>) {
     let validMessageInfo: JoinThreadMessageInfo = (messageInfo: JoinThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   createMessageInfo(
     rawMessageInfo: RawJoinThreadMessageInfo,
     creator: RelativeUserInfo,
   ): JoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: JoinThreadMessageData,
     id: ?string,
   ): RawJoinThreadMessageInfo {
     invariant(id, 'RawJoinThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: JoinThreadMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     return (
       `${creator} joined ` +
       params.encodedThreadEntity(messageInfo.threadID, 'this chat')
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const joinerArray = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.JOIN_THREAD,
         'messageInfo should be messageTypes.JOIN_THREAD!',
       );
       joinerArray[messageInfo.creator.id] = messageInfo.creator;
     }
     const joiners = values(joinerArray);
     const joinersString = pluralize(joiners.map(stringForUser));
 
     const body = `${joinersString} joined`;
     const merged = `${body} ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawJoinThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
-  generatesNotifs: async () => false,
+  generatesNotifs: async () => undefined,
 });
diff --git a/lib/shared/messages/leave-thread-message-spec.js b/lib/shared/messages/leave-thread-message-spec.js
index 92f6ec174..2586d83c3 100644
--- a/lib/shared/messages/leave-thread-message-spec.js
+++ b/lib/shared/messages/leave-thread-message-spec.js
@@ -1,138 +1,138 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   LeaveThreadMessageData,
   LeaveThreadMessageInfo,
   RawLeaveThreadMessageInfo,
 } from '../../types/messages/leave-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { values } from '../../utils/objects';
 import { pluralize } from '../../utils/text-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import type {
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
   RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const leaveThreadMessageSpec: MessageSpec<
   LeaveThreadMessageData,
   RawLeaveThreadMessageInfo,
   LeaveThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawLeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawLeaveThreadMessageInfo {
     const rawLeaveThreadMessageInfo: RawLeaveThreadMessageInfo = {
       type: messageTypes.LEAVE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawLeaveThreadMessageInfo;
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<LeaveThreadMessageInfo>) {
     let validMessageInfo: LeaveThreadMessageInfo = (messageInfo: LeaveThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   createMessageInfo(
     rawMessageInfo: RawLeaveThreadMessageInfo,
     creator: RelativeUserInfo,
   ): LeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: LeaveThreadMessageData,
     id: ?string,
   ): RawLeaveThreadMessageInfo {
     invariant(id, 'RawLeaveThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: LeaveThreadMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     return (
       `${creator} left ` +
       params.encodedThreadEntity(messageInfo.threadID, 'this chat')
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const leaverBeavers = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.LEAVE_THREAD,
         'messageInfo should be messageTypes.LEAVE_THREAD!',
       );
       leaverBeavers[messageInfo.creator.id] = messageInfo.creator;
     }
     const leavers = values(leaverBeavers);
     const leaversString = pluralize(leavers.map(stringForUser));
 
     const body = `${leaversString} left`;
     const merged = `${body} ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawLeaveThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
-  generatesNotifs: async () => false,
+  generatesNotifs: async () => undefined,
 });
diff --git a/lib/shared/messages/message-spec.js b/lib/shared/messages/message-spec.js
index 2a2d07040..c8037841c 100644
--- a/lib/shared/messages/message-spec.js
+++ b/lib/shared/messages/message-spec.js
@@ -1,120 +1,126 @@
 // @flow
 
 import type { PlatformDetails } from '../../types/device-types';
 import type { Media } from '../../types/media-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
   RawComposableMessageInfo,
   RawMessageInfo,
   RawRobotextMessageInfo,
   RobotextMessageInfo,
 } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { type ParserRules } from '../markdown';
 import type { GetMessageTitleViewerContext } from '../message-utils';
 
 export type MessageTitleParam<Info> = {
   +messageInfo: Info,
   +threadInfo: ThreadInfo,
   +markdownRules: ParserRules,
   +viewerContext?: GetMessageTitleViewerContext,
 };
 
 export type RawMessageInfoFromServerDBRowParams = {
   +localID: ?string,
   +media?: $ReadOnlyArray<Media>,
   +derivedMessages: $ReadOnlyMap<
     string,
     RawComposableMessageInfo | RawRobotextMessageInfo,
   >,
 };
 
 export type CreateMessageInfoParams = {
   +threadInfos: { +[id: string]: ThreadInfo },
   +createMessageInfoFromRaw: (rawInfo: RawMessageInfo) => ?MessageInfo,
   +createRelativeUserInfos: (
     userIDs: $ReadOnlyArray<string>,
   ) => RelativeUserInfo[],
 };
 
 export type RobotextParams = {
   +encodedThreadEntity: (threadID: string, text: string) => string,
   +robotextForUsers: (users: RelativeUserInfo[]) => string,
   +robotextForUser: (user: RelativeUserInfo) => string,
   +threadInfo: ?ThreadInfo,
 };
 
 export type NotificationTextsParams = {
   +notifThreadName: (threadInfo: ThreadInfo) => string,
   +notifTextForSubthreadCreation: (
     creator: RelativeUserInfo,
     threadType: ThreadType,
     parentThreadInfo: ThreadInfo,
     childThreadName: ?string,
     childThreadUIName: string,
   ) => NotifTexts,
   +strippedRobotextForMessageInfo: (
     messageInfo: RobotextMessageInfo,
     threadInfo: ThreadInfo,
   ) => string,
   +notificationTexts: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ) => NotifTexts,
 };
 
 export type GeneratesNotifsParams = {
   +notifTargetUserID: string,
   +userNotMemberOfSubthreads: Set<string>,
   +fetchMessageInfoByID: (messageID: string) => Promise<?RawMessageInfo>,
 };
 
+export const pushTypes = Object.freeze({
+  NOTIF: 'notif',
+  RESCIND: 'rescind',
+});
+export type PushType = $Values<typeof pushTypes>;
+
 export type MessageSpec<Data, RawInfo, Info> = {
   +messageContentForServerDB?: (data: Data | RawInfo) => string,
   +messageContentForClientDB?: (data: RawInfo) => string,
   +messageTitle: (param: MessageTitleParam<Info>) => string,
   +rawMessageInfoFromServerDBRow?: (
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ) => ?RawInfo,
   +rawMessageInfoFromClientDB: (
     clientDBMessageInfo: ClientDBMessageInfo,
   ) => RawInfo,
   +createMessageInfo: (
     rawMessageInfo: RawInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ) => ?Info,
   +rawMessageInfoFromMessageData?: (messageData: Data, id: ?string) => RawInfo,
   +robotext?: (
     messageInfo: Info,
     creator: string,
     params: RobotextParams,
   ) => string,
   +shimUnsupportedMessageInfo?: (
     rawMessageInfo: RawInfo,
     platformDetails: ?PlatformDetails,
   ) => RawInfo | RawUnsupportedMessageInfo,
   +unshimMessageInfo?: (
     unwrapped: RawInfo,
     messageInfo: RawMessageInfo,
   ) => ?RawMessageInfo,
   +notificationTexts?: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ) => NotifTexts,
   +notificationCollapseKey?: (rawMessageInfo: RawInfo) => string,
   +generatesNotifs: (
     rawMessageInfo: RawInfo,
     params: GeneratesNotifsParams,
-  ) => Promise<boolean>,
+  ) => Promise<?PushType>,
   +userIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +startsThread?: boolean,
   +threadIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +includedInRepliesCount?: boolean,
 };
diff --git a/lib/shared/messages/multimedia-message-spec.js b/lib/shared/messages/multimedia-message-spec.js
index 7e0495e31..2c53b0e3f 100644
--- a/lib/shared/messages/multimedia-message-spec.js
+++ b/lib/shared/messages/multimedia-message-spec.js
@@ -1,380 +1,382 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   contentStringForMediaArray,
   multimediaMessagePreview,
   shimUploadURI,
 } from '../../media/media-utils';
 import type { PlatformDetails } from '../../types/device-types';
 import type { Media, Video, Image } from '../../types/media-types';
 import {
   messageTypes,
   assertMessageType,
   isMediaMessageType,
 } from '../../types/message-types';
 import type {
   MessageInfo,
   RawMessageInfo,
   RawMultimediaMessageInfo,
   MultimediaMessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ImagesMessageData,
   RawImagesMessageInfo,
   ImagesMessageInfo,
 } from '../../types/messages/images';
 import type {
   MediaMessageData,
   MediaMessageInfo,
   RawMediaMessageInfo,
 } from '../../types/messages/media';
 import { getMediaMessageServerDBContentsFromMedia } from '../../types/messages/media';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   translateClientDBMediaInfosToMedia,
   translateClientDBMediaInfoToImage,
 } from '../../utils/message-ops-utils';
 import {
   createMediaMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { threadIsGroupChat } from '../thread-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  RawMessageInfoFromServerDBRowParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type RawMessageInfoFromServerDBRowParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const multimediaMessageSpec: MessageSpec<
   MediaMessageData | ImagesMessageData,
   RawMediaMessageInfo | RawImagesMessageInfo,
   MediaMessageInfo | ImagesMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data:
       | MediaMessageData
       | ImagesMessageData
       | RawMediaMessageInfo
       | RawImagesMessageInfo,
   ): string {
     if (data.type === messageTypes.MULTIMEDIA) {
       return JSON.stringify(
         getMediaMessageServerDBContentsFromMedia(data.media),
       );
     }
     const mediaIDs = data.media.map(media => parseInt(media.id, 10));
     return JSON.stringify(mediaIDs);
   },
 
   messageContentForClientDB(
     data: RawMediaMessageInfo | RawImagesMessageInfo,
   ): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawImagesMessageInfo | RawMediaMessageInfo {
     const messageType = assertMessageType(parseInt(clientDBMessageInfo.type));
     invariant(
       isMediaMessageType(messageType),
       'message must be of type IMAGES or MULTIMEDIA',
     );
     invariant(
       clientDBMessageInfo.media_infos !== null &&
         clientDBMessageInfo.media_infos !== undefined,
       `media_infos must be defined`,
     );
 
     const rawMessageInfo: RawImagesMessageInfo | RawMediaMessageInfo =
       messageType === messageTypes.IMAGES
         ? {
             type: messageTypes.IMAGES,
             threadID: clientDBMessageInfo.thread,
             creatorID: clientDBMessageInfo.user,
             time: parseInt(clientDBMessageInfo.time),
             media:
               clientDBMessageInfo.media_infos?.map(
                 translateClientDBMediaInfoToImage,
               ) ?? [],
           }
         : {
             type: messageTypes.MULTIMEDIA,
             threadID: clientDBMessageInfo.thread,
             creatorID: clientDBMessageInfo.user,
             time: parseInt(clientDBMessageInfo.time),
             media: translateClientDBMediaInfosToMedia(clientDBMessageInfo),
           };
 
     if (clientDBMessageInfo.local_id) {
       rawMessageInfo.localID = clientDBMessageInfo.local_id;
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
       rawMessageInfo.id = clientDBMessageInfo.id;
     }
     return rawMessageInfo;
   },
 
   messageTitle({
     messageInfo,
     viewerContext,
   }: MessageTitleParam<MediaMessageInfo | ImagesMessageInfo>) {
     let validMessageInfo: MultimediaMessageInfo = (messageInfo: MultimediaMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     const creator = stringForUser(validMessageInfo.creator);
     const preview = multimediaMessagePreview(validMessageInfo);
     return `${creator} ${preview}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawMediaMessageInfo | RawImagesMessageInfo {
     const { localID, media } = params;
     invariant(media, 'Media should be provided');
     return createMediaMessageInfo({
       threadID: row.threadID.toString(),
       creatorID: row.creatorID.toString(),
       media,
       id: row.id.toString(),
       localID,
       time: row.time,
     });
   },
 
   createMessageInfo(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
     creator: RelativeUserInfo,
   ): ?(MediaMessageInfo | ImagesMessageInfo) {
     if (rawMessageInfo.type === messageTypes.IMAGES) {
       const messageInfo: ImagesMessageInfo = {
         type: messageTypes.IMAGES,
         threadID: rawMessageInfo.threadID,
         creator,
         time: rawMessageInfo.time,
         media: rawMessageInfo.media,
       };
       if (rawMessageInfo.id) {
         messageInfo.id = rawMessageInfo.id;
       }
       if (rawMessageInfo.localID) {
         messageInfo.localID = rawMessageInfo.localID;
       }
       return messageInfo;
     } else if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       const messageInfo: MediaMessageInfo = {
         type: messageTypes.MULTIMEDIA,
         threadID: rawMessageInfo.threadID,
         creator,
         time: rawMessageInfo.time,
         media: rawMessageInfo.media,
       };
       if (rawMessageInfo.id) {
         messageInfo.id = rawMessageInfo.id;
       }
       if (rawMessageInfo.localID) {
         messageInfo.localID = rawMessageInfo.localID;
       }
       return messageInfo;
     }
   },
 
   rawMessageInfoFromMessageData(
     messageData: MediaMessageData | ImagesMessageData,
     id: ?string,
   ): RawMediaMessageInfo | RawImagesMessageInfo {
     if (messageData.type === messageTypes.IMAGES && id) {
       return ({ ...messageData, id }: RawImagesMessageInfo);
     } else if (messageData.type === messageTypes.IMAGES) {
       return ({ ...messageData }: RawImagesMessageInfo);
     } else if (id) {
       return ({ ...messageData, id }: RawMediaMessageInfo);
     } else {
       return ({ ...messageData }: RawMediaMessageInfo);
     }
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawMediaMessageInfo | RawImagesMessageInfo | RawUnsupportedMessageInfo {
     if (rawMessageInfo.type === messageTypes.IMAGES) {
       const shimmedRawMessageInfo = shimMediaMessageInfo(
         rawMessageInfo,
         platformDetails,
       );
       return shimmedRawMessageInfo;
     } else {
       const shimmedRawMessageInfo = shimMediaMessageInfo(
         rawMessageInfo,
         platformDetails,
       );
       // TODO figure out first native codeVersion supporting video playback
       if (hasMinCodeVersion(platformDetails, 158)) {
         return shimmedRawMessageInfo;
       }
       const { id } = shimmedRawMessageInfo;
       invariant(id !== null && id !== undefined, 'id should be set on server');
       return {
         type: messageTypes.UNSUPPORTED,
         id,
         threadID: shimmedRawMessageInfo.threadID,
         creatorID: shimmedRawMessageInfo.creatorID,
         time: shimmedRawMessageInfo.time,
         robotext: multimediaMessagePreview(shimmedRawMessageInfo),
         unsupportedMessageInfo: shimmedRawMessageInfo,
       };
     }
   },
 
   unshimMessageInfo(
     unwrapped: RawMediaMessageInfo | RawImagesMessageInfo,
     messageInfo: RawMessageInfo,
   ): ?RawMessageInfo {
     if (unwrapped.type === messageTypes.IMAGES) {
       return {
         ...unwrapped,
         media: unwrapped.media.map(media => {
           if (media.dimensions) {
             return media;
           }
           const dimensions = preDimensionUploads[media.id];
           invariant(
             dimensions,
             'only four photos were uploaded before dimensions were calculated, ' +
               `and ${media.id} was not one of them`,
           );
           return { ...media, dimensions };
         }),
       };
     } else if (unwrapped.type === messageTypes.MULTIMEDIA) {
       for (const { type } of unwrapped.media) {
         if (type !== 'photo' && type !== 'video') {
           return messageInfo;
         }
       }
     }
     return undefined;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const media = [];
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.IMAGES ||
           messageInfo.type === messageTypes.MULTIMEDIA,
         'messageInfo should be multimedia type!',
       );
       for (const singleMedia of messageInfo.media) {
         media.push(singleMedia);
       }
     }
     const contentString = contentStringForMediaArray(media);
     const userString = stringForUser(messageInfos[0].creator);
 
     let body, merged;
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       body = `sent you ${contentString}`;
       merged = body;
     } else {
       body = `sent ${contentString}`;
       const threadName = params.notifThreadName(threadInfo);
       merged = `${body} to ${threadName}`;
     }
     merged = `${userString} ${merged}`;
 
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix: userString,
     };
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
   ): string {
     // We use the legacy constant here to collapse both types into one
     return joinResult(
       messageTypes.IMAGES,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
+
   includedInRepliesCount: true,
 });
 
 function shimMediaMessageInfo(
   rawMessageInfo: RawMultimediaMessageInfo,
   platformDetails: ?PlatformDetails,
 ): RawMultimediaMessageInfo {
   if (rawMessageInfo.type === messageTypes.IMAGES) {
     let uriChanged = false;
     const newMedia: Image[] = [];
     for (const singleMedia of rawMessageInfo.media) {
       const shimmedURI = shimUploadURI(singleMedia.uri, platformDetails);
       if (shimmedURI === singleMedia.uri) {
         newMedia.push(singleMedia);
       } else {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Image));
         uriChanged = true;
       }
     }
     if (!uriChanged) {
       return rawMessageInfo;
     }
     return ({
       ...rawMessageInfo,
       media: newMedia,
     }: RawImagesMessageInfo);
   } else {
     let uriChanged = false;
     const newMedia: Media[] = [];
     for (const singleMedia of rawMessageInfo.media) {
       const shimmedURI = shimUploadURI(singleMedia.uri, platformDetails);
       if (shimmedURI === singleMedia.uri) {
         newMedia.push(singleMedia);
       } else if (singleMedia.type === 'photo') {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Image));
         uriChanged = true;
       } else {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Video));
         uriChanged = true;
       }
     }
     if (!uriChanged) {
       return rawMessageInfo;
     }
     return ({
       ...rawMessageInfo,
       media: newMedia,
     }: RawMediaMessageInfo);
   }
 }
 
 // Four photos were uploaded before dimensions were calculated server-side,
 // and delivered to clients without dimensions in the MultimediaMessageInfo.
 const preDimensionUploads = {
   '156642': { width: 1440, height: 1080 },
   '156649': { width: 720, height: 803 },
   '156794': { width: 720, height: 803 },
   '156877': { width: 574, height: 454 },
 };
diff --git a/lib/shared/messages/reaction-message-spec.js b/lib/shared/messages/reaction-message-spec.js
index ed40bacfe..25977715e 100644
--- a/lib/shared/messages/reaction-message-spec.js
+++ b/lib/shared/messages/reaction-message-spec.js
@@ -1,222 +1,225 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import {
   assertMessageType,
   messageTypes,
   type MessageInfo,
   type ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ReactionMessageData,
   RawReactionMessageInfo,
   ReactionMessageInfo,
 } from '../../types/messages/reaction';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { removeCreatorAsViewer } from '../message-utils';
 import { threadIsGroupChat } from '../thread-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
-  GeneratesNotifsParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
+  type GeneratesNotifsParams,
 } from './message-spec';
 import { assertSingleMessageInfo, joinResult } from './utils';
 
 export const reactionMessageSpec: MessageSpec<
   ReactionMessageData,
   RawReactionMessageInfo,
   ReactionMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ReactionMessageData | RawReactionMessageInfo,
   ): string {
     return JSON.stringify({
       reaction: data.reaction,
       action: data.action,
     });
   },
 
   messageContentForClientDB(data: RawReactionMessageInfo): string {
     return JSON.stringify({
       targetMessageID: data.targetMessageID,
       reaction: data.reaction,
       action: data.action,
     });
   },
 
   messageTitle({
     messageInfo,
     viewerContext,
   }: MessageTitleParam<ReactionMessageInfo>) {
     let validMessageInfo: ReactionMessageInfo = (messageInfo: ReactionMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
 
     const creator = stringForUser(validMessageInfo.creator);
     const preview =
       validMessageInfo.action === 'add_reaction'
         ? 'liked a message'
         : 'unliked a message';
     return `${creator} ${preview}`;
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawReactionMessageInfo {
     invariant(
       row.targetMessageID !== null && row.targetMessageID !== undefined,
       'targetMessageID should be set',
     );
 
     const content = JSON.parse(row.content);
 
     return {
       type: messageTypes.REACTION,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       targetMessageID: row.targetMessageID.toString(),
       reaction: content.reaction,
       action: content.action,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawReactionMessageInfo {
     const messageType = assertMessageType(parseInt(clientDBMessageInfo.type));
     invariant(
       messageType === messageTypes.REACTION,
       'message must be of type REACTION',
     );
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
 
     const rawReactionMessageInfo: RawReactionMessageInfo = {
       type: messageTypes.REACTION,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       targetMessageID: content.targetMessageID,
       reaction: content.reaction,
       action: content.action,
     };
 
     return rawReactionMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawReactionMessageInfo,
     creator: RelativeUserInfo,
   ): ReactionMessageInfo {
     return {
       type: messageTypes.REACTION,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       targetMessageID: rawMessageInfo.targetMessageID,
       reaction: rawMessageInfo.reaction,
       action: rawMessageInfo.action,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ReactionMessageData,
     id: ?string,
   ): RawReactionMessageInfo {
     invariant(id, 'RawReactionMessageInfo needs id');
     return { ...messageData, id };
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawReactionMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawReactionMessageInfo | RawUnsupportedMessageInfo {
     if (hasMinCodeVersion(platformDetails, 167)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
 
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'liked a message',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(unwrapped: RawReactionMessageInfo): RawReactionMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.REACTION,
       'messageInfo should be reaction type',
     );
 
     const userString = stringForUser(messageInfo.creator);
     const body =
       messageInfo.action === 'add_reaction'
         ? 'liked your message'
         : 'unliked your message';
 
     let merged;
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       merged = `${userString} ${body}`;
     } else {
       const threadName = params.notifThreadName(threadInfo);
       merged = `${userString} ${body} in ${threadName}`;
     }
 
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix: userString,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawReactionMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.targetMessageID,
     );
   },
 
   generatesNotifs: async (
     rawMessageInfo: RawReactionMessageInfo,
     params: GeneratesNotifsParams,
   ) => {
     const { notifTargetUserID, fetchMessageInfoByID } = params;
     const targetMessageInfo = await fetchMessageInfoByID(
       rawMessageInfo.targetMessageID,
     );
-    return targetMessageInfo?.creatorID === notifTargetUserID;
+    return targetMessageInfo?.creatorID === notifTargetUserID
+      ? pushTypes.NOTIF
+      : undefined;
   },
 });
diff --git a/lib/shared/messages/remove-members-message-spec.js b/lib/shared/messages/remove-members-message-spec.js
index c066e03ba..cbaa32e79 100644
--- a/lib/shared/messages/remove-members-message-spec.js
+++ b/lib/shared/messages/remove-members-message-spec.js
@@ -1,185 +1,185 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageData,
   RemoveMembersMessageInfo,
 } from '../../types/messages/remove-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { values } from '../../utils/objects';
 import {
   robotextForMessageInfo,
   robotextToRawString,
   removeCreatorAsViewer,
 } from '../message-utils';
 import type {
   CreateMessageInfoParams,
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
   RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const removeMembersMessageSpec: MessageSpec<
   RemoveMembersMessageData,
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: RemoveMembersMessageData | RawRemoveMembersMessageInfo,
   ): string {
     return JSON.stringify(data.removedUserIDs);
   },
 
   messageContentForClientDB(data: RawRemoveMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<RemoveMembersMessageInfo>) {
     let validMessageInfo: RemoveMembersMessageInfo = (messageInfo: RemoveMembersMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         removedMembers: validMessageInfo.removedMembers.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawRemoveMembersMessageInfo {
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       removedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawRemoveMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawRemoveMembersMessageInfo: RawRemoveMembersMessageInfo = {
       type: messageTypes.REMOVE_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       removedUserIDs: JSON.parse(content),
     };
     return rawRemoveMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawRemoveMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): RemoveMembersMessageInfo {
     const removedMembers = params.createRelativeUserInfos(
       rawMessageInfo.removedUserIDs,
     );
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       removedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: RemoveMembersMessageData,
     id: ?string,
   ): RawRemoveMembersMessageInfo {
     invariant(id, 'RawRemoveMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: RemoveMembersMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     const users = messageInfo.removedMembers;
     invariant(users.length !== 0, 'removed who??');
     const removedUsersString = params.robotextForUsers(users);
     return `${creator} removed ${removedUsersString}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const removedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.REMOVE_MEMBERS,
         'messageInfo should be messageTypes.REMOVE_MEMBERS!',
       );
       for (const member of messageInfo.removedMembers) {
         removedMembersObject[member.id] = member;
       }
     }
     const removedMembers = values(removedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.REMOVE_MEMBERS,
       'messageInfo should be messageTypes.REMOVE_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, removedMembers };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawRemoveMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
-  generatesNotifs: async () => false,
+  generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawRemoveMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.removedUserIDs;
   },
 });
diff --git a/lib/shared/messages/restore-entry-message-spec.js b/lib/shared/messages/restore-entry-message-spec.js
index 15b36e7f2..4fff5c7eb 100644
--- a/lib/shared/messages/restore-entry-message-spec.js
+++ b/lib/shared/messages/restore-entry-message-spec.js
@@ -1,157 +1,158 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawRestoreEntryMessageInfo,
   RestoreEntryMessageData,
   RestoreEntryMessageInfo,
 } from '../../types/messages/restore-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  MessageSpec,
-  MessageTitleParam,
-  NotificationTextsParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+  type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const restoreEntryMessageSpec: MessageSpec<
   RestoreEntryMessageData,
   RawRestoreEntryMessageInfo,
   RestoreEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: RestoreEntryMessageData | RawRestoreEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawRestoreEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<RestoreEntryMessageInfo>) {
     let validMessageInfo: RestoreEntryMessageInfo = (messageInfo: RestoreEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawRestoreEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.RESTORE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawRestoreEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawRestoreEntryMessageInfo: RawRestoreEntryMessageInfo = {
       type: messageTypes.RESTORE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawRestoreEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawRestoreEntryMessageInfo,
     creator: RelativeUserInfo,
   ): RestoreEntryMessageInfo {
     return {
       type: messageTypes.RESTORE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: RestoreEntryMessageData,
     id: ?string,
   ): RawRestoreEntryMessageInfo {
     invariant(id, 'RawRestoreEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: RestoreEntryMessageInfo, creator: string): string {
     const date = prettyDate(messageInfo.date);
     return (
       `${creator} restored an event scheduled for ${date}: ` +
       `"${encodeURI(messageInfo.text)}"`
     );
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.RESTORE_ENTRY,
       'messageInfo should be messageTypes.RESTORE_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `restored an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/sidebar-source-message-spec.js b/lib/shared/messages/sidebar-source-message-spec.js
index 82e2b86d9..0d6ee9b08 100644
--- a/lib/shared/messages/sidebar-source-message-spec.js
+++ b/lib/shared/messages/sidebar-source-message-spec.js
@@ -1,183 +1,183 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import type {
   MessageInfo,
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageData,
   SidebarSourceMessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import { messageTypes } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { hasMinCodeVersion } from '../version-utils';
 import type {
   CreateMessageInfoParams,
   MessageSpec,
   NotificationTextsParams,
   RawMessageInfoFromServerDBRowParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const sidebarSourceMessageSpec: MessageSpec<
   SidebarSourceMessageData,
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: SidebarSourceMessageData | RawSidebarSourceMessageInfo,
   ): string {
     const sourceMessageID = data.sourceMessage?.id;
     invariant(sourceMessageID, 'Source message id should be set');
     return JSON.stringify({
       sourceMessageID,
     });
   },
 
   messageContentForClientDB(data: RawSidebarSourceMessageInfo): string {
     invariant(
       data.sourceMessage && data.sourceMessage.id,
       'sourceMessage and sourceMessage.id should be defined',
     );
     return JSON.stringify(data.sourceMessage);
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawSidebarSourceMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const sourceMessage = JSON.parse(clientDBMessageInfo.content);
     const rawSidebarSourceMessageInfo: RawSidebarSourceMessageInfo = {
       type: messageTypes.SIDEBAR_SOURCE,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessage,
     };
     return rawSidebarSourceMessageInfo;
   },
 
   messageTitle() {
     invariant(false, 'Cannot call messageTitle on sidebarSourceMessageSpec');
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawSidebarSourceMessageInfo {
     const { derivedMessages } = params;
     invariant(derivedMessages, 'Derived messages should be provided');
 
     const content = JSON.parse(row.content);
     const sourceMessage = derivedMessages.get(content.sourceMessageID);
     if (!sourceMessage) {
       console.warn(
         `Message with id ${row.id} has a derived message ` +
           `${content.sourceMessageID} which is not present in the database`,
       );
     }
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessage,
     };
   },
 
   createMessageInfo(
     rawMessageInfo: RawSidebarSourceMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?SidebarSourceMessageInfo {
     if (!rawMessageInfo.sourceMessage) {
       return null;
     }
     const sourceMessage = params.createMessageInfoFromRaw(
       rawMessageInfo.sourceMessage,
     );
     invariant(
       sourceMessage &&
         sourceMessage.type !== messageTypes.SIDEBAR_SOURCE &&
         sourceMessage.type !== messageTypes.REACTION,
       'Sidebars can not be created from SIDEBAR SOURCE OR REACTION',
     );
 
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessage,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: SidebarSourceMessageData,
     id: ?string,
   ): RawSidebarSourceMessageInfo {
     invariant(id, 'RawSidebarSourceMessageInfo needs id');
     return { ...messageData, id };
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawSidebarSourceMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawSidebarSourceMessageInfo | RawUnsupportedMessageInfo {
     // TODO determine min code version
     if (
       hasMinCodeVersion(platformDetails, 75) &&
       rawMessageInfo.sourceMessage
     ) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'first message in thread',
       dontPrefixCreator: true,
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawSidebarSourceMessageInfo,
   ): RawSidebarSourceMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.SIDEBAR_SOURCE,
       'messageInfo should be messageTypes.SIDEBAR_SOURCE!',
     );
     const sourceMessageInfo = messageInfo.sourceMessage;
     return params.notificationTexts([sourceMessageInfo], threadInfo);
   },
 
-  generatesNotifs: async () => false,
+  generatesNotifs: async () => undefined,
 
   startsThread: true,
 });
diff --git a/lib/shared/messages/text-message-spec.js b/lib/shared/messages/text-message-spec.js
index da750f641..75e305ef3 100644
--- a/lib/shared/messages/text-message-spec.js
+++ b/lib/shared/messages/text-message-spec.js
@@ -1,200 +1,202 @@
 // @flow
 
 import invariant from 'invariant';
 import * as SimpleMarkdown from 'simple-markdown';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawTextMessageInfo,
   TextMessageData,
   TextMessageInfo,
 } from '../../types/messages/text';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   type ASTNode,
   type SingleASTNode,
   stripSpoilersFromNotifications,
   stripSpoilersFromMarkdownAST,
 } from '../markdown';
 import { threadIsGroupChat } from '../thread-utils';
 import { stringForUser } from '../user-utils';
-import type {
-  MessageSpec,
-  NotificationTextsParams,
-  RawMessageInfoFromServerDBRowParams,
+import {
+  pushTypes,
+  type MessageSpec,
+  type NotificationTextsParams,
+  type RawMessageInfoFromServerDBRowParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 /**
  * most of the markdown leaves contain `content` field
  * (it is an array or a string) apart from lists,
  * which have `items` field (that holds an array)
  */
 const rawTextFromMarkdownAST = (node: ASTNode): string => {
   if (Array.isArray(node)) {
     return node.map(rawTextFromMarkdownAST).join('');
   }
   const { content, items } = node;
   if (content && typeof content === 'string') {
     return content;
   } else if (items) {
     return rawTextFromMarkdownAST(items);
   } else if (content) {
     return rawTextFromMarkdownAST(content);
   }
   return '';
 };
 
 const getFirstNonQuotedRawLine = (
   nodes: $ReadOnlyArray<SingleASTNode>,
 ): string => {
   let result = 'message';
   for (const node of nodes) {
     if (node.type === 'blockQuote') {
       result = 'quoted message';
     } else {
       const rawText = rawTextFromMarkdownAST(node);
       if (!rawText || !rawText.replace(/\s/g, '')) {
         // handles the case of an empty(or containing only white spaces)
         // new line that usually occurs between a quote and the rest
         // of the message(we don't want it as a title, thus continue)
         continue;
       }
       return rawText;
     }
   }
   return result;
 };
 
 export const textMessageSpec: MessageSpec<
   TextMessageData,
   RawTextMessageInfo,
   TextMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: TextMessageData | RawTextMessageInfo,
   ): string {
     return data.text;
   },
 
   messageContentForClientDB(data: RawTextMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({ messageInfo, markdownRules }) {
     const { text } = messageInfo;
     const parser = SimpleMarkdown.parserFor(markdownRules);
     const ast = stripSpoilersFromMarkdownAST(
       parser(text, { disableAutoBlockNewlines: true }),
     );
     return getFirstNonQuotedRawLine(ast).trim();
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawTextMessageInfo {
     const rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       text: row.content,
     };
     if (params.localID) {
       rawTextMessageInfo.localID = params.localID;
     }
     return rawTextMessageInfo;
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawTextMessageInfo {
     const rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       text: clientDBMessageInfo.content ?? '',
     };
     if (clientDBMessageInfo.local_id) {
       rawTextMessageInfo.localID = clientDBMessageInfo.local_id;
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
       rawTextMessageInfo.id = clientDBMessageInfo.id;
     }
     return rawTextMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawTextMessageInfo,
     creator: RelativeUserInfo,
   ): TextMessageInfo {
     const messageInfo: TextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       text: rawMessageInfo.text,
     };
     if (rawMessageInfo.id) {
       messageInfo.id = rawMessageInfo.id;
     }
     if (rawMessageInfo.localID) {
       messageInfo.localID = rawMessageInfo.localID;
     }
     return messageInfo;
   },
 
   rawMessageInfoFromMessageData(
     messageData: TextMessageData,
     id: ?string,
   ): RawTextMessageInfo {
     if (id) {
       return { ...messageData, id };
     } else {
       return { ...messageData };
     }
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     const notificationTextWithoutSpoilers = stripSpoilersFromNotifications(
       messageInfo.text,
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       return {
         merged: `${threadInfo.uiName}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
       };
     } else {
       const userString = stringForUser(messageInfo.creator);
       const threadName = params.notifThreadName(threadInfo);
       return {
         merged: `${userString} to ${threadName}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
         prefix: `${userString}:`,
       };
     }
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
+
   includedInRepliesCount: true,
 });
diff --git a/lib/shared/messages/unsupported-message-spec.js b/lib/shared/messages/unsupported-message-spec.js
index 2fcb8233c..9bab9401f 100644
--- a/lib/shared/messages/unsupported-message-spec.js
+++ b/lib/shared/messages/unsupported-message-spec.js
@@ -1,94 +1,98 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   messageTypes,
   type ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawUnsupportedMessageInfo,
   UnsupportedMessageInfo,
 } from '../../types/messages/unsupported';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
-import type { MessageSpec, MessageTitleParam } from './message-spec';
+import {
+  pushTypes,
+  type MessageSpec,
+  type MessageTitleParam,
+} from './message-spec';
 
 export const unsupportedMessageSpec: MessageSpec<
   null,
   RawUnsupportedMessageInfo,
   UnsupportedMessageInfo,
 > = Object.freeze({
   messageContentForClientDB(data: RawUnsupportedMessageInfo): string {
     return JSON.stringify({
       robotext: data.robotext,
       dontPrefixCreator: data.dontPrefixCreator,
       unsupportedMessageInfo: data.unsupportedMessageInfo,
     });
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawUnsupportedMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawUnsupportedMessageInfo: RawUnsupportedMessageInfo = {
       type: messageTypes.UNSUPPORTED,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       robotext: content.robotext,
       dontPrefixCreator: content.dontPrefixCreator,
       unsupportedMessageInfo: content.unsupportedMessageInfo,
     };
     return rawUnsupportedMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawUnsupportedMessageInfo,
     creator: RelativeUserInfo,
   ): UnsupportedMessageInfo {
     return {
       type: messageTypes.UNSUPPORTED,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       robotext: rawMessageInfo.robotext,
       dontPrefixCreator: rawMessageInfo.dontPrefixCreator,
       unsupportedMessageInfo: rawMessageInfo.unsupportedMessageInfo,
     };
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<UnsupportedMessageInfo>) {
     let validMessageInfo: UnsupportedMessageInfo = (messageInfo: UnsupportedMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   robotext(messageInfo: UnsupportedMessageInfo, creator: string): string {
     if (messageInfo.dontPrefixCreator) {
       return messageInfo.robotext;
     }
     return `${creator} ${messageInfo.robotext}`;
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/update-relationship-message-spec.js b/lib/shared/messages/update-relationship-message-spec.js
index 61c066527..0b4501a96 100644
--- a/lib/shared/messages/update-relationship-message-spec.js
+++ b/lib/shared/messages/update-relationship-message-spec.js
@@ -1,201 +1,202 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type {
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageData,
   UpdateRelationshipMessageInfo,
 } from '../../types/messages/update-relationship';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  MessageTitleParam,
-  RobotextParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type MessageTitleParam,
+  type RobotextParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const updateRelationshipMessageSpec: MessageSpec<
   UpdateRelationshipMessageData,
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: UpdateRelationshipMessageData | RawUpdateRelationshipMessageInfo,
   ): string {
     return JSON.stringify({
       operation: data.operation,
       targetID: data.targetID,
     });
   },
 
   messageContentForClientDB(data: RawUpdateRelationshipMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<UpdateRelationshipMessageInfo>) {
     let validMessageInfo: UpdateRelationshipMessageInfo = (messageInfo: UpdateRelationshipMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         target: { ...validMessageInfo.target, isViewer: false },
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawUpdateRelationshipMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       targetID: content.targetID,
       operation: content.operation,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawUpdateRelationshipMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawUpdateRelationshipMessageInfo: RawUpdateRelationshipMessageInfo = {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       targetID: content.targetID,
       operation: content.operation,
     };
     return rawUpdateRelationshipMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawUpdateRelationshipMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?UpdateRelationshipMessageInfo {
     const target = params.createRelativeUserInfos([rawMessageInfo.targetID])[0];
     if (!target) {
       return null;
     }
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       target,
       time: rawMessageInfo.time,
       operation: rawMessageInfo.operation,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: UpdateRelationshipMessageData,
     id: ?string,
   ): RawUpdateRelationshipMessageInfo {
     invariant(id, 'RawUpdateRelationshipMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: UpdateRelationshipMessageInfo,
     creator: string,
     params: RobotextParams,
   ): string {
     const target = params.robotextForUser(messageInfo.target);
     if (messageInfo.operation === 'request_sent') {
       return `${creator} sent ${target} a friend request`;
     } else if (messageInfo.operation === 'request_accepted') {
       const targetPossessive = messageInfo.target.isViewer
         ? 'your'
         : `${target}'s`;
       return `${creator} accepted ${targetPossessive} friend request`;
     }
     invariant(
       false,
       `Invalid operation ${messageInfo.operation} ` +
         `of message with type ${messageInfo.type}`,
     );
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawUpdateRelationshipMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawUpdateRelationshipMessageInfo | RawUnsupportedMessageInfo {
     if (hasMinCodeVersion(platformDetails, 71)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'performed a relationship action',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawUpdateRelationshipMessageInfo,
   ): RawUpdateRelationshipMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const body =
       messageInfo.operation === 'request_sent'
         ? 'sent you a friend request'
         : 'accepted your friend request';
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
-  generatesNotifs: async () => true,
+  generatesNotifs: async () => pushTypes.NOTIF,
 });