diff --git a/keyserver/src/fetchers/thread-fetchers.js b/keyserver/src/fetchers/thread-fetchers.js
index f37700955..2dc353f85 100644
--- a/keyserver/src/fetchers/thread-fetchers.js
+++ b/keyserver/src/fetchers/thread-fetchers.js
@@ -1,393 +1,390 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { getAllThreadPermissions } from 'lib/permissions/thread-permissions.js';
 import {
   rawThreadInfoFromServerThreadInfo,
   getContainingThreadID,
   getCommunity,
 } from 'lib/shared/thread-utils.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type { AvatarDBContent, ClientAvatar } from 'lib/types/avatar-types.js';
 import type { RawMessageInfo, MessageInfo } from 'lib/types/message-types.js';
 import { threadTypes, type ThreadType } from 'lib/types/thread-types-enum.js';
 import {
-  type RawThreadInfo,
+  type RawThreadInfos,
   type ServerThreadInfo,
 } from 'lib/types/thread-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import { getUploadURL } from './upload-fetchers.js';
 import { dbQuery, SQL, mergeAndConditions } from '../database/database.js';
 import type { SQLStatementType } from '../database/types.js';
 import type { Viewer } from '../session/viewer.js';
 
 type FetchThreadInfosFilter = $Shape<{
   +accessibleToUserID: string,
   +threadID: string,
   +threadIDs: $ReadOnlySet<string>,
   +parentThreadID: string,
   +sourceMessageID: string,
 }>;
 function constructWhereClause(
   filter: FetchThreadInfosFilter,
 ): SQLStatementType {
   const fromTable = filter.accessibleToUserID ? 'memberships' : 'threads';
 
   const conditions = [];
 
   if (filter.accessibleToUserID) {
     conditions.push(
       SQL`mm.user = ${filter.accessibleToUserID} AND mm.role > -1`,
     );
   }
 
   if (filter.threadID && fromTable === 'memberships') {
     conditions.push(SQL`mm.thread = ${filter.threadID}`);
   } else if (filter.threadID) {
     conditions.push(SQL`t.id = ${filter.threadID}`);
   }
 
   if (filter.threadIDs && fromTable === 'memberships') {
     conditions.push(SQL`mm.thread IN (${[...filter.threadIDs]})`);
   } else if (filter.threadIDs) {
     conditions.push(SQL`t.id IN (${[...filter.threadIDs]})`);
   }
 
   if (filter.parentThreadID) {
     conditions.push(SQL`t.parent_thread_id = ${filter.parentThreadID}`);
   }
 
   if (filter.sourceMessageID) {
     conditions.push(SQL`t.source_message = ${filter.sourceMessageID}`);
   }
 
   if (conditions.length === 0) {
     return SQL``;
   }
 
   const clause = mergeAndConditions(conditions);
   return SQL`WHERE `.append(clause);
 }
 
 type FetchServerThreadInfosResult = {
   +threadInfos: { +[id: string]: ServerThreadInfo },
 };
 
 async function fetchServerThreadInfos(
   filter?: FetchThreadInfosFilter,
 ): Promise<FetchServerThreadInfosResult> {
   if (filter?.threadIDs?.size === 0) {
     return { threadInfos: {} };
   }
 
   let primaryFetchClause;
   if (filter?.accessibleToUserID) {
     primaryFetchClause = SQL`
       FROM memberships mm
       LEFT JOIN threads t ON t.id = mm.thread
     `;
   } else {
     primaryFetchClause = SQL`
       FROM threads t
     `;
   }
 
   const whereClause = filter ? constructWhereClause(filter) : '';
 
   const rolesQuery = SQL`
     SELECT t.id, t.default_role, r.id AS role, r.name, r.permissions
   `
     .append(primaryFetchClause)
     .append(
       SQL`
       LEFT JOIN roles r ON r.thread = t.id
     `,
     )
     .append(whereClause);
 
   const threadsQuery = SQL`
     SELECT t.id, t.name, t.parent_thread_id, t.containing_thread_id,
       t.community, t.depth, t.color, t.description, t.type, t.creation_time,
       t.source_message, t.replies_count, t.avatar, t.pinned_count, m.user,
       m.role, m.permissions, m.subscription,
       m.last_read_message < m.last_message AS unread, m.sender,
       up.id AS upload_id, up.secret AS upload_secret
   `
     .append(primaryFetchClause)
     .append(
       SQL`
       LEFT JOIN memberships m ON m.thread = t.id AND m.role >= 0
       LEFT JOIN uploads up ON up.container = t.id
     `,
     )
     .append(whereClause)
     .append(SQL` ORDER BY m.user ASC`);
   const [[threadsResult], [rolesResult]] = await Promise.all([
     dbQuery(threadsQuery),
     dbQuery(rolesQuery),
   ]);
 
   const threadInfos = {};
   for (const threadsRow of threadsResult) {
     const threadID = threadsRow.id.toString();
     if (!threadInfos[threadID]) {
       threadInfos[threadID] = {
         id: threadID,
         type: threadsRow.type,
         name: threadsRow.name ? threadsRow.name : '',
         description: threadsRow.description ? threadsRow.description : '',
         color: threadsRow.color,
         creationTime: threadsRow.creation_time,
         parentThreadID: threadsRow.parent_thread_id
           ? threadsRow.parent_thread_id.toString()
           : null,
         containingThreadID: threadsRow.containing_thread_id
           ? threadsRow.containing_thread_id.toString()
           : null,
         depth: threadsRow.depth,
         community: threadsRow.community
           ? threadsRow.community.toString()
           : null,
         members: [],
         roles: {},
         repliesCount: threadsRow.replies_count,
         pinnedCount: threadsRow.pinned_count,
       };
       if (threadsRow.avatar) {
         const avatar: AvatarDBContent = JSON.parse(threadsRow.avatar);
         let clientAvatar: ?ClientAvatar;
         if (avatar && avatar.type !== 'image') {
           clientAvatar = avatar;
         } else if (
           avatar &&
           avatar.type === 'image' &&
           threadsRow.upload_id &&
           threadsRow.upload_secret
         ) {
           const uploadID = threadsRow.upload_id.toString();
           invariant(
             uploadID === avatar.uploadID,
             `uploadID of upload should match uploadID of image avatar`,
           );
           clientAvatar = {
             type: 'image',
             uri: getUploadURL(uploadID, threadsRow.upload_secret),
           };
         }
 
         threadInfos[threadID] = {
           ...threadInfos[threadID],
           avatar: clientAvatar,
         };
       }
     }
     const sourceMessageID = threadsRow.source_message?.toString();
     if (sourceMessageID) {
       threadInfos[threadID].sourceMessageID = sourceMessageID;
     }
     if (threadsRow.user) {
       const userID = threadsRow.user.toString();
       const allPermissions = getAllThreadPermissions(
         JSON.parse(threadsRow.permissions),
         threadID,
       );
       threadInfos[threadID].members.push({
         id: userID,
         permissions: allPermissions,
         role: threadsRow.role ? threadsRow.role.toString() : null,
         subscription: JSON.parse(threadsRow.subscription),
         unread: threadsRow.role ? !!threadsRow.unread : null,
         isSender: !!threadsRow.sender,
       });
     }
   }
 
   for (const rolesRow of rolesResult) {
     const threadID = rolesRow.id.toString();
     if (!rolesRow.role) {
       continue;
     }
     const role = rolesRow.role.toString();
     if (!threadInfos[threadID].roles[role]) {
       threadInfos[threadID].roles[role] = {
         id: role,
         name: rolesRow.name,
         permissions: JSON.parse(rolesRow.permissions),
         isDefault: role === rolesRow.default_role.toString(),
       };
     }
   }
 
   return { threadInfos };
 }
 
