diff --git a/lib/types/avatar-types.js b/lib/types/avatar-types.js
index 42136b76d..23b9251a7 100644
--- a/lib/types/avatar-types.js
+++ b/lib/types/avatar-types.js
@@ -1,47 +1,69 @@
 // @flow
 
+import t, { type TUnion } from 'tcomb';
+
 import type { CreateUpdatesResult } from './update-types.js';
+import { tShape, tString } from '../utils/validation-utils.js';
 
 export type EmojiAvatarDBContent = {
   +type: 'emoji',
   +emoji: string,
   +color: string, // hex, without "#" or "0x"
 };
+const emojiAvatarDBContentValidator = tShape<EmojiAvatarDBContent>({
+  type: tString('emoji'),
+  emoji: t.String,
+  color: t.String,
+});
 
 export type ImageAvatarDBContent = {
   +type: 'image',
   +uploadID: string,
 };
 
 export type ENSAvatarDBContent = {
   +type: 'ens',
 };
+const ensAvatarDBContentValidator = tShape({ type: tString('ens') });
 
 export type AvatarDBContent =
   | EmojiAvatarDBContent
   | ImageAvatarDBContent
   | ENSAvatarDBContent;
 
 export type UpdateUserAvatarRemoveRequest = { +type: 'remove' };
 
 export type UpdateUserAvatarRequest =
   | AvatarDBContent
   | UpdateUserAvatarRemoveRequest;
 
 export type ClientEmojiAvatar = EmojiAvatarDBContent;
+const clientEmojiAvatarValidator = emojiAvatarDBContentValidator;
+
 export type ClientImageAvatar = {
   +type: 'image',
   +uri: string,
 };
+const clientImageAvatarValidator = tShape<ClientImageAvatar>({
+  type: tString('image'),
+  uri: t.String,
+});
+
 export type ClientENSAvatar = ENSAvatarDBContent;
+const clientENSAvatarValidator = ensAvatarDBContentValidator;
 
 export type ClientAvatar =
   | ClientEmojiAvatar
   | ClientImageAvatar
   | ClientENSAvatar;
+export const clientAvatarValidator: TUnion<ClientAvatar> = t.union([
+  clientEmojiAvatarValidator,
+  clientImageAvatarValidator,
+  clientENSAvatarValidator,
+]);
 
 export type ResolvedClientAvatar = ClientEmojiAvatar | ClientImageAvatar;
 
 export type UpdateUserAvatarResponse = {
   +updates: CreateUpdatesResult,
 };
diff --git a/lib/types/subscription-types.js b/lib/types/subscription-types.js
index fc392dcce..3b8ffedcb 100644
--- a/lib/types/subscription-types.js
+++ b/lib/types/subscription-types.js
@@ -1,27 +1,34 @@
 // @flow
 
+import _mapValues from 'lodash/fp/mapValues.js';
+import t, { type TInterface } from 'tcomb';
+
 import type { Shape } from './core.js';
+import { tShape } from '../utils/validation-utils.js';
 
 export const threadSubscriptions = Object.freeze({
   home: 'home',
   pushNotifs: 'pushNotifs',
 });
 
 export type ThreadSubscription = $ObjMap<
   typeof threadSubscriptions,
   () => boolean,
 >;
 
+export const threadSubscriptionValidator: TInterface<ThreadSubscription> =
+  tShape<ThreadSubscription>(_mapValues(() => t.Boolean)(threadSubscriptions));
+
 export type SubscriptionUpdateRequest = {
   threadID: string,
   updatedFields: Shape<ThreadSubscription>,
 };
 
 export type SubscriptionUpdateResponse = {
   threadSubscription: ThreadSubscription,
 };
 
 export type SubscriptionUpdateResult = {
   threadID: string,
   subscription: ThreadSubscription,
 };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 8db32b407..b2b70c757 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,516 +1,573 @@
 // @flow
 
 import invariant from 'invariant';
+import t, { type TInterface } from 'tcomb';
 
