diff --git a/lib/permissions/minimally-encoded-thread-permissions.js b/lib/permissions/minimally-encoded-thread-permissions.js
index b414d9162..7ca586a1d 100644
--- a/lib/permissions/minimally-encoded-thread-permissions.js
+++ b/lib/permissions/minimally-encoded-thread-permissions.js
@@ -1,189 +1,207 @@
 // @flow
 
 import invariant from 'invariant';
+import t, { type TInterface } from 'tcomb';
 
 import { parseThreadPermissionString } from './prefixes.js';
 import type {
   ThreadPermission,
   ThreadPermissionsInfo,
   ThreadRolePermissionsBlob,
 } from '../types/thread-permission-types.js';
+import type { RoleInfo } from '../types/thread-types.js';
+import { roleInfoValidator } from '../types/thread-types.js';
 import { entries, invertObjectToMap } from '../utils/objects.js';
+import { tRegex, tShape } from '../utils/validation-utils.js';
+import type { TRegex } from '../utils/validation-utils.js';
 
 // `baseRolePermissionEncoding` maps permission names to indices.
 // These indices represent the 6-bit basePermission part of the 10-bit role
 // permission encoding created by `rolePermissionToBitmaskHex`.
 // The 6-bit basePermission allows for up to 2^6 = 64 different permissions.
 // If more than 64 permissions are needed, the encoding in
 // `rolePermissionToBitmaskHex` will need to be updated to accommodate this.
 const baseRolePermissionEncoding = Object.freeze({
   // TODO (atul): Update flow to `194.0.0` for bigint support
   // $FlowIssue bigint-unsupported
   know_of: BigInt(0),
   visible: BigInt(1),
   voiced: BigInt(2),
   edit_entries: BigInt(3),
   edit_thread: BigInt(4), // EDIT_THREAD_NAME
   edit_thread_description: BigInt(5),
   edit_thread_color: BigInt(6),
   delete_thread: BigInt(7),
   create_subthreads: BigInt(8), // CREATE_SUBCHANNELS
   create_sidebars: BigInt(9),
   join_thread: BigInt(10),
   edit_permissions: BigInt(11),
   add_members: BigInt(12),
   remove_members: BigInt(13),
   change_role: BigInt(14),
   leave_thread: BigInt(15),
   react_to_message: BigInt(16),
   edit_message: BigInt(17),
   edit_thread_avatar: BigInt(18),
   manage_pins: BigInt(19),
   manage_invite_links: BigInt(20),
 });
 
 // `minimallyEncodedThreadPermissions` is used to map each permission
 // to its respective bitmask where the index from `baseRolePermissionEncoding`
 // is used to set a specific bit in the bitmask. This is used in the
 // `permissionsToBitmaskHex` function where each permission is represented as a
 // single bit and the final bitmask is the union of all granted permissions.
 const minimallyEncodedThreadPermissions = Object.fromEntries(
   Object.keys(baseRolePermissionEncoding).map((key, idx) => [
     key,
     BigInt(1) << BigInt(idx),
   ]),
 );
 
 // This function converts a set of permissions to a hex-encoded bitmask.
 // Each permission is represented as a single bit in the bitmask.
 const permissionsToBitmaskHex = (
   permissions: ThreadPermissionsInfo,
 ): string => {
   let bitmask = BigInt(0);
   for (const [key, permission] of entries(permissions)) {
     if (permission.value && key in minimallyEncodedThreadPermissions) {
       invariant(
         // TODO (atul): Update flow to `194.0.0` for bigint support
         // $FlowIssue illegal-typeof
         typeof minimallyEncodedThreadPermissions[key] === 'bigint',
         'must be bigint',
       );
       bitmask |= minimallyEncodedThreadPermissions[key];
     }
   }
   return bitmask.toString(16);
 };
 
 const hasPermission = (
   permissionsBitmaskHex: string,
   permission: ThreadPermission,
 ): boolean => {
   const permissionsBitmask = BigInt(`0x${permissionsBitmaskHex}`);
   if (!(permission in minimallyEncodedThreadPermissions)) {
     return false;
   }
   const permissionBitmask = minimallyEncodedThreadPermissions[permission];
   invariant(
     // TODO (atul): Update flow to `194.0.0` for bigint support
     // $FlowIssue illegal-typeof
     typeof permissionBitmask === 'bigint',
     'permissionBitmask must be of type bigint',
   );
   return (permissionsBitmask & permissionBitmask) !== BigInt(0);
 };
 
 const propagationPrefixes = Object.freeze({
   '': BigInt(0),
   'descendant_': BigInt(1),
   'child_': BigInt(2),
 });
 const filterPrefixes = Object.freeze({
   '': BigInt(0),
   'open_': BigInt(1),
   'toplevel_': BigInt(2),
   'opentoplevel_': BigInt(3),
 });
 
 // Role Permission Bitmask Structure
 // [9 8 7 6 5 4 3 2 1 0] - bit positions
 // [b b b b b b p p f f] - symbol representation
 // b = basePermission    (6 bits)
 // p = propagationPrefix (2 bits)
 // f = filterPrefix      (2 bits)
 const rolePermissionToBitmaskHex = (threadRolePermission: string): string => {
   const parsed = parseThreadPermissionString(threadRolePermission);
   const basePermissionBits =
     baseRolePermissionEncoding[parsed.permission] & BigInt(63);
   const propagationPrefixBits =
     propagationPrefixes[parsed.propagationPrefix ?? ''] & BigInt(3);
   const filterPrefixBits =
     filterPrefixes[parsed.filterPrefix ?? ''] & BigInt(3);
 
   const bitmask =
     (basePermissionBits << BigInt(4)) |
     (propagationPrefixBits << BigInt(2)) |
     filterPrefixBits;
 
   return bitmask.toString(16).padStart(3, '0');
 };
 
 const inverseBaseRolePermissionEncoding = invertObjectToMap(
   baseRolePermissionEncoding,
 );
 
 // $FlowIssue bigint-unsupported
 const inversePropagationPrefixes: Map<bigint, string> =
   invertObjectToMap(propagationPrefixes);
 
 // $FlowIssue bigint-unsupported
 const inverseFilterPrefixes: Map<bigint, string> =
   invertObjectToMap(filterPrefixes);
 
 const decodeRolePermissionBitmask = (bitmask: string): string => {
   const bitmaskInt = BigInt(`0x${bitmask}`);
   const basePermission = (bitmaskInt >> BigInt(4)) & BigInt(63);
   const propagationPrefix = (bitmaskInt >> BigInt(2)) & BigInt(3);
   const filterPrefix = bitmaskInt & BigInt(3);
 
   const basePermissionString =
     inverseBaseRolePermissionEncoding.get(basePermission);
   const propagationPrefixString =
     inversePropagationPrefixes.get(propagationPrefix) ?? '';
   const filterPrefixString = inverseFilterPrefixes.get(filterPrefix) ?? '';
 
   invariant(
     basePermissionString !== null &&
       basePermissionString !== undefined &&
       propagationPrefixString !== null &&
       propagationPrefixString !== undefined &&
       filterPrefixString !== null &&
       filterPrefixString !== undefined,
     'invalid bitmask',
   );
 
   return `${propagationPrefixString}${filterPrefixString}${basePermissionString}`;
 };
 
 const threadRolePermissionsBlobToBitmaskArray = (
   threadRolePermissionsBlob: ThreadRolePermissionsBlob,
 ): $ReadOnlyArray<string> =>
   Object.keys(threadRolePermissionsBlob).map(rolePermissionToBitmaskHex);
 
 const decodeThreadRolePermissionsBitmaskArray = (
   threadRolePermissionsBitmaskArray: $ReadOnlyArray<string>,
 ): ThreadRolePermissionsBlob =>
   Object.fromEntries(
     threadRolePermissionsBitmaskArray.map(bitmask => [
       decodeRolePermissionBitmask(bitmask),
       true,
     ]),
   );
 