-export type RawThreadInfos = {
-  +[id: string]: RawThreadInfo,
-};
 export type FetchThreadInfosResult = {
   +threadInfos: RawThreadInfos,
 };
 
 async function fetchThreadInfos(
   viewer: Viewer,
   inputFilter?: FetchThreadInfosFilter,
 ): Promise<FetchThreadInfosResult> {
   const filter = {
     accessibleToUserID: viewer.id,
     ...inputFilter,
   };
   const serverResult = await fetchServerThreadInfos(filter);
   return rawThreadInfosFromServerThreadInfos(viewer, serverResult);
 }
 
 function rawThreadInfosFromServerThreadInfos(
   viewer: Viewer,
   serverResult: FetchServerThreadInfosResult,
 ): FetchThreadInfosResult {
   const viewerID = viewer.id;
   const codeVersionBelow209 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 209,
   });
   const codeVersionBelow213 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 213,
   });
   const codeVersionBelow221 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 221,
   });
 
   const threadInfos = {};
   for (const threadID in serverResult.threadInfos) {
     const serverThreadInfo = serverResult.threadInfos[threadID];
     const threadInfo = rawThreadInfoFromServerThreadInfo(
       serverThreadInfo,
       viewerID,
       {
         filterThreadEditAvatarPermission: codeVersionBelow213,
         excludePinInfo: codeVersionBelow209,
         filterManageInviteLinksPermission: codeVersionBelow221,
       },
     );
     if (threadInfo) {
       threadInfos[threadID] = threadInfo;
     }
   }
   return { threadInfos };
 }
 
 async function verifyThreadIDs(
   threadIDs: $ReadOnlyArray<string>,
 ): Promise<$ReadOnlyArray<string>> {
   if (threadIDs.length === 0) {
     return [];
   }
 
   const query = SQL`SELECT id FROM threads WHERE id IN (${threadIDs})`;
   const [result] = await dbQuery(query);
 
   const verified = [];
   for (const row of result) {
     verified.push(row.id.toString());
   }
   return verified;
 }
 
 async function verifyThreadID(threadID: string): Promise<boolean> {
   const result = await verifyThreadIDs([threadID]);
   return result.length !== 0;
 }
 
 type ThreadAncestry = {
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
 };
 async function determineThreadAncestry(
   parentThreadID: ?string,
   threadType: ThreadType,
 ): Promise<ThreadAncestry> {
   if (!parentThreadID) {
     return { containingThreadID: null, community: null, depth: 0 };
   }
   const parentThreadInfos = await fetchServerThreadInfos({
     threadID: parentThreadID,
   });
   const parentThreadInfo = parentThreadInfos.threadInfos[parentThreadID];
   if (!parentThreadInfo) {
     throw new ServerError('invalid_parameters');
   }
   const containingThreadID = getContainingThreadID(
     parentThreadInfo,
     threadType,
   );
   const community = getCommunity(parentThreadInfo);
   const depth = parentThreadInfo.depth + 1;
   return { containingThreadID, community, depth };
 }
 
 function personalThreadQuery(
   firstMemberID: string,
   secondMemberID: string,
 ): SQLStatementType {
   return SQL`
     SELECT t.id 
     FROM threads t
     INNER JOIN memberships m1 
       ON m1.thread = t.id AND m1.user = ${firstMemberID}
     INNER JOIN memberships m2
       ON m2.thread = t.id AND m2.user = ${secondMemberID}
     WHERE t.type = ${threadTypes.PERSONAL}
       AND m1.role > 0
       AND m2.role > 0
   `;
 }
 
 async function fetchPersonalThreadID(
   viewerID: string,
   otherMemberID: string,
 ): Promise<?string> {
   const query = personalThreadQuery(viewerID, otherMemberID);
   const [threads] = await dbQuery(query);
   return threads[0]?.id.toString();
 }
 
 async function serverThreadInfoFromMessageInfo(
   message: RawMessageInfo | MessageInfo,
 ): Promise<?ServerThreadInfo> {
   const threadID = message.threadID;
   const threads = await fetchServerThreadInfos({ threadID });
   return threads.threadInfos[threadID];
 }
 
 async function fetchContainedThreadIDs(
   parentThreadID: string,
 ): Promise<Array<string>> {
   const query = SQL`
     WITH RECURSIVE thread_tree AS (
       SELECT id, containing_thread_id
       FROM threads
       WHERE id = ${parentThreadID}
       UNION ALL
       SELECT t.id, t.containing_thread_id
       FROM threads t
       JOIN thread_tree tt ON t.containing_thread_id = tt.id
     )
     SELECT id FROM thread_tree
   `;
   const [result] = await dbQuery(query);
   return result.map(row => row.id.toString());
 }
 
 export {
   fetchServerThreadInfos,
   fetchThreadInfos,
   rawThreadInfosFromServerThreadInfos,
   verifyThreadIDs,
   verifyThreadID,
   determineThreadAncestry,
   personalThreadQuery,
   fetchPersonalThreadID,
   serverThreadInfoFromMessageInfo,
   fetchContainedThreadIDs,
 };
