diff --git a/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js b/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
index 300e25a37..b7831ffeb 100644
--- a/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
+++ b/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
@@ -1,104 +1,111 @@
 // @flow
 
 import uuid from 'uuid';
 
 import type { AddMembersResult } from './add-members-spec.js';
 import { createThickRawThreadInfo } from './create-thread-spec.js';
 import type { DMOperationSpec } from './dm-op-spec.js';
 import type { DMAddViewerToThreadMembersOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import { messageTruncationStatus } from '../../types/message-types.js';
 import type { AddMembersMessageData } from '../../types/messages/add-members.js';
+import { joinThreadSubscription } from '../../types/subscription-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
 
 function createAddViewerToThreadMembersMessageDataFromDMOp(
   dmOperation: DMAddViewerToThreadMembersOperation,
 ): AddMembersMessageData {
   const { editorID, time, addedUserIDs, existingThreadDetails } = dmOperation;
   return {
     type: messageTypes.ADD_MEMBERS,
     threadID: existingThreadDetails.threadID,
     creatorID: editorID,
     time,
     addedUserIDs: [...addedUserIDs],
   };
 }
 
 function createAddViewerToThreadMembersResults(
   dmOperation: DMAddViewerToThreadMembersOperation,
   viewerID: string,
 ): AddMembersResult {
   const { time, messageID, addedUserIDs, existingThreadDetails } = dmOperation;
   const messageData =
     createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
 
   const rawMessageInfos = [
     rawMessageInfoFromMessageData(messageData, messageID),
   ];
 
   const resultThreadInfo = createThickRawThreadInfo(
     {
       ...existingThreadDetails,
-      allMemberIDs: [...existingThreadDetails.allMemberIDs, ...addedUserIDs],
+      allMemberIDsWithSubscriptions: [
+        ...existingThreadDetails.allMemberIDsWithSubscriptions,
+        ...addedUserIDs.map(id => ({
+          id,
+          subscription: joinThreadSubscription,
+        })),
+      ],
     },
     viewerID,
   );
   const updateInfos = [
     {
       type: updateTypes.JOIN_THREAD,
       id: uuid.v4(),
       time,
       threadInfo: resultThreadInfo,
       rawMessageInfos,
       truncationStatus: messageTruncationStatus.EXHAUSTIVE,
       rawEntryInfos: [],
     },
   ];
   return {
     rawMessageInfos: [],
     updateInfos,
     threadInfo: resultThreadInfo,
   };
 }
 
 const addViewerToThreadMembersSpec: DMOperationSpec<DMAddViewerToThreadMembersOperation> =
   Object.freeze({
     notificationsCreationData: async (
       dmOperation: DMAddViewerToThreadMembersOperation,
     ) => {
       const messageData =
         createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
       return { messageDatas: [messageData] };
     },
     processDMOperation: async (
       dmOperation: DMAddViewerToThreadMembersOperation,
       viewerID: string,
     ) => {
       const { rawMessageInfos, updateInfos } =
         createAddViewerToThreadMembersResults(dmOperation, viewerID);
       return { rawMessageInfos, updateInfos };
     },
     canBeProcessed(
       dmOperation: DMAddViewerToThreadMembersOperation,
       viewerID: string,
     ) {
       if (dmOperation.addedUserIDs.includes(viewerID)) {
         return { isProcessingPossible: true };
       }
       console.log('Invalid DM operation', dmOperation);
       return {
         isProcessingPossible: false,
         reason: {
           type: 'invalid',
         },
       };
     },
     supportsAutoRetry: true,
   });
 
 export {
   addViewerToThreadMembersSpec,
   createAddViewerToThreadMembersResults,
   createAddViewerToThreadMembersMessageDataFromDMOp,
 };
diff --git a/lib/shared/dm-ops/change-thread-subscription.js b/lib/shared/dm-ops/change-thread-subscription.js
new file mode 100644
index 000000000..a8f87ef43
--- /dev/null
+++ b/lib/shared/dm-ops/change-thread-subscription.js
@@ -0,0 +1,80 @@
+// @flow
+
+import invariant from 'invariant';
+import uuid from 'uuid';
+
+import type {
+  ProcessDMOperationUtilities,
+  DMOperationSpec,
+} from './dm-op-spec.js';
+import type { DMChangeThreadSubscriptionOperation } from '../../types/dm-ops.js';
+import { updateTypes } from '../../types/update-types-enum.js';
+import type { ClientUpdateInfo } from '../../types/update-types.js';
+
+const changeThreadSubscriptionSpec: DMOperationSpec<DMChangeThreadSubscriptionOperation> =
+  Object.freeze({
+    processDMOperation: async (
+      dmOperation: DMChangeThreadSubscriptionOperation,
+      viewerID: string,
+      utilities: ProcessDMOperationUtilities,
+    ) => {
+      const { creatorID, threadID, subscription, time } = dmOperation;
+
+      const threadInfo = utilities.threadInfos[threadID];
+      invariant(threadInfo.thick, 'Thread should be thick');
+
+      const creatorMemberInfo = threadInfo.members.find(
+        member => member.id === creatorID,
+      );
+      invariant(creatorMemberInfo, 'operation creator missing in thread');
+      const updatedCreatorMemberInfo = {
+        ...creatorMemberInfo,
+        subscription,
+      };
+      const otherMemberInfos = threadInfo.members.filter(
+        member => member.id !== creatorID,
+      );
+      const membersUpdate = [...otherMemberInfos, updatedCreatorMemberInfo];
+
+      const threadInfoUpdate = {
+        ...threadInfo,
+        members: membersUpdate,
+      };
+      const updateInfos: Array<ClientUpdateInfo> = [
+        {
+          type: updateTypes.UPDATE_THREAD,
+          id: uuid.v4(),
+          time,
+          threadInfo: threadInfoUpdate,
+        },
+      ];
+
+      return { updateInfos, rawMessageInfos: [] };
+    },
+    canBeProcessed(
+      dmOperation: DMChangeThreadSubscriptionOperation,
+      viewerID: string,
+      utilities: ProcessDMOperationUtilities,
+    ) {
+      const { threadID, creatorID } = dmOperation;
+      if (!utilities.threadInfos[threadID]) {
+        return {
+          isProcessingPossible: false,
+          reason: { type: 'missing_thread', threadID },
+        };
+      }
+
+      if (
+        !utilities.threadInfos[threadID].members.find(
+          memberInfo => memberInfo.id === creatorID,
+        )
+      ) {
+        return { isProcessingPossible: false, reason: { type: 'invalid' } };
+      }
+
+      return { isProcessingPossible: true };
+    },
+    supportsAutoRetry: true,
+  });
+
+export { changeThreadSubscriptionSpec };
diff --git a/lib/shared/dm-ops/create-sidebar-spec.js b/lib/shared/dm-ops/create-sidebar-spec.js
index f9714d70d..f8af1d949 100644
--- a/lib/shared/dm-ops/create-sidebar-spec.js
+++ b/lib/shared/dm-ops/create-sidebar-spec.js
@@ -1,168 +1,173 @@
 // @flow
 
 import uuid from 'uuid';
 
 import { createThickRawThreadInfo } from './create-thread-spec.js';
 import type {
   DMOperationSpec,
   ProcessDMOperationUtilities,
 } from './dm-op-spec.js';
 import type { DMCreateSidebarOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import {
   type RawMessageInfo,
   messageTruncationStatus,
 } from '../../types/message-types.js';
+import { joinThreadSubscription } from '../../types/subscription-types.js';
 import { threadTypes } from '../../types/thread-types-enum.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { generatePendingThreadColor } from '../color-utils.js';
 import {
   isInvalidSidebarSource,
   rawMessageInfoFromMessageData,
 } from '../message-utils.js';
 
 async function createMessageDatasFromDMOperation(
   dmOperation: DMCreateSidebarOperation,
   utilities: ProcessDMOperationUtilities,
   threadColor?: string,
 ) {
   const {
     threadID,
     creatorID,
     time,
     parentThreadID,
     memberIDs,
     sourceMessageID,
   } = dmOperation;
 
   const allMemberIDs = [creatorID, ...memberIDs];
   const color = threadColor ?? generatePendingThreadColor(allMemberIDs);
   const sourceMessage = await utilities.fetchMessage(sourceMessageID);
 
   if (!sourceMessage) {
     throw new Error(
       `could not find sourceMessage ${sourceMessageID}... probably ` +
         'joined thick thread ${parentThreadID} after its creation',
     );
   }
   if (isInvalidSidebarSource(sourceMessage)) {
     throw new Error(
       `sourceMessage ${sourceMessageID} is an invalid sidebar source`,
     );
   }
 
   const sidebarSourceMessageData = {
     type: messageTypes.SIDEBAR_SOURCE,
     threadID,
     creatorID,
     time,
     sourceMessage: sourceMessage,
   };
 
   const createSidebarMessageData = {
     type: messageTypes.CREATE_SIDEBAR,
     threadID,
     creatorID,
     time: time + 1,
     sourceMessageAuthorID: sourceMessage.creatorID,
     initialThreadState: {
       parentThreadID,
       color,
       memberIDs: allMemberIDs,
     },
   };
 
   return {
     sidebarSourceMessageData,
     createSidebarMessageData,
   };
 }
 
 const createSidebarSpec: DMOperationSpec<DMCreateSidebarOperation> =
   Object.freeze({
     notificationsCreationData: async (
       dmOperation: DMCreateSidebarOperation,
       utilities: ProcessDMOperationUtilities,
     ) => {
       const { sidebarSourceMessageData, createSidebarMessageData } =
         await createMessageDatasFromDMOperation(dmOperation, utilities);
       return {
         messageDatas: [sidebarSourceMessageData, createSidebarMessageData],
       };
     },
     processDMOperation: async (
       dmOperation: DMCreateSidebarOperation,
       viewerID: string,
       utilities: ProcessDMOperationUtilities,
     ) => {
       const {
         threadID,
         creatorID,
         time,
         parentThreadID,
         memberIDs,
         sourceMessageID,
         roleID,
         newSidebarSourceMessageID,
         newCreateSidebarMessageID,
       } = dmOperation;
       const allMemberIDs = [creatorID, ...memberIDs];
+      const allMemberIDsWithSubscriptions = allMemberIDs.map(id => ({
+        id,
+        subscription: joinThreadSubscription,
+      }));
 
       const rawThreadInfo = createThickRawThreadInfo(
         {
           threadID,
           threadType: threadTypes.THICK_SIDEBAR,
           creationTime: time,
           parentThreadID,
-          allMemberIDs,
+          allMemberIDsWithSubscriptions,
           roleID,
           unread: creatorID !== viewerID,
           sourceMessageID,
           containingThreadID: parentThreadID,
         },
         viewerID,
       );
 
       const { sidebarSourceMessageData, createSidebarMessageData } =
         await createMessageDatasFromDMOperation(
           dmOperation,
           utilities,
           rawThreadInfo.color,
         );
 
       const sidebarSourceMessageInfo = rawMessageInfoFromMessageData(
         sidebarSourceMessageData,
         newSidebarSourceMessageID,
       );
       const createSidebarMessageInfo = rawMessageInfoFromMessageData(
         createSidebarMessageData,
         newCreateSidebarMessageID,
       );
 
       const rawMessageInfos: Array<RawMessageInfo> = [
         sidebarSourceMessageInfo,
         createSidebarMessageInfo,
       ];
 
       const threadJoinUpdateInfo = {
         type: updateTypes.JOIN_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: rawThreadInfo,
         rawMessageInfos,
         truncationStatus: messageTruncationStatus.EXHAUSTIVE,
         rawEntryInfos: [],
       };
 
       return {
         rawMessageInfos: [], // included in updateInfos below
         updateInfos: [threadJoinUpdateInfo],
       };
     },
     canBeProcessed() {
       return { isProcessingPossible: true };
     },
     supportsAutoRetry: true,
   });
 
 export { createSidebarSpec };
diff --git a/lib/shared/dm-ops/create-thread-spec.js b/lib/shared/dm-ops/create-thread-spec.js
index 7723e5da5..88bc37354 100644
--- a/lib/shared/dm-ops/create-thread-spec.js
+++ b/lib/shared/dm-ops/create-thread-spec.js
@@ -1,209 +1,218 @@
 // @flow
 
 import uuid from 'uuid';
 
 import type { DMOperationSpec } from './dm-op-spec.js';
 import { specialRoles } from '../../permissions/special-roles.js';
 import {
   getAllThreadPermissions,
   makePermissionsBlob,
   getThickThreadRolePermissionsBlob,
 } from '../../permissions/thread-permissions.js';
 import type {
   CreateThickRawThreadInfoInput,
   DMCreateThreadOperation,
 } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import { messageTruncationStatus } from '../../types/message-types.js';
 import {
   type ThickRawThreadInfo,
   type RoleInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../../types/minimally-encoded-thread-permissions-types.js';
 import { joinThreadSubscription } from '../../types/subscription-types.js';
 import type { ThreadPermissionsInfo } from '../../types/thread-permission-types.js';
 import type { ThickThreadType } from '../../types/thread-types-enum.js';
 import type { ThickMemberInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { generatePendingThreadColor } from '../color-utils.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
 
 function createRoleAndPermissionForThickThreads(
   threadType: ThickThreadType,
   threadID: string,
   roleID: string,
 ): { +role: RoleInfo, +membershipPermissions: ThreadPermissionsInfo } {
   const rolePermissions = getThickThreadRolePermissionsBlob(threadType);
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(rolePermissions, null, threadID, threadType),
     threadID,
   );
   const role: RoleInfo = {
     ...minimallyEncodeRoleInfo({
       id: roleID,
       name: 'Members',
       permissions: rolePermissions,
       isDefault: true,
     }),
     specialRole: specialRoles.DEFAULT_ROLE,
   };
   return {
     membershipPermissions,
     role,
   };
 }
 
 type MutableThickRawThreadInfo = { ...ThickRawThreadInfo };
 function createThickRawThreadInfo(
   input: CreateThickRawThreadInfoInput,
   viewerID: string,
 ): MutableThickRawThreadInfo {
   const {
     threadID,
     threadType,
     creationTime,
     parentThreadID,
-    allMemberIDs,
+    allMemberIDsWithSubscriptions,
     roleID,
     unread,
     name,
     avatar,
     description,
     color,
     containingThreadID,
     sourceMessageID,
     repliesCount,
     pinnedCount,
   } = input;
 
-  const threadColor = color ?? generatePendingThreadColor(allMemberIDs);
+  const threadColor =
+    color ??
+    generatePendingThreadColor(
+      allMemberIDsWithSubscriptions.map(({ id }) => id),
+    );
 
   const { membershipPermissions, role } =
     createRoleAndPermissionForThickThreads(threadType, threadID, roleID);
 
   const newThread: MutableThickRawThreadInfo = {
     thick: true,
     minimallyEncoded: true,
     id: threadID,
     type: threadType,
     color: threadColor,
     creationTime,
     parentThreadID,
-    members: allMemberIDs.map(memberID =>
-      minimallyEncodeMemberInfo<ThickMemberInfo>({
-        id: memberID,
-        role: role.id,
-        permissions: membershipPermissions,
-        isSender: memberID === viewerID,
-        subscription: joinThreadSubscription,
-      }),
+    members: allMemberIDsWithSubscriptions.map(
+      ({ id: memberID, subscription }) =>
+        minimallyEncodeMemberInfo<ThickMemberInfo>({
+          id: memberID,
+          role: role.id,
+          permissions: membershipPermissions,
+          isSender: memberID === viewerID,
+          subscription,
+        }),
     ),
     roles: {
       [role.id]: role,
     },
     currentUser: minimallyEncodeThreadCurrentUserInfo({
       role: role.id,
       permissions: membershipPermissions,
       subscription: joinThreadSubscription,
       unread,
     }),
     repliesCount: repliesCount ?? 0,
     name,
     avatar,
     description,
     containingThreadID,
   };
   if (sourceMessageID) {
     newThread.sourceMessageID = sourceMessageID;
   }
   if (pinnedCount) {
     newThread.pinnedCount = pinnedCount;
   }
   return newThread;
 }
 
 function createMessageDataFromDMOperation(
   dmOperation: DMCreateThreadOperation,
 ) {
   const { threadID, creatorID, time, threadType, memberIDs } = dmOperation;
   const allMemberIDs = [creatorID, ...memberIDs];
   const color = generatePendingThreadColor(allMemberIDs);
   return {
     type: messageTypes.CREATE_THREAD,
     threadID,
     creatorID,
     time,
     initialThreadState: {
       type: threadType,
       color,
       memberIDs: allMemberIDs,
     },
   };
 }
 
 const createThreadSpec: DMOperationSpec<DMCreateThreadOperation> =
   Object.freeze({
     notificationsCreationData: async (dmOperation: DMCreateThreadOperation) => {
       const messageData = createMessageDataFromDMOperation(dmOperation);
       return { messageDatas: [messageData] };
     },
     processDMOperation: async (
       dmOperation: DMCreateThreadOperation,
       viewerID: string,
     ) => {
       const {
         threadID,
         creatorID,
         time,
         threadType,
         memberIDs,
         roleID,
         newMessageID,
       } = dmOperation;
       const allMemberIDs = [creatorID, ...memberIDs];
+      const allMemberIDsWithSubscriptions = allMemberIDs.map(id => ({
+        id,
+        subscription: joinThreadSubscription,
+      }));
 
       const rawThreadInfo = createThickRawThreadInfo(
         {
           threadID,
           threadType,
           creationTime: time,
-          allMemberIDs,
+          allMemberIDsWithSubscriptions,
           roleID,
           unread: creatorID !== viewerID,
         },
         viewerID,
       );
 
       const messageData = createMessageDataFromDMOperation(dmOperation);
       const rawMessageInfos = [
         rawMessageInfoFromMessageData(messageData, newMessageID),
       ];
 
       const threadJoinUpdateInfo = {
         type: updateTypes.JOIN_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: rawThreadInfo,
         rawMessageInfos,
         truncationStatus: messageTruncationStatus.EXHAUSTIVE,
         rawEntryInfos: [],
       };
 
       return {
         rawMessageInfos: [], // included in updateInfos below
         updateInfos: [threadJoinUpdateInfo],
       };
     },
     canBeProcessed() {
       return { isProcessingPossible: true };
     },
     supportsAutoRetry: true,
   });
 
 export {
   createThickRawThreadInfo,
   createThreadSpec,
   createRoleAndPermissionForThickThreads,
 };
diff --git a/lib/shared/dm-ops/dm-op-specs.js b/lib/shared/dm-ops/dm-op-specs.js
index e40898dcb..3ee92cfee 100644
--- a/lib/shared/dm-ops/dm-op-specs.js
+++ b/lib/shared/dm-ops/dm-op-specs.js
@@ -1,31 +1,33 @@
 // @flow
 
 import { addMembersSpec } from './add-members-spec.js';
 import { addViewerToThreadMembersSpec } from './add-viewer-to-thread-members-spec.js';
 import { changeThreadSettingsSpec } from './change-thread-settings-spec.js';
+import { changeThreadSubscriptionSpec } from './change-thread-subscription.js';
 import { createSidebarSpec } from './create-sidebar-spec.js';
 import { createThreadSpec } from './create-thread-spec.js';
 import type { DMOperationSpec } from './dm-op-spec.js';
 import { joinThreadSpec } from './join-thread-spec.js';
 import { leaveThreadSpec } from './leave-thread-spec.js';
 import { removeMembersSpec } from './remove-members-spec.js';
 import { sendEditMessageSpec } from './send-edit-message-spec.js';
 import { sendReactionMessageSpec } from './send-reaction-message-spec.js';
 import { sendTextMessageSpec } from './send-text-message-spec.js';
 import { type DMOperationType, dmOperationTypes } from '../../types/dm-ops.js';
 
 export const dmOpSpecs: {
   +[DMOperationType]: DMOperationSpec<any>,
 } = Object.freeze({
   [dmOperationTypes.CREATE_THREAD]: createThreadSpec,
   [dmOperationTypes.CREATE_SIDEBAR]: createSidebarSpec,
   [dmOperationTypes.SEND_TEXT_MESSAGE]: sendTextMessageSpec,
   [dmOperationTypes.SEND_REACTION_MESSAGE]: sendReactionMessageSpec,
   [dmOperationTypes.SEND_EDIT_MESSAGE]: sendEditMessageSpec,
   [dmOperationTypes.ADD_MEMBERS]: addMembersSpec,
   [dmOperationTypes.ADD_VIEWER_TO_THREAD_MEMBERS]: addViewerToThreadMembersSpec,
   [dmOperationTypes.JOIN_THREAD]: joinThreadSpec,
   [dmOperationTypes.LEAVE_THREAD]: leaveThreadSpec,
   [dmOperationTypes.REMOVE_MEMBERS]: removeMembersSpec,
   [dmOperationTypes.CHANGE_THREAD_SETTINGS]: changeThreadSettingsSpec,
+  [dmOperationTypes.CHANGE_THREAD_SUBSCRIPTION]: changeThreadSubscriptionSpec,
 });
diff --git a/lib/shared/dm-ops/dm-op-utils.js b/lib/shared/dm-ops/dm-op-utils.js
index 3617a1905..f6e5d1bc1 100644
--- a/lib/shared/dm-ops/dm-op-utils.js
+++ b/lib/shared/dm-ops/dm-op-utils.js
@@ -1,231 +1,241 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import { dmOpSpecs } from './dm-op-specs.js';
 import { useProcessAndSendDMOperation } from './process-dm-ops.js';
 import type {
   CreateThickRawThreadInfoInput,
   DMAddMembersOperation,
   DMAddViewerToThreadMembersOperation,
   DMOperation,
 } from '../../types/dm-ops.js';
-import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
+import type {
+  ThickRawThreadInfo,
+  ThreadInfo,
+} from '../../types/minimally-encoded-thread-permissions-types.js';
 import type { InboundActionMetadata } from '../../types/redux-types.js';
 import {
   outboundP2PMessageStatuses,
   type OutboundP2PMessage,
 } from '../../types/sqlite-types.js';
 import {
   assertThickThreadType,
   thickThreadTypes,
 } from '../../types/thread-types-enum.js';
 import type { RawThreadInfos } from '../../types/thread-types.js';
 import {
   type DMOperationP2PMessage,
   userActionsP2PMessageTypes,
 } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
 import type { CurrentUserInfo } from '../../types/user-types.js';
 import { getContentSigningKey } from '../../utils/crypto-utils.js';
 import { useSelector } from '../../utils/redux-utils.js';
 
 function generateMessagesToPeers(
   message: DMOperation,
   peers: $ReadOnlyArray<{
     +userID: string,
     +deviceID: string,
   }>,
 ): $ReadOnlyArray<OutboundP2PMessage> {
   const opMessage: DMOperationP2PMessage = {
     type: userActionsP2PMessageTypes.DM_OPERATION,
     op: message,
   };
   const plaintext = JSON.stringify(opMessage);
   const outboundP2PMessages = [];
   for (const peer of peers) {
     const messageToPeer: OutboundP2PMessage = {
       messageID: uuid.v4(),
       deviceID: peer.deviceID,
       userID: peer.userID,
       timestamp: new Date().getTime().toString(),
       plaintext,
       ciphertext: '',
       status: outboundP2PMessageStatuses.persisted,
       supportsAutoRetry: dmOpSpecs[message.type].supportsAutoRetry,
     };
     outboundP2PMessages.push(messageToPeer);
   }
   return outboundP2PMessages;
 }
 
 export const dmOperationSpecificationTypes = Object.freeze({
   OUTBOUND: 'OutboundDMOperationSpecification',
   INBOUND: 'InboundDMOperationSpecification',
 });
 
 // The operation generated on the sending client, causes changes to
 // the state and broadcasting information to peers.
 export type OutboundDMOperationSpecification = {
   +type: 'OutboundDMOperationSpecification',
   +op: DMOperation,
   +recipients:
     | { +type: 'all_peer_devices' | 'self_devices' }
     | { +type: 'some_users', +userIDs: $ReadOnlyArray<string> }
     | { +type: 'all_thread_members', +threadID: string },
   +sendOnly?: boolean,
 };
 
 // The operation received from other peers, causes changes to
 // the state and after processing, sends confirmation to the sender.
 export type InboundDMOperationSpecification = {
   +type: 'InboundDMOperationSpecification',
   +op: DMOperation,
   +metadata: ?InboundActionMetadata,
 };
 
 export type DMOperationSpecification =
   | OutboundDMOperationSpecification
   | InboundDMOperationSpecification;
 
 async function createMessagesToPeersFromDMOp(
   operation: OutboundDMOperationSpecification,
   allPeerUserIDAndDeviceIDs: $ReadOnlyArray<{
     +userID: string,
     +deviceID: string,
   }>,
   currentUserInfo: ?CurrentUserInfo,
   threadInfos: RawThreadInfos,
 ): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
   if (!currentUserInfo?.id) {
     return [];
   }
 
   let peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs;
   if (operation.recipients.type === 'self_devices') {
     peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs.filter(
       peer => peer.userID === currentUserInfo.id,
     );
   } else if (operation.recipients.type === 'some_users') {
     const userIDs = new Set(operation.recipients.userIDs);
     peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs.filter(peer =>
       userIDs.has(peer.userID),
     );
   } else if (operation.recipients.type === 'all_thread_members') {
     const members = threadInfos[operation.recipients.threadID]?.members ?? [];
     const memberIDs = members.map(member => member.id);
 
     const userIDs = new Set(memberIDs);
     peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs.filter(peer =>
       userIDs.has(peer.userID),
     );
   }
 
   const thisDeviceID = await getContentSigningKey();
   const targetPeers = peerUserIDAndDeviceIDs.filter(
     peer => peer.deviceID !== thisDeviceID,
   );
   return generateMessagesToPeers(operation.op, targetPeers);
 }
 
 function getCreateThickRawThreadInfoInputFromThreadInfo(
-  threadInfo: ThreadInfo,
+  threadInfo: ThickRawThreadInfo,
 ): CreateThickRawThreadInfoInput {
   const roleID = Object.keys(threadInfo.roles).pop();
   const thickThreadType = assertThickThreadType(threadInfo.type);
   return {
     threadID: threadInfo.id,
     threadType: thickThreadType,
     creationTime: threadInfo.creationTime,
     parentThreadID: threadInfo.parentThreadID,
-    allMemberIDs: threadInfo.members.map(member => member.id),
+    allMemberIDsWithSubscriptions: threadInfo.members.map(
+      ({ id, subscription }) => ({
+        id,
+        subscription,
+      }),
+    ),
     roleID,
     unread: !!threadInfo.currentUser.unread,
     name: threadInfo.name,
     avatar: threadInfo.avatar,
     description: threadInfo.description,
     color: threadInfo.color,
     containingThreadID: threadInfo.containingThreadID,
     sourceMessageID: threadInfo.sourceMessageID,
     repliesCount: threadInfo.repliesCount,
     pinnedCount: threadInfo.pinnedCount,
   };
 }
 
 function useAddDMThreadMembers(): (
   newMemberIDs: $ReadOnlyArray<string>,
   threadInfo: ThreadInfo,
 ) => Promise<void> {
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const processAndSendDMOperation = useProcessAndSendDMOperation();
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
 
   return React.useCallback(
     async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
+      const rawThreadInfo = threadInfos[threadInfo.id];
+      invariant(rawThreadInfo.thick, 'thread should be thick');
       const existingThreadDetails =
-        getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
+        getCreateThickRawThreadInfoInputFromThreadInfo(rawThreadInfo);
 
       invariant(viewerID, 'viewerID should be set');
       const addViewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
         {
           type: 'add_viewer_to_thread_members',
           existingThreadDetails,
           editorID: viewerID,
           time: Date.now(),
           messageID: uuid.v4(),
           addedUserIDs: newMemberIDs,
         };
       const viewerOperationSpecification: OutboundDMOperationSpecification = {
         type: dmOperationSpecificationTypes.OUTBOUND,
         op: addViewerToThreadMembersOperation,
         recipients: {
           type: 'some_users',
           userIDs: newMemberIDs,
         },
         sendOnly: true,
       };
 
       invariant(viewerID, 'viewerID should be set');
       const addMembersOperation: DMAddMembersOperation = {
         type: 'add_members',
         threadID: threadInfo.id,
         editorID: viewerID,
         time: Date.now(),
         messageID: uuid.v4(),
         addedUserIDs: newMemberIDs,
       };
       const newMemberIDsSet = new Set<string>(newMemberIDs);
       const recipientsThreadID =
         threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
         threadInfo.parentThreadID
           ? threadInfo.parentThreadID
           : threadInfo.id;
 
       const existingMembers =
         threadInfos[recipientsThreadID]?.members
           ?.map(member => member.id)
           ?.filter(memberID => !newMemberIDsSet.has(memberID)) ?? [];
 
       const addMembersOperationSpecification: OutboundDMOperationSpecification =
         {
           type: dmOperationSpecificationTypes.OUTBOUND,
           op: addMembersOperation,
           recipients: {
             type: 'some_users',
             userIDs: existingMembers,
           },
         };
 
       await Promise.all([
         processAndSendDMOperation(viewerOperationSpecification),
         processAndSendDMOperation(addMembersOperationSpecification),
       ]);
     },
     [processAndSendDMOperation, threadInfos, viewerID],
   );
 }
 
 export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };
diff --git a/lib/shared/dm-ops/join-thread-spec.js b/lib/shared/dm-ops/join-thread-spec.js
index 440e523f7..265a1ffd1 100644
--- a/lib/shared/dm-ops/join-thread-spec.js
+++ b/lib/shared/dm-ops/join-thread-spec.js
@@ -1,141 +1,144 @@
 // @flow
 
 import invariant from 'invariant';
 import uuid from 'uuid';
 
 import {
   createRoleAndPermissionForThickThreads,
   createThickRawThreadInfo,
 } from './create-thread-spec.js';
 import type {
   DMOperationSpec,
   ProcessDMOperationUtilities,
 } from './dm-op-spec.js';
 import type { DMJoinThreadOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import {
   messageTruncationStatus,
   type RawMessageInfo,
 } from '../../types/message-types.js';
 import { minimallyEncodeMemberInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
 import { joinThreadSubscription } from '../../types/subscription-types.js';
 import type { ThickMemberInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type { ClientUpdateInfo } from '../../types/update-types.js';
 import { values } from '../../utils/objects.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
 import { roleIsDefaultRole, userIsMember } from '../thread-utils.js';
 
 function createMessageDataFromDMOperation(dmOperation: DMJoinThreadOperation) {
   const { joinerID, time, existingThreadDetails } = dmOperation;
   return {
     type: messageTypes.JOIN_THREAD,
     threadID: existingThreadDetails.threadID,
     creatorID: joinerID,
     time,
   };
 }
 
 const joinThreadSpec: DMOperationSpec<DMJoinThreadOperation> = Object.freeze({
   notificationsCreationData: async (dmOperation: DMJoinThreadOperation) => {
     const messageData = createMessageDataFromDMOperation(dmOperation);
     return { messageDatas: [messageData] };
   },
   processDMOperation: async (
     dmOperation: DMJoinThreadOperation,
     viewerID: string,
     utilities: ProcessDMOperationUtilities,
   ) => {
     const { joinerID, time, messageID, existingThreadDetails } = dmOperation;
 
     const currentThreadInfo =
       utilities.threadInfos[existingThreadDetails.threadID];
 
     const messageData = createMessageDataFromDMOperation(dmOperation);
     const joinThreadMessageInfos = [
       rawMessageInfoFromMessageData(messageData, messageID),
     ];
 
     if (userIsMember(currentThreadInfo, joinerID)) {
       return {
         rawMessageInfos: joinThreadMessageInfos,
         updateInfos: [],
       };
     }
 
     const updateInfos: Array<ClientUpdateInfo> = [];
     const rawMessageInfos: Array<RawMessageInfo> = [];
     if (viewerID === joinerID) {
       const newThreadInfo = createThickRawThreadInfo(
         {
           ...existingThreadDetails,
-          allMemberIDs: [...existingThreadDetails.allMemberIDs, joinerID],
+          allMemberIDsWithSubscriptions: [
+            ...existingThreadDetails.allMemberIDsWithSubscriptions,
+            { id: joinerID, subscription: joinThreadSubscription },
+          ],
         },
         viewerID,
       );
       updateInfos.push({
         type: updateTypes.JOIN_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: newThreadInfo,
         rawMessageInfos: joinThreadMessageInfos,
         truncationStatus: messageTruncationStatus.EXHAUSTIVE,
         rawEntryInfos: [],
       });
     } else {
       invariant(currentThreadInfo.thick, 'Thread should be thick');
 
       rawMessageInfos.push(...joinThreadMessageInfos);
       const defaultRoleID = values(currentThreadInfo.roles).find(role =>
         roleIsDefaultRole(role),
       )?.id;
       invariant(defaultRoleID, 'Default role ID must exist');
       const { membershipPermissions } = createRoleAndPermissionForThickThreads(
         currentThreadInfo.type,
         currentThreadInfo.id,
         defaultRoleID,
       );
 
       const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
         id: joinerID,
         role: defaultRoleID,
         permissions: membershipPermissions,
         isSender: joinerID === viewerID,
         subscription: joinThreadSubscription,
       });
       const updatedThreadInfo = {
         ...currentThreadInfo,
         members: [...currentThreadInfo.members, member],
       };
       updateInfos.push({
         type: updateTypes.UPDATE_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: updatedThreadInfo,
       });
     }
     return {
       rawMessageInfos,
       updateInfos,
     };
   },
   canBeProcessed(
     dmOperation: DMJoinThreadOperation,
     viewerID: string,
     utilities: ProcessDMOperationUtilities,
   ) {
     if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) {
       return { isProcessingPossible: true };
     }
     return {
       isProcessingPossible: false,
       reason: {
         type: 'missing_thread',
         threadID: dmOperation.existingThreadDetails.threadID,
       },
     };
   },
   supportsAutoRetry: true,
 });
 
 export { joinThreadSpec };
diff --git a/lib/types/dm-ops.js b/lib/types/dm-ops.js
index 8ea4950fa..ba118ecfe 100644
--- a/lib/types/dm-ops.js
+++ b/lib/types/dm-ops.js
@@ -1,378 +1,411 @@
 // @flow
 
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import { clientAvatarValidator, type ClientAvatar } from './avatar-types.js';
 import type { RawMessageInfo } from './message-types.js';
 import type { NotificationsCreationData } from './notif-types.js';
 import type { OutboundP2PMessage } from './sqlite-types.js';
+import {
+  type ThreadSubscription,
+  threadSubscriptionValidator,
+} from './subscription-types.js';
 import {
   type NonSidebarThickThreadType,
   nonSidebarThickThreadTypes,
   type ThickThreadType,
   thickThreadTypeValidator,
 } from './thread-types-enum.js';
 import type { ClientUpdateInfo } from './update-types.js';
 import { values } from '../utils/objects.js';
 import { tColor, tShape, tString, tUserID } from '../utils/validation-utils.js';
 
 export const dmOperationTypes = Object.freeze({
   CREATE_THREAD: 'create_thread',
   CREATE_SIDEBAR: 'create_sidebar',
   SEND_TEXT_MESSAGE: 'send_text_message',
   SEND_REACTION_MESSAGE: 'send_reaction_message',
   SEND_EDIT_MESSAGE: 'send_edit_message',
   ADD_MEMBERS: 'add_members',
   ADD_VIEWER_TO_THREAD_MEMBERS: 'add_viewer_to_thread_members',
   JOIN_THREAD: 'join_thread',
   LEAVE_THREAD: 'leave_thread',
   REMOVE_MEMBERS: 'remove_members',
   CHANGE_THREAD_SETTINGS: 'change_thread_settings',
+  CHANGE_THREAD_SUBSCRIPTION: 'change_thread_subscription',
 });
 export type DMOperationType = $Values<typeof dmOperationTypes>;
 
+type MemberIDWithSubscription = {
+  +id: string,
+  +subscription: ThreadSubscription,
+};
+export const memberIDWithSubscriptionValidator: TInterface<MemberIDWithSubscription> =
+  tShape<MemberIDWithSubscription>({
+    id: tUserID,
+    subscription: threadSubscriptionValidator,
+  });
+
 export type CreateThickRawThreadInfoInput = {
   +threadID: string,
   +threadType: ThickThreadType,
   +creationTime: number,
   +parentThreadID?: ?string,
-  +allMemberIDs: $ReadOnlyArray<string>,
+  +allMemberIDsWithSubscriptions: $ReadOnlyArray<MemberIDWithSubscription>,
   +roleID: string,
   +unread: boolean,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color?: ?string,
   +containingThreadID?: ?string,
   +sourceMessageID?: ?string,
   +repliesCount?: ?number,
   +pinnedCount?: ?number,
 };
 export const createThickRawThreadInfoInputValidator: TInterface<CreateThickRawThreadInfoInput> =
   tShape<CreateThickRawThreadInfoInput>({
     threadID: t.String,
     threadType: thickThreadTypeValidator,
     creationTime: t.Number,
     parentThreadID: t.maybe(t.String),
-    allMemberIDs: t.list(tUserID),
+    allMemberIDsWithSubscriptions: t.list(memberIDWithSubscriptionValidator),
     roleID: t.String,
     unread: t.Boolean,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.maybe(t.String),
     containingThreadID: t.maybe(t.String),
     sourceMessageID: t.maybe(t.String),
     repliesCount: t.maybe(t.Number),
     pinnedCount: t.maybe(t.Number),
   });
 
 export type DMCreateThreadOperation = {
   +type: 'create_thread',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +threadType: NonSidebarThickThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +roleID: string,
   +newMessageID: string,
 };
 export const dmCreateThreadOperationValidator: TInterface<DMCreateThreadOperation> =
   tShape<DMCreateThreadOperation>({
     type: tString(dmOperationTypes.CREATE_THREAD),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     threadType: t.enums.of(values(nonSidebarThickThreadTypes)),
     memberIDs: t.list(tUserID),
     roleID: t.String,
     newMessageID: t.String,
   });
 
 export type DMCreateSidebarOperation = {
   +type: 'create_sidebar',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +parentThreadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: string,
   +roleID: string,
   +newSidebarSourceMessageID: string,
   +newCreateSidebarMessageID: string,
 };
 export const dmCreateSidebarOperationValidator: TInterface<DMCreateSidebarOperation> =
   tShape<DMCreateSidebarOperation>({
     type: tString(dmOperationTypes.CREATE_SIDEBAR),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     parentThreadID: t.String,
     memberIDs: t.list(tUserID),
     sourceMessageID: t.String,
     roleID: t.String,
     newSidebarSourceMessageID: t.String,
     newCreateSidebarMessageID: t.String,
   });
 
 export type DMSendTextMessageOperation = {
   +type: 'send_text_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +text: string,
 };
 export const dmSendTextMessageOperationValidator: TInterface<DMSendTextMessageOperation> =
   tShape<DMSendTextMessageOperation>({
     type: tString(dmOperationTypes.SEND_TEXT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     text: t.String,
   });
 
 export type DMSendReactionMessageOperation = {
   +type: 'send_reaction_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 export const dmSendReactionMessageOperationValidator: TInterface<DMSendReactionMessageOperation> =
   tShape<DMSendReactionMessageOperation>({
     type: tString(dmOperationTypes.SEND_REACTION_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     reaction: t.String,
     action: t.enums.of(['add_reaction', 'remove_reaction']),
   });
 
 export type DMSendEditMessageOperation = {
   +type: 'send_edit_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +text: string,
 };
 export const dmSendEditMessageOperationValidator: TInterface<DMSendEditMessageOperation> =
   tShape<DMSendEditMessageOperation>({
     type: tString(dmOperationTypes.SEND_EDIT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     text: t.String,
   });
 
 type DMAddMembersBase = {
   +editorID: string,
   +time: number,
   +messageID: string,
   +addedUserIDs: $ReadOnlyArray<string>,
 };
 const dmAddMembersBaseValidatorShape = {
   editorID: tUserID,
   time: t.Number,
   messageID: t.String,
   addedUserIDs: t.list(tUserID),
 };
 
 export type DMAddMembersOperation = $ReadOnly<{
   +type: 'add_members',
   +threadID: string,
   ...DMAddMembersBase,
 }>;
 export const dmAddMembersOperationValidator: TInterface<DMAddMembersOperation> =
   tShape<DMAddMembersOperation>({
     type: tString(dmOperationTypes.ADD_MEMBERS),
     threadID: t.String,
     ...dmAddMembersBaseValidatorShape,
   });
 
 export type DMAddViewerToThreadMembersOperation = $ReadOnly<{
   +type: 'add_viewer_to_thread_members',
   +existingThreadDetails: CreateThickRawThreadInfoInput,
   ...DMAddMembersBase,
 }>;
 export const dmAddViewerToThreadMembersValidator: TInterface<DMAddViewerToThreadMembersOperation> =
   tShape<DMAddViewerToThreadMembersOperation>({
     type: tString(dmOperationTypes.ADD_VIEWER_TO_THREAD_MEMBERS),
     existingThreadDetails: createThickRawThreadInfoInputValidator,
     ...dmAddMembersBaseValidatorShape,
   });
 
 export type DMJoinThreadOperation = {
   +type: 'join_thread',
   +joinerID: string,
   +time: number,
   +messageID: string,
   +existingThreadDetails: CreateThickRawThreadInfoInput,
 };
 export const dmJoinThreadOperationValidator: TInterface<DMJoinThreadOperation> =
   tShape<DMJoinThreadOperation>({
     type: tString(dmOperationTypes.JOIN_THREAD),
     joinerID: tUserID,
     time: t.Number,
     messageID: t.String,
     existingThreadDetails: createThickRawThreadInfoInputValidator,
   });
 
 export type DMLeaveThreadOperation = {
   +type: 'leave_thread',
   +editorID: string,
   +time: number,
   +messageID: string,
   +threadID: string,
 };
 export const dmLeaveThreadOperationValidator: TInterface<DMLeaveThreadOperation> =
   tShape<DMLeaveThreadOperation>({
     type: tString(dmOperationTypes.LEAVE_THREAD),
     editorID: tUserID,
     time: t.Number,
     messageID: t.String,
     threadID: t.String,
   });
 
 export type DMRemoveMembersOperation = {
   +type: 'remove_members',
   +editorID: string,
   +time: number,
   +messageID: string,
   +threadID: string,
   +removedUserIDs: $ReadOnlyArray<string>,
 };
 export const dmRemoveMembersOperationValidator: TInterface<DMRemoveMembersOperation> =
   tShape<DMRemoveMembersOperation>({
     type: tString(dmOperationTypes.REMOVE_MEMBERS),
     editorID: tUserID,
     time: t.Number,
     messageID: t.String,
     threadID: t.String,
     removedUserIDs: t.list(tUserID),
   });
 
 export type DMThreadSettingsChanges = {
   +name?: string,
   +description?: string,
   +color?: string,
   +avatar?: ClientAvatar,
 };
 
 export type DMChangeThreadSettingsOperation = $ReadOnly<{
   +type: 'change_thread_settings',
   +threadID: string,
   +editorID: string,
   +time: number,
   +changes: DMThreadSettingsChanges,
   +messageIDsPrefix: string,
 }>;
 export const dmChangeThreadSettingsOperationValidator: TInterface<DMChangeThreadSettingsOperation> =
   tShape<DMChangeThreadSettingsOperation>({
     type: tString(dmOperationTypes.CHANGE_THREAD_SETTINGS),
     threadID: t.String,
     editorID: tUserID,
     time: t.Number,
     changes: tShape({
       name: t.maybe(t.String),
       description: t.maybe(t.String),
       color: t.maybe(tColor),
       avatar: t.maybe(clientAvatarValidator),
     }),
     messageIDsPrefix: t.String,
   });
 
+export type DMChangeThreadSubscriptionOperation = {
+  +type: 'change_thread_subscription',
+  +time: number,
+  +threadID: string,
+  +creatorID: string,
+  +subscription: ThreadSubscription,
+};
+export const dmChangeThreadSubscriptionOperationValidator: TInterface<DMChangeThreadSubscriptionOperation> =
+  tShape<DMChangeThreadSubscriptionOperation>({
+    type: tString(dmOperationTypes.CHANGE_THREAD_SUBSCRIPTION),
+    time: t.Number,
+    threadID: t.String,
+    creatorID: tUserID,
+    subscription: threadSubscriptionValidator,
+  });
+
 export type DMOperation =
   | DMCreateThreadOperation
   | DMCreateSidebarOperation
   | DMSendTextMessageOperation
   | DMSendReactionMessageOperation
   | DMSendEditMessageOperation
   | DMAddMembersOperation
   | DMAddViewerToThreadMembersOperation
   | DMJoinThreadOperation
   | DMLeaveThreadOperation
   | DMRemoveMembersOperation
-  | DMChangeThreadSettingsOperation;
+  | DMChangeThreadSettingsOperation
+  | DMChangeThreadSubscriptionOperation;
 export const dmOperationValidator: TUnion<DMOperation> = t.union([
   dmCreateThreadOperationValidator,
   dmCreateSidebarOperationValidator,
   dmSendTextMessageOperationValidator,
   dmSendReactionMessageOperationValidator,
   dmSendEditMessageOperationValidator,
   dmAddMembersOperationValidator,
   dmAddViewerToThreadMembersValidator,
   dmJoinThreadOperationValidator,
   dmLeaveThreadOperationValidator,
   dmRemoveMembersOperationValidator,
   dmChangeThreadSettingsOperationValidator,
+  dmChangeThreadSubscriptionOperationValidator,
 ]);
 
 export type DMOperationResult = {
   rawMessageInfos: Array<RawMessageInfo>,
   updateInfos: Array<ClientUpdateInfo>,
 };
 
 export const processDMOpsActionType = 'PROCESS_DM_OPS';
 
 export type ProcessDMOpsPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
   +outboundP2PMessages: ?$ReadOnlyArray<OutboundP2PMessage>,
   // For messages that could be retried from UI, we need to bind DM `messageID`
   // with `outboundP2PMessages` to keep track of whether all P2P messages
   // were queued on Tunnelbroker.
   +messageIDWithoutAutoRetry: ?string,
   +notificationsCreationData: ?NotificationsCreationData,
 };
 
 export const queueDMOpsActionType = 'QUEUE_DM_OPS';
 export type QueueDMOpsPayload = {
   +operation: DMOperation,
   +threadID: string,
   +timestamp: number,
 };
 
 export const pruneDMOpsQueueActionType = 'PRUNE_DM_OPS_QUEUE';
 export type PruneDMOpsQueuePayload = {
   +pruneMaxTimestamp: number,
 };
 
 export const clearQueuedThreadDMOpsActionType = 'CLEAR_QUEUED_THREAD_DM_OPS';
 export type ClearQueuedThreadDMOpsPayload = {
   +threadID: string,
 };
 
 export type QueuedDMOperations = {
   +operations: {
     +[threadID: string]: $ReadOnlyArray<{
       +operation: DMOperation,
       +timestamp: number,
     }>,
   },
 };
 
 export type SendDMStartedPayload = {
   +messageID: string,
 };
 
 export type SendDMOpsSuccessPayload = {
   +messageID: string,
   +outboundP2PMessageIDs: $ReadOnlyArray<string>,
 };
 
 export const sendDMActionTypes = Object.freeze({
   started: 'SEND_DM_STARTED',
   success: 'SEND_DM_SUCCESS',
   failed: 'SEND_DM_FAILED',
 });