+export type MinimallyEncodedRoleInfo = {
+  ...RoleInfo,
+  +permissions: $ReadOnlyArray<string>,
+};
+
+const tHexEncodedRolePermission: TRegex = tRegex(/^[0-9a-fA-F]{3,}$/);
+const minimallyEncodedRoleInfoValidator: TInterface<MinimallyEncodedRoleInfo> =
+  tShape<MinimallyEncodedRoleInfo>({
+    ...roleInfoValidator.meta.props,
+    permissions: t.list(tHexEncodedRolePermission),
+  });
+
 export {
   permissionsToBitmaskHex,
   hasPermission,
   rolePermissionToBitmaskHex,
   decodeRolePermissionBitmask,
   threadRolePermissionsBlobToBitmaskArray,
   decodeThreadRolePermissionsBitmaskArray,
+  minimallyEncodedRoleInfoValidator,
 };
diff --git a/lib/permissions/minimally-encoded-thread-permissions.test.js b/lib/permissions/minimally-encoded-thread-permissions.test.js
index 4eabf77cc..cdced14b7 100644
--- a/lib/permissions/minimally-encoded-thread-permissions.test.js
+++ b/lib/permissions/minimally-encoded-thread-permissions.test.js
@@ -1,223 +1,284 @@
 // @flow
 
 import {
   decodeRolePermissionBitmask,
   decodeThreadRolePermissionsBitmaskArray,
   hasPermission,
+  minimallyEncodedRoleInfoValidator,
   permissionsToBitmaskHex,
   rolePermissionToBitmaskHex,
   threadRolePermissionsBlobToBitmaskArray,
 } from './minimally-encoded-thread-permissions.js';
 import type { ThreadRolePermissionsBlob } from '../types/thread-permission-types.js';
 
 describe('minimallyEncodedThreadPermissions', () => {
   const permissions = {
     know_of: { value: true, source: '1' },
     visible: { value: true, source: '1' },
     voiced: { value: true, source: '1' },
     edit_entries: { value: true, source: '1' },
     edit_thread: { value: true, source: '1' },
     edit_thread_description: { value: true, source: '1' },
     edit_thread_color: { value: true, source: '1' },
     delete_thread: { value: true, source: '1' },
     create_subthreads: { value: true, source: '1' },
     create_sidebars: { value: true, source: '1' },
     join_thread: { value: false, source: null },
     edit_permissions: { value: false, source: null },
     add_members: { value: true, source: '1' },
     remove_members: { value: true, source: '1' },
     change_role: { value: true, source: '1' },
     leave_thread: { value: false, source: null },
     react_to_message: { value: true, source: '1' },
     edit_message: { value: true, source: '1' },
   };
 
   it('should encode ThreadPermissionsInfo as bitmask', () => {
     const permissionsBitmask = permissionsToBitmaskHex(permissions);
     expect(permissionsBitmask).toBe('373ff');
     expect(hasPermission(permissionsBitmask, 'know_of')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'visible')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'voiced')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_entries')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_thread')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_thread_description')).toBe(
       true,
     );
     expect(hasPermission(permissionsBitmask, 'edit_thread_color')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'delete_thread')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'create_subthreads')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'create_sidebars')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'join_thread')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'edit_permissions')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'remove_members')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'change_role')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'leave_thread')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'react_to_message')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_message')).toBe(true);
   });
 });
 
 describe('rolePermissionToBitmaskHex', () => {
   it('should encode `child_opentoplevel_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_visible')).toBe(
       '01b',
     );
   });
 
   it('should encode `child_opentoplevel_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_know_of')).toBe(
       '00b',
     );
   });
 
   it('should encode `child_toplevel_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_toplevel_visible')).toBe('01a');
   });
 
   it('should encode `child_toplevel_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_toplevel_know_of')).toBe('00a');
   });
 
   it('should encode `child_opentoplevel_join_thread` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_join_thread')).toBe(
       '0ab',
     );
   });
 
   it('should encode `child_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_visible')).toBe('018');
   });
 
   it('should encode `child_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_know_of')).toBe('008');
   });
 });
 
 describe('decodeRolePermissionBitmask', () => {
   it('should decode `01b` to `child_opentoplevel_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('01b')).toBe(
       'child_opentoplevel_visible',
     );
   });
 
   it('should decode `00b` to `child_opentoplevel_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('00b')).toBe(
       'child_opentoplevel_know_of',
     );
   });
 
   it('should decode `01a` to `child_toplevel_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('01a')).toBe('child_toplevel_visible');
   });
 
   it('should decode `00a` to `child_toplevel_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('00a')).toBe('child_toplevel_know_of');
   });
 
   it('should decode `0ab` to `child_opentoplevel_join_thread` successfully', () => {
     expect(decodeRolePermissionBitmask('0ab')).toBe(
       'child_opentoplevel_join_thread',
     );
   });
 
   it('should decode `018` to `child_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('018')).toBe('child_visible');
   });
 
   it('should decode `008` to `child_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('008')).toBe('child_know_of');
   });
 });
 
 const threadRolePermissionsBlob: ThreadRolePermissionsBlob = {
   add_members: true,
   child_open_join_thread: true,
   create_sidebars: true,
   create_subthreads: true,
   descendant_open_know_of: true,
   descendant_open_visible: true,
   descendant_opentoplevel_join_thread: true,
   edit_entries: true,
   edit_message: true,
   edit_permissions: true,
   edit_thread: true,
   edit_thread_avatar: true,
   edit_thread_color: true,
   edit_thread_description: true,
   know_of: true,
   leave_thread: true,
   react_to_message: true,
   remove_members: true,
   visible: true,
   voiced: true,
   open_know_of: true,
   open_visible: true,
   opentoplevel_join_thread: true,
   toplevel_know_of: true,
   toplevel_visible: true,
   opentoplevel_know_of: true,
   opentoplevel_visible: true,
   child_know_of: true,
   child_visible: true,
   child_opentoplevel_join_thread: true,
   child_toplevel_know_of: true,
   child_toplevel_visible: true,
   child_opentoplevel_know_of: true,
   child_opentoplevel_visible: true,
 };
 
 const threadRolePermissionsBitmaskArray = [
   '0c0',
   '0a9',
   '090',
   '080',
   '005',
   '015',
   '0a7',
   '030',
   '110',
   '0b0',
   '040',
   '120',
   '060',
   '050',
   '000',
   '0f0',
   '100',
   '0d0',
   '010',
   '020',
   '001',
   '011',
   '0a3',
   '002',
   '012',
   '003',
   '013',
   '008',
   '018',
   '0ab',
   '00a',
   '01a',
   '00b',
   '01b',
 ];
 
 describe('threadRolePermissionsBlobToBitmaskArray', () => {
   it('should encode threadRolePermissionsBlob as bitmask array', () => {
     const arr = threadRolePermissionsBlobToBitmaskArray(
       threadRolePermissionsBlob,
     );
     expect(arr).toEqual(threadRolePermissionsBitmaskArray);
   });
 });
 
 describe('decodeThreadRolePermissionsBitmaskArray', () => {
   it('should decode threadRolePermissionsBitmaskArray', () => {
     expect(
       decodeThreadRolePermissionsBitmaskArray(
         threadRolePermissionsBitmaskArray,
       ),
     ).toEqual(threadRolePermissionsBlob);
   });
 });
