diff --git a/keyserver/src/responders/thread-responders.js b/keyserver/src/responders/thread-responders.js
index b0ee77724..3b440f560 100644
--- a/keyserver/src/responders/thread-responders.js
+++ b/keyserver/src/responders/thread-responders.js
@@ -1,188 +1,188 @@
 // @flow
 
 import t from 'tcomb';
 import type { TUnion, TInterface } from 'tcomb';
 
 import {
   type ThreadDeletionRequest,
   type RoleChangeRequest,
   type ChangeThreadSettingsResult,
   type RemoveMembersRequest,
   type LeaveThreadRequest,
   type LeaveThreadResult,
   type UpdateThreadRequest,
   type ServerNewThreadRequest,
   type NewThreadResponse,
   type ServerThreadJoinRequest,
   type ThreadJoinResult,
   threadTypes,
 } from 'lib/types/thread-types';
 import { values } from 'lib/utils/objects';
 import {
   tShape,
   tNumEnum,
   tColor,
   tPassword,
 } from 'lib/utils/validation-utils';
 
 import { createThread } from '../creators/thread-creator';
 import { deleteThread } from '../deleters/thread-deleters';
 import type { Viewer } from '../session/viewer';
 import {
   updateRole,
   removeMembers,
   leaveThread,
   updateThread,
   joinThread,
 } from '../updaters/thread-updaters';
 import { validateInput } from '../utils/validation-utils';
 import {
   entryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders';
 
 const threadDeletionRequestInputValidator = tShape({
   threadID: t.String,
-  accountPassword: tPassword,
+  accountPassword: t.maybe(tPassword),
 });
 
 async function threadDeletionResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LeaveThreadResult> {
   const request: ThreadDeletionRequest = input;
   await validateInput(viewer, threadDeletionRequestInputValidator, request);
   return await deleteThread(viewer, request);
 }
 
 const roleChangeRequestInputValidator = tShape({
   threadID: t.String,
   memberIDs: t.list(t.String),
   role: t.refinement(t.String, str => {
     const int = parseInt(str, 10);
     return String(int) === str && int > 0;
   }),
 });
 
 async function roleUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: RoleChangeRequest = input;
   await validateInput(viewer, roleChangeRequestInputValidator, request);
   return await updateRole(viewer, request);
 }
 
 const removeMembersRequestInputValidator = tShape({
   threadID: t.String,
   memberIDs: t.list(t.String),
 });
 
 async function memberRemovalResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: RemoveMembersRequest = input;
   await validateInput(viewer, removeMembersRequestInputValidator, request);
   return await removeMembers(viewer, request);
 }
 
 const leaveThreadRequestInputValidator = tShape({
   threadID: t.String,
 });
 
 async function threadLeaveResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LeaveThreadResult> {
   const request: LeaveThreadRequest = input;
   await validateInput(viewer, leaveThreadRequestInputValidator, request);
   return await leaveThread(viewer, request);
 }
 
 const updateThreadRequestInputValidator = tShape({
   threadID: t.String,
   changes: tShape({
     type: t.maybe(tNumEnum(values(threadTypes))),
     name: t.maybe(t.String),
     description: t.maybe(t.String),
     color: t.maybe(tColor),
     parentThreadID: t.maybe(t.String),
     newMemberIDs: t.maybe(t.list(t.String)),
   }),
   accountPassword: t.maybe(tPassword),
 });
 
 async function threadUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: UpdateThreadRequest = input;
   await validateInput(viewer, updateThreadRequestInputValidator, request);
   return await updateThread(viewer, request);
 }
 
 const threadRequestValidationShape = {
   name: t.maybe(t.String),
   description: t.maybe(t.String),
   color: t.maybe(tColor),
   parentThreadID: t.maybe(t.String),
   initialMemberIDs: t.maybe(t.list(t.String)),
   calendarQuery: t.maybe(entryQueryInputValidator),
 };
 const newThreadRequestInputValidator: TUnion<TInterface> = t.union([
   tShape({
     type: tNumEnum([threadTypes.SIDEBAR]),
     sourceMessageID: t.String,
     ...threadRequestValidationShape,
   }),
   tShape({
     type: tNumEnum([
       threadTypes.COMMUNITY_OPEN_SUBTHREAD,
       threadTypes.COMMUNITY_SECRET_SUBTHREAD,
       threadTypes.PERSONAL,
       threadTypes.LOCAL,
     ]),
     ...threadRequestValidationShape,
   }),
 ]);
 async function threadCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<NewThreadResponse> {
   const request: ServerNewThreadRequest = input;
   await validateInput(viewer, newThreadRequestInputValidator, request);
 
   return await createThread(viewer, request, {
     silentlyFailMembers: request.type === threadTypes.SIDEBAR,
   });
 }
 
 const joinThreadRequestInputValidator = tShape({
   threadID: t.String,
   calendarQuery: t.maybe(entryQueryInputValidator),
 });
 async function threadJoinResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ThreadJoinResult> {
   const request: ServerThreadJoinRequest = input;
   await validateInput(viewer, joinThreadRequestInputValidator, request);
 
   if (request.calendarQuery) {
     await verifyCalendarQueryThreadIDs(request.calendarQuery);
   }
 
   return await joinThread(viewer, request);
 }
 
 export {
   threadDeletionResponder,
   roleUpdateResponder,
   memberRemovalResponder,
   threadLeaveResponder,
   threadUpdateResponder,
   threadCreationResponder,
   threadJoinResponder,
   newThreadRequestInputValidator,
 };