-import type {
-  AvatarDBContent,
-  ClientAvatar,
-  UpdateUserAvatarRequest,
+import {
+  type AvatarDBContent,
+  type ClientAvatar,
+  type UpdateUserAvatarRequest,
+  clientAvatarValidator,
 } from './avatar-types.js';
 import type { Shape } from './core.js';
 import type { CalendarQuery, RawEntryInfo } from './entry-types.js';
 import type { Media } from './media-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from './message-types.js';
-import type { ThreadSubscription } from './subscription-types.js';
+import {
+  type ThreadSubscription,
+  threadSubscriptionValidator,
+} from './subscription-types.js';
 import type { ServerUpdateInfo, ClientUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import type { ThreadEntity } from '../utils/entity-text.js';
+import { values } from '../utils/objects.js';
+import { tNumEnum, tBool, tID, tShape } from '../utils/validation-utils.js';
 
 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;
 }
+const threadTypeValidator = tNumEnum(values(threadTypes));
+
 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',
   REACT_TO_MESSAGE: 'react_to_message',
   EDIT_MESSAGE: 'edit_message',
   EDIT_THREAD_AVATAR: 'edit_thread_avatar',
   MANAGE_PINS: 'manage_pins',
 });
 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' ||
       ourThreadPermissions === 'react_to_message' ||
       ourThreadPermissions === 'edit_message' ||
       ourThreadPermissions === 'edit_thread_avatar' ||
       ourThreadPermissions === 'manage_pins',
     'string is not threadPermissions enum',
   );
   return ourThreadPermissions;
 }
+const threadPermissionValidator = t.enums.of(values(threadPermissions));
 
 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 };
 
+const threadPermissionInfoValidator = t.union([
+  tShape({ value: tBool(true), source: t.String }),
+  tShape({ value: tBool(false), source: t.Nil }),
+]);
+
 export type ThreadPermissionsBlob = {
   +[permission: string]: ThreadPermissionInfo,
 };
 export type ThreadRolePermissionsBlob = { +[permission: string]: boolean };
+const threadRolePermissionsBlobValidator = t.dict(t.String, t.Boolean);
 
 export type ThreadPermissionsInfo = {
   +[permission: ThreadPermission]: ThreadPermissionInfo,
 };
+const threadPermissionsInfoValidator = t.dict(
+  threadPermissionValidator,
+  threadPermissionInfoValidator,
+);
 
 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,
 };
 
 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 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 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 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,
   +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 ClientDBReplaceThreadOperation = {
   +type: 'replace',
   +payload: ClientDBThreadInfo,
 };
 
 export type ClientDBThreadStoreOperation =
   | RemoveThreadOperation
   | RemoveAllThreadsOperation
   | ClientDBReplaceThreadOperation;
 
 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 = {
   +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>,
   +avatar: UpdateUserAvatarRequest,
 }>;
 
 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,
   +inviteLinkSecret?: string,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
 };
 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 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,
 };
 
 // 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 };
diff --git a/lib/types/validation.test.js b/lib/types/validation.test.js
index 13714556a..158a79d88 100644
--- a/lib/types/validation.test.js
+++ b/lib/types/validation.test.js
@@ -1,321 +1,635 @@
 // @flow
 
 import _findKey from 'lodash/fp/findKey.js';
 
 import {
   imageValidator,
   videoValidator,
   mediaValidator,
 } from './media-types.js';
 import { messageTypes } from './message-types-enum.js';