+
+describe('minimallyEncodedRoleInfoValidator', () => {
+  it('should validate correctly formed MinimallyEncodedRoleInfo', () => {
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 'roleID',
+        name: 'roleName',
+        permissions: ['abc', 'def'],
+        isDefault: true,
+      }),
+    ).toBe(true);
+  });
+
+  it('should NOT validate malformed MinimallyEncodedRoleInfo', () => {
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 1234,
+        name: 'roleName',
+        permissions: ['abc', 'def'],
+        isDefault: true,
+      }),
+    ).toBe(false);
+
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 'roleID',
+        name: 'roleName',
+        permissions: ['hello a02 test', 'def'],
+        isDefault: true,
+      }),
+    ).toBe(false);
+
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 'roleID',
+        name: 'roleName',
+        permissions: [123, 456],
+        isDefault: true,
+      }),
+    ).toBe(false);
+
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 'roleID',
+        name: 'roleName',
+        permissions: ['ZZZ', 'YYY'],
+        isDefault: true,
+      }),
+    ).toBe(false);
+
+    expect(
+      minimallyEncodedRoleInfoValidator.is({
+        id: 'roleID',
+        name: 'roleName',
+        permissions: ['AAAAA', 'YYY'],
+        isDefault: true,
+      }),
+    ).toBe(false);
+  });
+});
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index f3546d13e..2eef807bb 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,471 +1,471 @@
 // @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>({