diff --git a/keyserver/src/shared/state-sync/threads-state-sync-spec.js b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
index 99e3e70e8..68c9fd373 100644
--- a/keyserver/src/shared/state-sync/threads-state-sync-spec.js
+++ b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
@@ -1,25 +1,23 @@
 // @flow
 
 import { threadsStateSyncSpec as libSpec } from 'lib/shared/state-sync/threads-state-sync-spec.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
+import type { RawThreadInfos } from 'lib/types/thread-types.js';
 
 import type { ServerStateSyncSpec } from './state-sync-spec.js';
-import {
-  fetchThreadInfos,
-  type RawThreadInfos,
-} from '../../fetchers/thread-fetchers.js';
+import { fetchThreadInfos } from '../../fetchers/thread-fetchers.js';
 import type { Viewer } from '../../session/viewer.js';
 
 export const threadsStateSyncSpec: ServerStateSyncSpec<RawThreadInfos> =
   Object.freeze({
     async fetch(
       viewer: Viewer,
       query: $ReadOnlyArray<CalendarQuery>,
       ids?: $ReadOnlySet<string>,
     ) {
       const filter = ids ? { threadIDs: ids } : undefined;
       const result = await fetchThreadInfos(viewer, filter);
       return result.threadInfos;
     },
     ...libSpec,
   });