+import { threadTypes, rawThreadInfoValidator } from './thread-types.js';
 import { messageSpecs } from '../shared/messages/message-specs.js';
 
 describe('media validation', () => {
   const photo = {
     id: '92696',
     type: 'photo',
     uri: 'http://0.0.0.0:3000/comm/upload/92696/0fb272bd1c75d976',
     dimensions: {
       width: 340,
       height: 288,
     },
   };
   const video = {
     type: 'video',
     id: '92769',
     uri: 'http://0.0.0.0:3000/comm/upload/92769/4bcc6987b25b2f66',
     dimensions: {
       width: 480,
       height: 270,
     },
     thumbnailID: '92770',
     thumbnailURI: 'http://0.0.0.0:3000/comm/upload/92770/d56466051dcef1db',
   };
 
   it('should validate correct media', () => {
     expect(mediaValidator.is(photo)).toBe(true);
     expect(imageValidator.is(photo)).toBe(true);
     expect(mediaValidator.is(video)).toBe(true);
     expect(videoValidator.is(video)).toBe(true);
   });
 
   it('should not validate incorrect media', () => {
     expect(imageValidator.is(video)).toBe(false);
     expect(videoValidator.is(photo)).toBe(false);
     expect(mediaValidator.is({ ...photo, type: undefined })).toBe(false);
     expect(mediaValidator.is({ ...video, dimensions: undefined })).toBe(false);
   });
 });
 
 describe('message validation', () => {
   const messages = [
     {
       type: messageTypes.TEXT,
       threadID: '83859',
       creatorID: '83853',
       time: 1682077048858,
       text: 'text',
       localID: 'local1',
       id: '92837',
     },
     {
       type: messageTypes.CREATE_THREAD,
       id: '83876',
       threadID: '83859',
       time: 1673561105839,
       creatorID: '83853',
       initialThreadState: {
         type: 6,
         name: null,
         parentThreadID: '1',
         color: '57697f',
         memberIDs: ['256', '83853'],
       },
     },
     {
       type: messageTypes.ADD_MEMBERS,
       id: '4754380',
       threadID: '4746046',
       time: 1680179819346,
       creatorID: '256',
       addedUserIDs: ['518252', '1329299', '1559042'],
     },
     {
       type: messageTypes.CREATE_SUB_THREAD,
       threadID: '87111',
       creatorID: '83928',
       time: 1682083573756,
       childThreadID: '92993',
       id: '93000',
     },
     {
       type: messageTypes.CHANGE_SETTINGS,
       threadID: '83859',
       creatorID: '83853',
       time: 1682082984605,
       field: 'color',
       value: 'b8753d',
       id: '92880',
     },
     {
       type: messageTypes.REMOVE_MEMBERS,
       threadID: '92993',
       creatorID: '83928',
       time: 1682083613415,
       removedUserIDs: ['83890'],
       id: '93012',
     },
     {
       type: messageTypes.CHANGE_ROLE,
       threadID: '85027',
       creatorID: '256',
       time: 1632393331694,
       userIDs: ['85081'],
       newRole: 'role',
       id: '85431',
     },
     {
       type: messageTypes.LEAVE_THREAD,
       id: '93027',
       threadID: '92993',
       time: 1682083651037,
       creatorID: '83928',
     },
     {
       type: messageTypes.JOIN_THREAD,
       threadID: '92993',
       creatorID: '83928',
       time: 1682083678595,
       id: '93035',
     },
     {
       type: messageTypes.CREATE_ENTRY,
       threadID: '84695',
       creatorID: '83928',
       time: 1682083217395,
       entryID: '92917',
       date: '2023-04-02',
       text: 'text',
       id: '92920',
     },
     {
       type: messageTypes.EDIT_ENTRY,
       threadID: '84695',
       creatorID: '83928',
       time: 1682083374471,
       entryID: '92917',
       date: '2023-04-02',
       text: 'text',
       id: '92950',
     },
     {
       type: messageTypes.DELETE_ENTRY,
       threadID: '86033',
       creatorID: '83928',
       time: 1682083220296,
       entryID: '92904',
       date: '2023-04-02',
       text: 'text',
       id: '92932',
     },
     {
       type: messageTypes.RESTORE_ENTRY,
       id: '92962',
       threadID: '86033',
       time: 1682083414244,
       creatorID: '83928',
       entryID: '92904',
       date: '2023-04-02',
       text: 'text',
     },
     {
       type: messageTypes.UNSUPPORTED,
       threadID: '87080',
       creatorID: '256',
       time: 1640733462322,
       robotext: 'unsupported message',
       unsupportedMessageInfo: {
         type: 105,
         threadID: '97489',
         creatorID: '256',
         time: 1640773011289,
         id: '97672',
       },
       id: '97730',
     },
     {
       type: messageTypes.IMAGES,
       threadID: '92796',
       creatorID: '83928',
       time: 1682083469079,
       media: [
         {
           id: '92974',
           uri: 'http://0.0.0.0:3000/comm/upload/92974/ff3d02ded71e2762',
           type: 'photo',
           dimensions: {
             width: 220,
             height: 220,
           },
         },
       ],
       localID: 'local0',
       id: '92976',
     },
     {
       type: messageTypes.MULTIMEDIA,
       threadID: '89644',
       creatorID: '83853',
       time: 1682076177257,
       media: [
         {
           type: 'video',
           id: '92769',
           uri: 'http://0.0.0.0:3000/comm/upload/92769/4bcc6987b25b2f66',
           dimensions: {
             width: 480,
             height: 270,
           },
           thumbnailID: '92770',
           thumbnailURI:
             'http://0.0.0.0:3000/comm/upload/92770/d56466051dcef1db',
         },
       ],
       id: '92771',
     },
     {
       type: messageTypes.UPDATE_RELATIONSHIP,
       threadID: '92796',
       creatorID: '83928',
       targetID: '83853',
       time: 1682083716312,
       operation: 'request_sent',
       id: '93039',
     },
     {
       type: messageTypes.SIDEBAR_SOURCE,
       threadID: '93044',
       creatorID: '83928',
       time: 1682083756831,
       sourceMessage: {
         type: 0,
         id: '92816',
         threadID: '92796',
         time: 1682076737518,
         creatorID: '83928',
         text: 'text',
       },
       id: '93049',
     },
     {
       type: messageTypes.CREATE_SIDEBAR,
       threadID: '93044',
       creatorID: '83928',
       time: 1682083756831,
       sourceMessageAuthorID: '83928',
       initialThreadState: {
         name: 'text',
         parentThreadID: '92796',
         color: 'aa4b4b',
         memberIDs: ['83853', '83928'],
       },
       id: '93050',
     },
     {
       type: messageTypes.REACTION,
       threadID: '86033',
       localID: 'local8',
       creatorID: '83928',
       time: 1682083295820,
       targetMessageID: '91607',
       reaction: '😂',
       action: 'add_reaction',
       id: '92943',
     },
     {
       type: messageTypes.EDIT_MESSAGE,
       threadID: '86033',
       creatorID: '83928',
       time: 1682083295820,
       targetMessageID: '91607',
       text: 'text',
       id: '92943',
     },
     {
       type: messageTypes.TOGGLE_PIN,
       threadID: '86033',
       targetMessageID: '91607',
       action: 'pin',
       pinnedContent: 'text',
       creatorID: '83928',
       time: 1682083295820,
       id: '92943',
     },
   ];
 
   for (const validatorMessageTypeName in messageTypes) {
     const validatorMessageType = messageTypes[validatorMessageTypeName];
     const validator = messageSpecs[validatorMessageType].validator;
 
     for (const message of messages) {
       const messageTypeName = _findKey(e => e === message.type)(messageTypes);
 
       if (validatorMessageType === message.type) {
         it(`${validatorMessageTypeName} should validate ${messageTypeName}`, () => {
           expect(validator.is(message)).toBe(true);
         });
       } else if (
         !(
           (validatorMessageType === messageTypes.IMAGES &&
             message.type === messageTypes.MULTIMEDIA) ||
           (validatorMessageType === messageTypes.MULTIMEDIA &&
             message.type === messageTypes.IMAGES)
         )
       ) {
         it(`${validatorMessageTypeName} shouldn't validate ${messageTypeName}`, () => {
           expect(validator.is(message)).toBe(false);
         });
       }
     }
   }
 });