+export const roleInfoValidator: TInterface<RoleInfo> = 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?: empty,
 };
 
 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,
 };
 
 export type UserProfileThreadInfo = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
diff --git a/lib/utils/validation-utils.js b/lib/utils/validation-utils.js
index e69376699..ce99c2b36 100644
--- a/lib/utils/validation-utils.js
+++ b/lib/utils/validation-utils.js
@@ -1,144 +1,144 @@
 // @flow
 
 import invariant from 'invariant';
 import t from 'tcomb';
 import type {
   TStructProps,
   TIrreducible,
   TRefinement,
   TEnums,
   TInterface,
   TUnion,
   TType,
 } from 'tcomb';
 
 import {
   validEmailRegex,
   oldValidUsernameRegex,
   validHexColorRegex,
 } from '../shared/account-utils.js';
 import type { PlatformDetails } from '../types/device-types';
 import type {
   MediaMessageServerDBContent,
   PhotoMessageServerDBContent,
   VideoMessageServerDBContent,
 } from '../types/messages/media';
 
 function tBool(value: boolean): TIrreducible<boolean> {
   return t.irreducible(value.toString(), x => x === value);
 }
 
 function tString(value: string): TIrreducible<string> {
   return t.irreducible(`'${value}'`, x => x === value);
 }
 
 function tNumber(value: number): TIrreducible<number> {
   return t.irreducible(value.toString(), x => x === value);
 }
 
 function tShape<T>(spec: TStructProps<T>): TInterface<T> {
   return t.interface(spec, { strict: true });
 }
 
