diff --git a/lib/types/minimally-encoded-thread-permissions-types.js b/lib/types/minimally-encoded-thread-permissions-types.js
index 9998c696e..7f2eb4f59 100644
--- a/lib/types/minimally-encoded-thread-permissions-types.js
+++ b/lib/types/minimally-encoded-thread-permissions-types.js
@@ -1,184 +1,221 @@
 // @flow
 
 import _mapValues from 'lodash/fp/mapValues.js';
 import type { TInterface } from 'tcomb';
 import t from 'tcomb';
 
 import {
   memberInfoValidator,
   rawThreadInfoValidator,
   roleInfoValidator,
   threadCurrentUserInfoValidator,
 } from './thread-types.js';
 import type {
   MemberInfo,
   RawThreadInfo,
+  RelativeMemberInfo,
   RoleInfo,
   ThreadCurrentUserInfo,
 } from './thread-types.js';
 import {
   decodeThreadRolePermissionsBitmaskArray,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
   threadRolePermissionsBlobToBitmaskArray,
   tHexEncodedRolePermission,
   tHexEncodedPermissionsBitmask,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import { tBool, tID, tShape } from '../utils/validation-utils.js';
 
 export type MinimallyEncodedRoleInfo = $ReadOnly<{
   ...RoleInfo,
   +minimallyEncoded: true,
   +permissions: $ReadOnlyArray<string>,
 }>;
 
 const minimallyEncodedRoleInfoValidator: TInterface<MinimallyEncodedRoleInfo> =
   tShape<MinimallyEncodedRoleInfo>({
     ...roleInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
     permissions: t.list(tHexEncodedRolePermission),
   });
 
 const minimallyEncodeRoleInfo = (
   roleInfo: RoleInfo,
 ): MinimallyEncodedRoleInfo => ({
   ...roleInfo,
   minimallyEncoded: true,
   permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
 });
 
 const decodeMinimallyEncodedRoleInfo = (
   minimallyEncodedRoleInfo: MinimallyEncodedRoleInfo,
 ): RoleInfo => {
   const { minimallyEncoded, ...rest } = minimallyEncodedRoleInfo;
   return {
     ...rest,
     permissions: decodeThreadRolePermissionsBitmaskArray(
       minimallyEncodedRoleInfo.permissions,
     ),
   };
 };
 
 export type MinimallyEncodedThreadCurrentUserInfo = $ReadOnly<{
   ...ThreadCurrentUserInfo,
   +minimallyEncoded: true,
   +permissions: string,
 }>;
 
 const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> =
   tShape<MinimallyEncodedThreadCurrentUserInfo>({
     ...threadCurrentUserInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
     permissions: tHexEncodedPermissionsBitmask,
   });
 
 const minimallyEncodeThreadCurrentUserInfo = (
   threadCurrentUserInfo: ThreadCurrentUserInfo,
 ): MinimallyEncodedThreadCurrentUserInfo => ({
   ...threadCurrentUserInfo,
   minimallyEncoded: true,
   permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
 });
 
 const decodeMinimallyEncodedThreadCurrentUserInfo = (
   minimallyEncodedThreadCurrentUserInfo: MinimallyEncodedThreadCurrentUserInfo,
 ): ThreadCurrentUserInfo => {
   const { minimallyEncoded, ...rest } = minimallyEncodedThreadCurrentUserInfo;
   return {
     ...rest,
     permissions: threadPermissionsFromBitmaskHex(
       minimallyEncodedThreadCurrentUserInfo.permissions,
     ),
   };
 };
 
 export type MinimallyEncodedMemberInfo = $ReadOnly<{
   ...MemberInfo,
   +minimallyEncoded: true,
   +permissions: string,
 }>;
 
 const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> =
   tShape<MinimallyEncodedMemberInfo>({
     ...memberInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
     permissions: tHexEncodedPermissionsBitmask,
   });
 
 const minimallyEncodeMemberInfo = (
   memberInfo: MemberInfo,
 ): MinimallyEncodedMemberInfo => ({
   ...memberInfo,
   minimallyEncoded: true,
   permissions: permissionsToBitmaskHex(memberInfo.permissions),
 });
 
 const decodeMinimallyEncodedMemberInfo = (
   minimallyEncodedMemberInfo: MinimallyEncodedMemberInfo,
 ): MemberInfo => {
   const { minimallyEncoded, ...rest } = minimallyEncodedMemberInfo;
   return {
     ...rest,
     permissions: threadPermissionsFromBitmaskHex(
       minimallyEncodedMemberInfo.permissions,
     ),
   };
 };
 
+export type MinimallyEncodedRelativeMemberInfo = $ReadOnly<{
+  ...MinimallyEncodedMemberInfo,
+  +username: ?string,
+  +isViewer: boolean,
+}>;
+
+const minimallyEncodedRelativeMemberInfoValidator: TInterface<MinimallyEncodedRelativeMemberInfo> =
+  tShape<MinimallyEncodedRelativeMemberInfo>({
+    ...minimallyEncodedMemberInfoValidator.meta.props,
+    username: t.maybe(t.String),
+    isViewer: t.Boolean,
+  });
+
+const minimallyEncodeRelativeMemberInfo = (
+  relativeMemberInfo: RelativeMemberInfo,
+): MinimallyEncodedRelativeMemberInfo => ({
+  ...relativeMemberInfo,
+  minimallyEncoded: true,
+  permissions: permissionsToBitmaskHex(relativeMemberInfo.permissions),
+});
+
+const decodeMinimallyEncodedRelativeMemberInfo = (
+  minimallyEncodedRelativeMemberInfo: MinimallyEncodedRelativeMemberInfo,
+): RelativeMemberInfo => {
+  const { minimallyEncoded, ...rest } = minimallyEncodedRelativeMemberInfo;
+  return {
+    ...rest,
+    permissions: threadPermissionsFromBitmaskHex(
+      minimallyEncodedRelativeMemberInfo.permissions,
+    ),
+  };
+};
+
 export type MinimallyEncodedRawThreadInfo = $ReadOnly<{
   ...RawThreadInfo,
   +minimallyEncoded: true,
   +members: $ReadOnlyArray<MinimallyEncodedMemberInfo>,
   +roles: { +[id: string]: MinimallyEncodedRoleInfo },
   +currentUser: MinimallyEncodedThreadCurrentUserInfo,
 }>;
 
 const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> =
   tShape<MinimallyEncodedRawThreadInfo>({
     ...rawThreadInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
     members: t.list(minimallyEncodedMemberInfoValidator),
     roles: t.dict(tID, minimallyEncodedRoleInfoValidator),
     currentUser: minimallyEncodedThreadCurrentUserInfoValidator,
   });
 
 const minimallyEncodeRawThreadInfo = (
   rawThreadInfo: RawThreadInfo,
 ): MinimallyEncodedRawThreadInfo => {
   const { members, roles, currentUser, ...rest } = rawThreadInfo;
   return {
     ...rest,
     minimallyEncoded: true,
     members: members.map(minimallyEncodeMemberInfo),
     roles: _mapValues(minimallyEncodeRoleInfo)(roles),
     currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
   };
 };
 
 const decodeMinimallyEncodedRawThreadInfo = (
   minimallyEncodedRawThreadInfo: MinimallyEncodedRawThreadInfo,
 ): RawThreadInfo => {
   const { minimallyEncoded, members, roles, currentUser, ...rest } =
     minimallyEncodedRawThreadInfo;
   return {
     ...rest,
     members: members.map(decodeMinimallyEncodedMemberInfo),
     roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
     currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
   };
 };
 
 export {
   minimallyEncodedRoleInfoValidator,
   minimallyEncodeRoleInfo,
   decodeMinimallyEncodedRoleInfo,
   minimallyEncodedThreadCurrentUserInfoValidator,
   minimallyEncodeThreadCurrentUserInfo,
   decodeMinimallyEncodedThreadCurrentUserInfo,
   minimallyEncodedMemberInfoValidator,
   minimallyEncodeMemberInfo,
   decodeMinimallyEncodedMemberInfo,
   minimallyEncodedRawThreadInfoValidator,
   minimallyEncodeRawThreadInfo,
   decodeMinimallyEncodedRawThreadInfo,
+  minimallyEncodedRelativeMemberInfoValidator,
+  minimallyEncodeRelativeMemberInfo,
+  decodeMinimallyEncodedRelativeMemberInfo,
 };