diff --git a/lib/selectors/socket-selectors.js b/lib/selectors/socket-selectors.js
index f0d19bf0f..059019adb 100644
--- a/lib/selectors/socket-selectors.js
+++ b/lib/selectors/socket-selectors.js
@@ -1,255 +1,255 @@
 // @flow
 
 import { createSelector } from 'reselect';
 import t from 'tcomb';
 
 import {
   updatesCurrentAsOfSelector,
   currentAsOfSelector,
 } from './keyserver-selectors.js';
 import { currentCalendarQuery } from './nav-selectors.js';
 import {
   serverEntryInfo,
   serverEntryInfosObject,
   filterRawEntryInfosByCalendarQuery,
 } from '../shared/entry-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type { SignedIdentityKeysBlob } from '../types/crypto-types.js';
 import {
-  type RawEntryInfo,
+  type RawEntryInfos,
   rawEntryInfoValidator,
   type CalendarQuery,
 } from '../types/entry-types.js';
 import type { AppState } from '../types/redux-types.js';
 import type { ClientReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   type ClientServerRequest,
   type ClientClientResponse,
 } from '../types/request-types.js';
 import type { SessionState } from '../types/session-types.js';
 import type { OneTimeKeyGenerator } from '../types/socket-types.js';
 import {
-  type RawThreadInfo,
+  type RawThreadInfos,
   rawThreadInfoValidator,
 } from '../types/thread-types.js';
 import {
   type CurrentUserInfo,
   currentUserInfoValidator,
   type UserInfos,
   userInfosValidator,
 } from '../types/user-types.js';
 import { getConfig } from '../utils/config.js';
 import { convertClientIDsToServerIDs } from '../utils/conversion-utils.js';
 import { minimumOneTimeKeysRequired } from '../utils/crypto-utils.js';
 import { values, hash } from '../utils/objects.js';
 import { tID, ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const queuedReports: (
   state: AppState,
 ) => $ReadOnlyArray<ClientReportCreationRequest> = createSelector(
   (state: AppState) => state.reportStore.queuedReports,
   (
     mainQueuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   ): $ReadOnlyArray<ClientReportCreationRequest> => mainQueuedReports,
 );
 
 const getClientResponsesSelector: (
   state: AppState,
 ) => (
   calendarActive: boolean,
   oneTimeKeyGenerator: ?OneTimeKeyGenerator,
   getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
   getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   (state: AppState) => state.threadStore.threadInfos,
   (state: AppState) => state.entryStore.entryInfos,
   (state: AppState) => state.userStore.userInfos,
   (state: AppState) => state.currentUserInfo,
   currentCalendarQuery,
   (
-    threadInfos: { +[id: string]: RawThreadInfo },
-    entryInfos: { +[id: string]: RawEntryInfo },
+    threadInfos: RawThreadInfos,
+    entryInfos: RawEntryInfos,
     userInfos: UserInfos,
     currentUserInfo: ?CurrentUserInfo,
     calendarQuery: (calendarActive: boolean) => CalendarQuery,
   ) => {
     return async (
       calendarActive: boolean,
       oneTimeKeyGenerator: ?OneTimeKeyGenerator,
       getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
       getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
       serverRequests: $ReadOnlyArray<ClientServerRequest>,
     ): Promise<$ReadOnlyArray<ClientClientResponse>> => {
       const clientResponses = [];
       const serverRequestedPlatformDetails = serverRequests.some(
         request => request.type === serverRequestTypes.PLATFORM_DETAILS,
       );
       for (const serverRequest of serverRequests) {
         if (
           serverRequest.type === serverRequestTypes.PLATFORM &&
           !serverRequestedPlatformDetails
         ) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM,
             platform: getConfig().platformDetails.platform,
           });
         } else if (serverRequest.type === serverRequestTypes.PLATFORM_DETAILS) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM_DETAILS,
             platformDetails: getConfig().platformDetails,
           });
         } else if (serverRequest.type === serverRequestTypes.CHECK_STATE) {
           const filteredEntryInfos = filterRawEntryInfosByCalendarQuery(
             serverEntryInfosObject(values(entryInfos)),
             calendarQuery(calendarActive),
           );
 
           const convertedEntryInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.dict(tID, rawEntryInfoValidator),
             filteredEntryInfos,
           );
 
           const convertedThreadInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.dict(tID, rawThreadInfoValidator),
             threadInfos,
           );
 
           const convertedUserInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             userInfosValidator,
             userInfos,
           );
 
           const convertedCurrentUserInfo = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.maybe(currentUserInfoValidator),
             currentUserInfo,
           );
 
           const hashResults = {};
           for (const key in serverRequest.hashesToCheck) {
             const expectedHashValue = serverRequest.hashesToCheck[key];
             let hashValue;
             if (key === 'threadInfos') {
               hashValue = hash(convertedThreadInfos);
             } else if (key === 'entryInfos') {
               hashValue = hash(convertedEntryInfos);
             } else if (key === 'userInfos') {
               hashValue = hash(convertedUserInfos);
             } else if (key === 'currentUserInfo') {
               hashValue = hash(convertedCurrentUserInfo);
             } else if (key.startsWith('threadInfo|')) {
               const [, threadID] = key.split('|');
               hashValue = hash(convertedThreadInfos[threadID]);
             } else if (key.startsWith('entryInfo|')) {
               const [, entryID] = key.split('|');
               let rawEntryInfo = convertedEntryInfos[entryID];
               if (rawEntryInfo) {
                 rawEntryInfo = serverEntryInfo(rawEntryInfo);
               }
               hashValue = hash(rawEntryInfo);
             } else if (key.startsWith('userInfo|')) {
               const [, userID] = key.split('|');
               hashValue = hash(convertedUserInfos[userID]);
             } else {
               continue;
             }
             hashResults[key] = expectedHashValue === hashValue;
           }
 
           const { failUnmentioned } = serverRequest;
           if (failUnmentioned && failUnmentioned.threadInfos) {
             for (const threadID in convertedThreadInfos) {
               const key = `threadInfo|${threadID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.entryInfos) {
             for (const entryID in convertedEntryInfos) {
               const key = `entryInfo|${entryID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.userInfos) {
             for (const userID in convertedUserInfos) {
               const key = `userInfo|${userID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
 
           clientResponses.push({
             type: serverRequestTypes.CHECK_STATE,
             hashResults,
           });
         } else if (
           serverRequest.type === serverRequestTypes.MORE_ONE_TIME_KEYS &&
           oneTimeKeyGenerator
         ) {
           const keys: string[] = [];
           for (let i = 0; i < minimumOneTimeKeysRequired; ++i) {
             keys.push(oneTimeKeyGenerator(i));
           }
           clientResponses.push({
             type: serverRequestTypes.MORE_ONE_TIME_KEYS,
             keys,
           });
         } else if (
           serverRequest.type === serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB &&
           getSignedIdentityKeysBlob
         ) {
           const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
           clientResponses.push({
             type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
             signedIdentityKeysBlob,
           });
         } else if (
           serverRequest.type ===
             serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE &&
           getInitialNotificationsEncryptedMessage
         ) {
           const initialNotificationsEncryptedMessage =
             await getInitialNotificationsEncryptedMessage();
           clientResponses.push({
             type: serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE,
             initialNotificationsEncryptedMessage,
           });
         }
       }
       return clientResponses;
     };
   },
 );
 
 const sessionStateFuncSelector: (
   state: AppState,
 ) => (calendarActive: boolean) => SessionState = createSelector(
   currentAsOfSelector,
   updatesCurrentAsOfSelector,
   currentCalendarQuery,
   (
       messagesCurrentAsOf: number,
       updatesCurrentAsOf: number,
       calendarQuery: (calendarActive: boolean) => CalendarQuery,
     ) =>
     (calendarActive: boolean): SessionState => ({
       calendarQuery: calendarQuery(calendarActive),
       messagesCurrentAsOf,
       updatesCurrentAsOf,
       watchedIDs: threadWatcher.getWatchedIDs(),
     }),
 );
 
 export { queuedReports, getClientResponsesSelector, sessionStateFuncSelector };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 12c47f1b1..a3876c59f 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,463 +1,466 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type AvatarDBContent,
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarRequest,
 } from './avatar-types.js';
 import type { Shape } from './core.js';
 import type { CalendarQuery } from './entry-types.js';
 import type { Media } from './media-types.js';
 import type {
   MessageTruncationStatuses,
   RawMessageInfo,
 } from './message-types.js';
 import {
   type ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type ThreadPermissionsInfo,
   threadPermissionsInfoValidator,
   type ThreadRolePermissionsBlob,
   threadRolePermissionsBlobValidator,
   type UserSurfacedPermission,
 } from './thread-permission-types.js';
 import { type ThreadType, threadTypeValidator } from './thread-types-enum.js';
 import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import {
   type ThreadEntity,
   threadEntityValidator,
 } from '../utils/entity-text.js';
 import { tID, tShape } from '../utils/validation-utils.js';
 
 export type MemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 const memberInfoValidator = tShape<MemberInfo>({
   id: t.String,
   role: t.maybe(tID),
   permissions: threadPermissionsInfoValidator,
   isSender: t.Boolean,
 });
 
 export type RelativeMemberInfo = {
   ...MemberInfo,
   +username: ?string,
   +isViewer: boolean,
 };
 const relativeMemberInfoValidator = tShape<RelativeMemberInfo>({
   ...memberInfoValidator.meta.props,
   username: t.maybe(t.String),
   isViewer: t.Boolean,
 });
 
 export type RoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 const roleInfoValidator = tShape<RoleInfo>({
   id: tID,
   name: t.String,
   permissions: threadRolePermissionsBlobValidator,
   isDefault: t.Boolean,
 });
 
 export type ThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 const threadCurrentUserInfoValidator = tShape<ThreadCurrentUserInfo>({
   role: t.maybe(tID),
   permissions: threadPermissionsInfoValidator,
   subscription: threadSubscriptionValidator,
   unread: t.maybe(t.Boolean),
 });
 
 export type RawThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<MemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
+export type RawThreadInfos = {
+  +[id: string]: RawThreadInfo,
+};
 export const rawThreadInfoValidator: TInterface<RawThreadInfo> =
   tShape<RawThreadInfo>({
     id: tID,
     type: threadTypeValidator,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.String,
     creationTime: t.Number,
     parentThreadID: t.maybe(tID),
     containingThreadID: t.maybe(tID),
     community: t.maybe(tID),
     members: t.list(memberInfoValidator),
     roles: t.dict(tID, roleInfoValidator),
     currentUser: threadCurrentUserInfoValidator,
     sourceMessageID: t.maybe(tID),
     repliesCount: t.Number,
     pinnedCount: t.maybe(t.Number),
   });
 
 export type ThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string | ThreadEntity,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<RelativeMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 export const threadInfoValidator: TInterface<ThreadInfo> = tShape<ThreadInfo>({
   id: tID,
   type: threadTypeValidator,
   name: t.maybe(t.String),
   uiName: t.union([t.String, threadEntityValidator]),
   avatar: t.maybe(clientAvatarValidator),
   description: t.maybe(t.String),
   color: t.String,
   creationTime: t.Number,
   parentThreadID: t.maybe(tID),
   containingThreadID: t.maybe(tID),
   community: t.maybe(tID),
   members: t.list(relativeMemberInfoValidator),
   roles: t.dict(tID, roleInfoValidator),
   currentUser: threadCurrentUserInfoValidator,
   sourceMessageID: t.maybe(tID),
   repliesCount: t.Number,
   pinnedCount: t.maybe(t.Number),
 });
 
 export type ResolvedThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<RelativeMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +avatar?: AvatarDBContent,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
   +members: $ReadOnlyArray<ServerMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount: number,
 };
 
 export type ThreadStore = {
   +threadInfos: { +[id: string]: RawThreadInfo },
 };
 export const threadStoreValidator: TInterface<ThreadStore> =
   tShape<ThreadStore>({
     threadInfos: t.dict(tID, rawThreadInfoValidator),
   });
 
 export type ClientDBThreadInfo = {
   +id: string,
   +type: number,
   +name: ?string,
   +avatar?: ?string,
   +description: ?string,
   +color: string,
   +creationTime: string,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: string,
   +roles: string,
   +currentUser: string,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ThreadDeletionRequest = {
   +threadID: string,
   +accountPassword: ?string,
 };
 
 export type RemoveMembersRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 export type RoleChangeRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +role: string,
 };
 
 export type ChangeThreadSettingsResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type ChangeThreadSettingsPayload = {
   +threadID: string,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type LeaveThreadRequest = {
   +threadID: string,
 };
 export type LeaveThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type LeaveThreadPayload = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type ThreadChanges = Shape<{
   +type: ThreadType,
   +name: string,
   +description: string,
   +color: string,
   +parentThreadID: ?string,
   +newMemberIDs: $ReadOnlyArray<string>,
   +avatar: UpdateUserAvatarRequest,
 }>;
 
 export type UpdateThreadRequest = {
   +threadID: string,
   +changes: ThreadChanges,
   +accountPassword?: empty,
 };
 
 export type BaseNewThreadRequest = {
   +id?: ?string,
   +name?: ?string,
   +description?: ?string,
   +color?: ?string,
   +parentThreadID?: ?string,
   +initialMemberIDs?: ?$ReadOnlyArray<string>,
   +ghostMemberIDs?: ?$ReadOnlyArray<string>,
 };
 type NewThreadRequest =
   | {
       +type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
       ...BaseNewThreadRequest,
     }
   | {
       +type: 5,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
     };
 
 export type ClientNewThreadRequest = {
   ...NewThreadRequest,
   +calendarQuery: CalendarQuery,
 };
 export type ServerNewThreadRequest = {
   ...NewThreadRequest,
   +calendarQuery?: ?CalendarQuery,
 };
 
 export type NewThreadResponse = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 export type NewThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 
 export type ServerThreadJoinRequest = {
   +threadID: string,
   +calendarQuery?: ?CalendarQuery,
   +inviteLinkSecret?: string,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
 };
 export type ThreadJoinResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type ThreadJoinPayload = {
   +updatesResult: {
     newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type ThreadFetchMediaResult = {
   +media: $ReadOnlyArray<Media>,
 };
 export type ThreadFetchMediaRequest = {
   +threadID: string,
   +limit: number,
   +offset: number,
 };
 
 export type SidebarInfo = {
   +threadInfo: ThreadInfo,
   +lastUpdatedTime: number,
   +mostRecentNonLocalMessage: ?string,
 };
 
 export type ToggleMessagePinRequest = {
   +messageID: string,
   +action: 'pin' | 'unpin',
 };
 
 export type ToggleMessagePinResult = {
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadID: string,
 };
 
 type CreateRoleAction = {
   +community: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'create_role',
 };
 
 type EditRoleAction = {
   +community: string,
   +existingRoleID: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'edit_role',
 };
 
 export type RoleModificationRequest = CreateRoleAction | EditRoleAction;
 
 export type RoleModificationResult = {
   +threadInfo: RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleModificationPayload = {
   +threadInfo: RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type RoleDeletionRequest = {
   +community: string,
   +roleID: string,
 };
 
 export type RoleDeletionResult = {
   +threadInfo: RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleDeletionPayload = {
   +threadInfo: RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 // We can show a max of 3 sidebars inline underneath their parent in the chat
 // tab. If there are more, we show a button that opens a modal to see the rest
 export const maxReadSidebars = 3;
 
 // We can show a max of 5 sidebars inline underneath their parent
 // in the chat tab if every one of the displayed sidebars is unread
 export const maxUnreadSidebars = 5;
 
 export type ThreadStoreThreadInfos = { +[id: string]: RawThreadInfo };
 
 export type ChatMentionCandidates = { +[id: string]: ResolvedThreadInfo };
 export type ChatMentionCandidatesObj = {
   +[id: string]: ChatMentionCandidates,
 };