-type TRegex = TRefinement<string>;
+export type TRegex = TRefinement<string>;
 function tRegex(regex: RegExp): TRegex {
   return t.refinement(t.String, val => regex.test(val));
 }
 
 function tNumEnum(nums: $ReadOnlyArray<number>): TRefinement<number> {
   return t.refinement(t.Number, (input: number) => {
     for (const num of nums) {
       if (input === num) {
         return true;
       }
     }
     return false;
   });
 }
 const tNull: TIrreducible<null> = t.irreducible('null', x => x === null);
 const tDate: TRegex = tRegex(/^[0-9]{4}-[0-1][0-9]-[0-3][0-9]$/);
 const tColor: TRegex = tRegex(validHexColorRegex); // we don't include # char
 const tPlatform: TEnums = t.enums.of([
   'ios',
   'android',
   'web',
   'windows',
   'macos',
 ]);
 const tDeviceType: TEnums = t.enums.of(['ios', 'android']);
 const tPlatformDetails: TInterface<PlatformDetails> = tShape({
   platform: tPlatform,
   codeVersion: t.maybe(t.Number),
   stateVersion: t.maybe(t.Number),
 });
 const tPassword: TRefinement<string> = t.refinement(
   t.String,
   (password: string) => !!password,
 );
 const tCookie: TRegex = tRegex(/^(user|anonymous)=[0-9]+:[0-9a-f]+$/);
 const tEmail: TRegex = tRegex(validEmailRegex);
 const tOldValidUsername: TRegex = tRegex(oldValidUsernameRegex);
 const tID: TRefinement<string> = t.refinement(t.String, (id: string) => !!id);
 
 const tMediaMessagePhoto: TInterface<PhotoMessageServerDBContent> = tShape({
   type: tString('photo'),
   uploadID: tID,
 });
 
 const tMediaMessageVideo: TInterface<VideoMessageServerDBContent> = tShape({
   type: tString('video'),
   uploadID: tID,
   thumbnailUploadID: tID,
 });
 
 const tMediaMessageMedia: TUnion<MediaMessageServerDBContent> = t.union([
   tMediaMessagePhoto,
   tMediaMessageVideo,
 ]);
 
 function assertWithValidator<T>(data: mixed, validator: TType<T>): T {
   invariant(validator.is(data), "data isn't of type T");
   return (data: any);
 }
 
 const ashoatKeyserverID = '256';
 
 const idSchemaRegex = '(?:[0-9]+\\|)?[0-9]+';
 
 const pendingThreadIDRegex = `pending/(type[0-9]+/[0-9]+(\\+[0-9]+)*|sidebar/${idSchemaRegex})`;
 
 const chatNameMaxLength = 191;
 const chatNameMinLength = 0;
 const secondCharRange = `{${chatNameMinLength},${chatNameMaxLength}}`;
 const validChatNameRegexString = `.${secondCharRange}`;
 const validChatNameRegex: RegExp = new RegExp(`^${validChatNameRegexString}$`);
 
 export {
   tBool,
   tString,
   tNumber,
   tShape,
   tRegex,
   tNumEnum,
   tNull,
   tDate,
   tColor,
   tPlatform,
   tDeviceType,
   tPlatformDetails,
   tPassword,
   tCookie,
   tEmail,
   tOldValidUsername,
   tID,
   tMediaMessagePhoto,
   tMediaMessageVideo,
   tMediaMessageMedia,
   assertWithValidator,
   ashoatKeyserverID,
   idSchemaRegex,
   pendingThreadIDRegex,
   validChatNameRegex,
   validChatNameRegexString,
   chatNameMaxLength,
 };