+
+describe('thread validation', () => {
+  const thread = {
+    id: '85171',
+    type: threadTypes.PERSONAL,
+    name: '',
+    description: '',
+    color: '6d49ab',
+    creationTime: 1675887298557,
+    parentThreadID: '1',
+    members: [
+      {
+        id: '256',
+        role: null,
+        permissions: {
+          know_of: {
+            value: true,
+            source: '1',
+          },
+          membership: {
+            value: false,
+            source: null,
+          },
+          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: true,
+            source: '1',
+          },
+          edit_permissions: {
+            value: true,
+            source: '1',
+          },
+          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: false,
+            source: null,
+          },
+          edit_message: {
+            value: false,
+            source: null,
+          },
+          manage_pins: {
+            value: true,
+            source: '1',
+          },
+        },
+        isSender: false,
+      },
+      {
+        id: '83853',
+        role: '85172',
+        permissions: {
+          know_of: {
+            value: true,
+            source: '85171',
+          },
+          membership: {
+            value: false,
+            source: null,
+          },
+          visible: {
+            value: true,
+            source: '85171',
+          },
+          voiced: {
+            value: true,
+            source: '85171',
+          },
+          edit_entries: {
+            value: true,
+            source: '85171',
+          },
+          edit_thread: {
+            value: true,
+            source: '85171',
+          },
+          edit_thread_description: {
+            value: true,
+            source: '85171',
+          },
+          edit_thread_color: {
+            value: true,
+            source: '85171',
+          },
+          delete_thread: {
+            value: false,
+            source: null,
+          },
+          create_subthreads: {
+            value: false,
+            source: null,
+          },
+          create_sidebars: {
+            value: true,
+            source: '85171',
+          },
+          join_thread: {
+            value: false,
+            source: null,
+          },
+          edit_permissions: {
+            value: false,
+            source: null,
+          },
+          add_members: {
+            value: false,
+            source: null,
+          },
+          remove_members: {
+            value: false,
+            source: null,
+          },
+          change_role: {
+            value: false,
+            source: null,
+          },
+          leave_thread: {
+            value: false,
+            source: null,
+          },
+          react_to_message: {
+            value: true,
+            source: '85171',
+          },
+          edit_message: {
+            value: true,
+            source: '85171',
+          },
+          manage_pins: {
+            value: false,
+            source: null,
+          },
+        },
+        isSender: true,
+      },
+    ],
+    roles: {
+      '85172': {
+        id: '85172',
+        name: 'Members',
+        permissions: {
+          know_of: true,
+          visible: true,
+          voiced: true,
+          react_to_message: true,
+          edit_message: true,
+          edit_entries: true,
+          edit_thread: true,
+          edit_thread_color: true,
+          edit_thread_description: true,
+          create_sidebars: true,
+          descendant_open_know_of: true,
+          descendant_open_visible: true,
+          child_open_join_thread: true,
+        },
+        isDefault: true,
+      },
+    },
+    currentUser: {
+      role: '85172',
+      permissions: {
+        know_of: {
+          value: true,
+          source: '85171',
+        },
+        membership: {
+          value: false,
+          source: null,
+        },
+        visible: {
+          value: true,
+          source: '85171',
+        },
+        voiced: {
+          value: true,
+          source: '85171',
+        },
+        edit_entries: {
+          value: true,
+          source: '85171',
+        },
+        edit_thread: {
+          value: true,
+          source: '85171',
+        },
+        edit_thread_description: {
+          value: true,
+          source: '85171',
+        },
+        edit_thread_color: {
+          value: true,
+          source: '85171',
+        },
+        delete_thread: {
+          value: false,
+          source: null,
+        },
+        create_subthreads: {
+          value: false,
+          source: null,
+        },
+        create_sidebars: {
+          value: true,
+          source: '85171',
+        },
+        join_thread: {
+          value: false,
+          source: null,
+        },
+        edit_permissions: {
+          value: false,
+          source: null,
+        },
+        add_members: {
+          value: false,
+          source: null,
+        },
+        remove_members: {
+          value: false,
+          source: null,
+        },
+        change_role: {
+          value: false,
+          source: null,
+        },
+        leave_thread: {
+          value: false,
+          source: null,
+        },
+        react_to_message: {
+          value: true,
+          source: '85171',
+        },
+        edit_message: {
+          value: true,
+          source: '85171',
+        },
+        manage_pins: {
+          value: false,
+          source: null,
+        },
+      },
+      subscription: {
+        home: true,
+        pushNotifs: true,
+      },
+      unread: false,
+    },
+    repliesCount: 0,
+    containingThreadID: '1',
+    community: '1',
+    pinnedCount: 0,
+  };
+
+  it('should validate correct thread', () => {
+    expect(rawThreadInfoValidator.is(thread)).toBe(true);
+  });
+  it('should not validate incorrect thread', () => {
+    expect(
+      rawThreadInfoValidator.is({ ...thread, creationTime: undefined }),
+    ).toBe(false);
+  });
+});