diff --git a/lib/actions/thread-actions.js b/lib/actions/thread-actions.js
index 31b3257a4..aa9ccfaf8 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,180 +1,180 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type {
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   UpdateThreadRequest,
   ClientNewThreadRequest,
   NewThreadResult,
   ClientThreadJoinRequest,
   ThreadJoinPayload,
 } from '../types/thread-types';
 import type { CallServerEndpoint } from '../utils/call-server-endpoint';
 import { values } from '../utils/objects';
 
 const deleteThreadActionTypes = Object.freeze({
   started: 'DELETE_THREAD_STARTED',
   success: 'DELETE_THREAD_SUCCESS',
   failed: 'DELETE_THREAD_FAILED',
 });
 const deleteThread = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
-  currentAccountPassword: string,
+  currentAccountPassword: ?string,
 ) => Promise<LeaveThreadPayload>) => async (
   threadID,
   currentAccountPassword,
 ) => {
   const response = await callServerEndpoint('delete_thread', {
     threadID,
     accountPassword: currentAccountPassword,
   });
   return {
     updatesResult: response.updatesResult,
   };
 };
 
 const changeThreadSettingsActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_SETTINGS_STARTED',
   success: 'CHANGE_THREAD_SETTINGS_SUCCESS',
   failed: 'CHANGE_THREAD_SETTINGS_FAILED',
 });
 const changeThreadSettings = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   request: UpdateThreadRequest,
 ) => Promise<ChangeThreadSettingsPayload>) => async request => {
   const response = await callServerEndpoint('update_thread', request);
   invariant(
     Object.keys(request.changes).length > 0,
     'No changes provided to changeThreadSettings!',
   );
   return {
     threadID: request.threadID,
     updatesResult: response.updatesResult,
     newMessageInfos: response.newMessageInfos,
   };
 };
 
 const removeUsersFromThreadActionTypes = Object.freeze({
   started: 'REMOVE_USERS_FROM_THREAD_STARTED',
   success: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
   failed: 'REMOVE_USERS_FROM_THREAD_FAILED',
 });
 const removeUsersFromThread = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   memberIDs: $ReadOnlyArray<string>,
 ) => Promise<ChangeThreadSettingsPayload>) => async (threadID, memberIDs) => {
   const response = await callServerEndpoint('remove_members', {
     threadID,
     memberIDs,
   });
   return {
     threadID,
     updatesResult: response.updatesResult,
     newMessageInfos: response.newMessageInfos,
   };
 };
 
 const changeThreadMemberRolesActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
   success: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
   failed: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
 });
 const changeThreadMemberRoles = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   threadID: string,
   memberIDs: $ReadOnlyArray<string>,
   newRole: string,
 ) => Promise<ChangeThreadSettingsPayload>) => async (
   threadID,
   memberIDs,
   newRole,
 ) => {
   const response = await callServerEndpoint('update_role', {
     threadID,
     memberIDs,
     role: newRole,
   });
   return {
     threadID,
     updatesResult: response.updatesResult,
     newMessageInfos: response.newMessageInfos,
   };
 };
 
 const newThreadActionTypes = Object.freeze({
   started: 'NEW_THREAD_STARTED',
   success: 'NEW_THREAD_SUCCESS',
   failed: 'NEW_THREAD_FAILED',
 });
 const newThread = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   request: ClientNewThreadRequest,
 ) => Promise<NewThreadResult>) => async request => {
   const response = await callServerEndpoint('create_thread', request);
   return {
     newThreadID: response.newThreadID,
     updatesResult: response.updatesResult,
     newMessageInfos: response.newMessageInfos,
     userInfos: response.userInfos,
   };
 };
 
 const joinThreadActionTypes = Object.freeze({
   started: 'JOIN_THREAD_STARTED',
   success: 'JOIN_THREAD_SUCCESS',
   failed: 'JOIN_THREAD_FAILED',
 });
 const joinThread = (
   callServerEndpoint: CallServerEndpoint,
 ): ((
   request: ClientThreadJoinRequest,
 ) => Promise<ThreadJoinPayload>) => async request => {
   const response = await callServerEndpoint('join_thread', request);
   const userInfos = values(response.userInfos);
   return {
     updatesResult: response.updatesResult,
     rawMessageInfos: response.rawMessageInfos,
     truncationStatuses: response.truncationStatuses,
     userInfos,
   };
 };
 
 const leaveThreadActionTypes = Object.freeze({
   started: 'LEAVE_THREAD_STARTED',
   success: 'LEAVE_THREAD_SUCCESS',
   failed: 'LEAVE_THREAD_FAILED',
 });
 const leaveThread = (
   callServerEndpoint: CallServerEndpoint,
 ): ((threadID: string) => Promise<LeaveThreadPayload>) => async threadID => {
   const response = await callServerEndpoint('leave_thread', { threadID });
   return {
     updatesResult: response.updatesResult,
   };
 };
 
 export {
   deleteThreadActionTypes,
   deleteThread,
   changeThreadSettingsActionTypes,
   changeThreadSettings,
   removeUsersFromThreadActionTypes,
   removeUsersFromThread,
   changeThreadMemberRolesActionTypes,
   changeThreadMemberRoles,
   newThreadActionTypes,
   newThread,
   joinThreadActionTypes,
   joinThread,
   leaveThreadActionTypes,
   leaveThread,
 };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index b88983a1d..b079c7831 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,449 +1,449 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { Shape } from './core';
 import type { CalendarQuery, RawEntryInfo } from './entry-types';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from './message-types';
 import type { ThreadSubscription } from './subscription-types';
 import type { ServerUpdateInfo, ClientUpdateInfo } from './update-types';
 import type { UserInfo, UserInfos } from './user-types';
 
 export const threadTypes = Object.freeze({
   //OPEN: 0,   (DEPRECATED)
   //CLOSED: 1, (DEPRECATED)
   //SECRET: 2, (DEPRECATED)
   // has parent, not top-level (appears under parent in inbox), and visible to
   // all members of parent
   SIDEBAR: 5,
   // canonical thread for each pair of users. represents the friendship
   PERSONAL: 6,
   // canonical thread for each single user
   PRIVATE: 7,
   // local "thick" thread (outside of community). no parent, can only have
   // sidebar children. currently a proxy for COMMUNITY_SECRET_SUBTHREAD until we
   // launch actual E2E
   LOCAL: 4,
   // aka "org". no parent, top-level, has admin
   COMMUNITY_ROOT: 8,
   // like COMMUNITY_ROOT, but members aren't voiced
   COMMUNITY_ANNOUNCEMENT_ROOT: 9,
   // an open subthread. has parent, top-level (not sidebar), and visible to all
   // members of parent. root ancestor is a COMMUNITY_ROOT
   COMMUNITY_OPEN_SUBTHREAD: 3,
   // like COMMUNITY_SECRET_SUBTHREAD, but members aren't voiced
   COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD: 10,
   // a secret subthread. optional parent, top-level (not sidebar), visible only
   // to its members. root ancestor is a COMMUNITY_ROOT
   COMMUNITY_SECRET_SUBTHREAD: 4,
   // like COMMUNITY_SECRET_SUBTHREAD, but members aren't voiced
   COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD: 11,
   // like COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD, but you can't leave
   GENESIS: 12,
 });
 export type ThreadType = $Values<typeof threadTypes>;
 export function assertThreadType(threadType: number): ThreadType {
   invariant(
     threadType === 3 ||
       threadType === 4 ||
       threadType === 5 ||
       threadType === 6 ||
       threadType === 7 ||
       threadType === 8 ||
       threadType === 9 ||
       threadType === 10 ||
       threadType === 11 ||
       threadType === 12,
     'number is not ThreadType enum',
   );
   return threadType;
 }
 export const communityThreadTypes: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.COMMUNITY_ROOT,
   threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT,
   threadTypes.GENESIS,
 ]);
 
 export const communitySubthreads: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.COMMUNITY_OPEN_SUBTHREAD,
   threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD,
   threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD,
 ]);
 
 export function threadTypeIsCommunityRoot(threadType: ThreadType): boolean {
   return communityThreadTypes.includes(threadType);
 }
 
 export const threadPermissions = Object.freeze({
   KNOW_OF: 'know_of',
   MEMBERSHIP_DEPRECATED: 'membership',
   VISIBLE: 'visible',
   VOICED: 'voiced',
   EDIT_ENTRIES: 'edit_entries',
   EDIT_THREAD_NAME: 'edit_thread',
   EDIT_THREAD_DESCRIPTION: 'edit_thread_description',
   EDIT_THREAD_COLOR: 'edit_thread_color',
   DELETE_THREAD: 'delete_thread',
   CREATE_SUBCHANNELS: 'create_subthreads',
   CREATE_SIDEBARS: 'create_sidebars',
   JOIN_THREAD: 'join_thread',
   EDIT_PERMISSIONS: 'edit_permissions',
   ADD_MEMBERS: 'add_members',
   REMOVE_MEMBERS: 'remove_members',
   CHANGE_ROLE: 'change_role',
   LEAVE_THREAD: 'leave_thread',
 });
 export type ThreadPermission = $Values<typeof threadPermissions>;
 export function assertThreadPermissions(
   ourThreadPermissions: string,
 ): ThreadPermission {
   invariant(
     ourThreadPermissions === 'know_of' ||
       ourThreadPermissions === 'membership' ||
       ourThreadPermissions === 'visible' ||
       ourThreadPermissions === 'voiced' ||
       ourThreadPermissions === 'edit_entries' ||
       ourThreadPermissions === 'edit_thread' ||
       ourThreadPermissions === 'edit_thread_description' ||
       ourThreadPermissions === 'edit_thread_color' ||
       ourThreadPermissions === 'delete_thread' ||
       ourThreadPermissions === 'create_subthreads' ||
       ourThreadPermissions === 'create_sidebars' ||
       ourThreadPermissions === 'join_thread' ||
       ourThreadPermissions === 'edit_permissions' ||
       ourThreadPermissions === 'add_members' ||
       ourThreadPermissions === 'remove_members' ||
       ourThreadPermissions === 'change_role' ||
       ourThreadPermissions === 'leave_thread',
     'string is not threadPermissions enum',
   );
   return ourThreadPermissions;
 }
 
 export const threadPermissionPropagationPrefixes = Object.freeze({
   DESCENDANT: 'descendant_',
   CHILD: 'child_',
 });
 export type ThreadPermissionPropagationPrefix = $Values<
   typeof threadPermissionPropagationPrefixes,
 >;
 
 export const threadPermissionFilterPrefixes = Object.freeze({
   // includes only SIDEBAR, COMMUNITY_OPEN_SUBTHREAD,
   // COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   OPEN: 'open_',
   // excludes only SIDEBAR
   TOP_LEVEL: 'toplevel_',
   // includes only COMMUNITY_OPEN_SUBTHREAD,
   // COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   OPEN_TOP_LEVEL: 'opentoplevel_',
 });
 export type ThreadPermissionFilterPrefix = $Values<
   typeof threadPermissionFilterPrefixes,
 >;
 
 export type ThreadPermissionInfo =
   | { +value: true, +source: string }
   | { +value: false, +source: null };
 
 export type ThreadPermissionsBlob = {
   +[permission: string]: ThreadPermissionInfo,
 };
 export type ThreadRolePermissionsBlob = { +[permission: string]: boolean };
 
 export type ThreadPermissionsInfo = {
   +[permission: ThreadPermission]: ThreadPermissionInfo,
 };
 
 export type MemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 
 export type RelativeMemberInfo = {
   ...MemberInfo,
   +username: ?string,
   +isViewer: boolean,
 };
 
 export type RoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 
 export type ThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 
 export type RawThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +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,
 };
 
 export type ThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string,
   +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,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +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,
 };
 
 export type ThreadStore = {
   +threadInfos: { +[id: string]: RawThreadInfo },
 };
 
 export type RemoveThreadOperation = {
   +type: 'remove',
   +payload: { +ids: $ReadOnlyArray<string> },
 };
 
 export type RemoveAllThreadsOperation = {
   +type: 'remove_all',
 };
 
 export type ReplaceThreadOperation = {
   +type: 'replace',
   +payload: { +id: string, +threadInfo: RawThreadInfo },
 };
 
 export type ThreadStoreOperation =
   | RemoveThreadOperation
   | RemoveAllThreadsOperation
   | ReplaceThreadOperation;
 
 export type ClientDBThreadInfo = {
   +id: string,
   +type: number,
   +name: ?string,
   +description: ?string,
   +color: string,
   +creationTime: string,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: string,
   +roles: string,
   +currentUser: string,
   +sourceMessageID?: string,
   +repliesCount: number,
 };
 
 export type ClientDBReplaceThreadOperation = {
   +type: 'replace',
   +payload: ClientDBThreadInfo,
 };
 
 export type ClientDBThreadStoreOperation =
   | RemoveThreadOperation
   | RemoveAllThreadsOperation
   | ClientDBReplaceThreadOperation;
 
 export type ThreadDeletionRequest = {
   +threadID: string,
-  +accountPassword: string,
+  +accountPassword: ?string,
 };
 
 export type RemoveMembersRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 export type RoleChangeRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +role: string,
 };
 
 export type ChangeThreadSettingsResult = {
   +threadInfo?: RawThreadInfo,
   +threadInfos?: { +[id: string]: RawThreadInfo },
   +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 = {
   +threadInfos?: { +[id: string]: RawThreadInfo },
   +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>,
 }>;
 
 export type UpdateThreadRequest = {
   +threadID: string,
   +changes: ThreadChanges,
 };
 
 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>,
   +newThreadInfo?: RawThreadInfo,
   +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,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
 };
 export type ThreadJoinResult = {
   threadInfos?: { +[id: string]: RawThreadInfo },
   updatesResult: {
     newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatuses: MessageTruncationStatuses,
   userInfos: UserInfos,
   rawEntryInfos?: ?$ReadOnlyArray<RawEntryInfo>,
 };
 export type ThreadJoinPayload = {
   +updatesResult: {
     newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type SidebarInfo = {
   +threadInfo: ThreadInfo,
   +lastUpdatedTime: number,
   +mostRecentNonLocalMessage: ?string,
 };
 
 // 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;