diff --git a/keyserver/src/shared/state-sync/threads-state-sync-spec.js b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
index 0e1587255..e6802d41f 100644
--- a/keyserver/src/shared/state-sync/threads-state-sync-spec.js
+++ b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
@@ -1,49 +1,51 @@
 // @flow
 
 import { rawThreadInfoValidator } from 'lib/permissions/minimally-encoded-thread-permissions-validators.js';
 import { threadsStateSyncSpec as libSpec } from 'lib/shared/state-sync/threads-state-sync-spec.js';
 import type { ClientThreadInconsistencyReportCreationRequest } from 'lib/types/report-types.js';
 import {
+  type LegacyRawThreadInfos,
+  type LegacyRawThreadInfo,
   type RawThreadInfo,
   type RawThreadInfos,
 } from 'lib/types/thread-types.js';
 import { hash, combineUnorderedHashes, values } from 'lib/utils/objects.js';
 
 import type { ServerStateSyncSpec } from './state-sync-spec.js';
 import { fetchThreadInfos } from '../../fetchers/thread-fetchers.js';
 import type { Viewer } from '../../session/viewer.js';
 import { validateOutput } from '../../utils/validation-utils.js';
 
 export const threadsStateSyncSpec: ServerStateSyncSpec<
-  RawThreadInfos,
-  RawThreadInfos,
-  RawThreadInfo,
+  LegacyRawThreadInfos,
+  LegacyRawThreadInfos,
+  LegacyRawThreadInfo,
   $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
 > = Object.freeze({
   fetch,
   async fetchFullSocketSyncPayload(viewer: Viewer) {
     const result = await fetchThreadInfos(viewer);
     return result.threadInfos;
   },
   async fetchServerInfosHash(viewer: Viewer, ids?: $ReadOnlySet<string>) {
     const infos = await fetch(viewer, ids);
     return getServerInfosHash(infos);
   },
   getServerInfosHash,
   getServerInfoHash,
   ...libSpec,
 });
 
 async function fetch(viewer: Viewer, ids?: $ReadOnlySet<string>) {
   const filter = ids ? { threadIDs: ids } : undefined;
   const result = await fetchThreadInfos(viewer, filter);
   return result.threadInfos;
 }
 
 function getServerInfosHash(infos: RawThreadInfos) {
   return combineUnorderedHashes(values(infos).map(getServerInfoHash));
 }
 
 function getServerInfoHash(info: RawThreadInfo) {
   return hash(validateOutput(null, rawThreadInfoValidator, info));
 }
diff --git a/lib/shared/state-sync/threads-state-sync-spec.js b/lib/shared/state-sync/threads-state-sync-spec.js
index d73d424c5..fbe93e34a 100644
--- a/lib/shared/state-sync/threads-state-sync-spec.js
+++ b/lib/shared/state-sync/threads-state-sync-spec.js
@@ -1,81 +1,81 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 import { createSelector } from 'reselect';
 
 import type { StateSyncSpec, BoundStateSyncSpec } from './state-sync-spec.js';
 import type { AppState } from '../../types/redux-types.js';
 import {
   reportTypes,
   type ClientThreadInconsistencyReportCreationRequest,
 } from '../../types/report-types.js';
 import type { ProcessServerRequestAction } from '../../types/request-types.js';
 import {
-  type RawThreadInfo,
-  type RawThreadInfos,
+  type LegacyRawThreadInfos,
+  type LegacyRawThreadInfo,
 } from '../../types/thread-types.js';
 import { actionLogger } from '../../utils/action-logger.js';
 import { getConfig } from '../../utils/config.js';
 import { combineUnorderedHashes, values } from '../../utils/objects.js';
 import { generateReportID } from '../../utils/report-utils.js';
 import { sanitizeActionSecrets } from '../../utils/sanitization.js';
 import { ashoatKeyserverID } from '../../utils/validation-utils.js';
 
 const selector: (
   state: AppState,
 ) => BoundStateSyncSpec<
-  RawThreadInfos,
-  RawThreadInfo,
+  LegacyRawThreadInfos,
+  LegacyRawThreadInfo,
   $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
 > = createSelector(
   (state: AppState) => state.integrityStore.threadHashes,
   (state: AppState) => state.integrityStore.threadHashingStatus === 'completed',
   (threadHashes: { +[string]: number }, threadHashingComplete: boolean) => ({
     ...threadsStateSyncSpec,
     getInfoHash: (id: string) => threadHashes[`${ashoatKeyserverID}|${id}`],
     getAllInfosHash: threadHashingComplete
       ? () => combineUnorderedHashes(values(threadHashes))
       : () => null,
     getIDs: threadHashingComplete
       ? () => Object.keys(threadHashes).map(id => id.split('|')[1])
       : () => null,
   }),
 );
 
 export const threadsStateSyncSpec: StateSyncSpec<
-  RawThreadInfos,
-  RawThreadInfo,
+  LegacyRawThreadInfos,
+  LegacyRawThreadInfo,
   $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
 > = Object.freeze({
   hashKey: 'threadInfos',
   innerHashSpec: {
     hashKey: 'threadInfo',
     deleteKey: 'deleteThreadIDs',
     rawInfosKey: 'rawThreadInfos',
   },
   findStoreInconsistencies(
     action: ProcessServerRequestAction,
-    beforeStateCheck: RawThreadInfos,
-    afterStateCheck: RawThreadInfos,
+    beforeStateCheck: LegacyRawThreadInfos,
+    afterStateCheck: LegacyRawThreadInfos,
   ) {
     if (_isEqual(beforeStateCheck)(afterStateCheck)) {
       return emptyArray;
     }
     return [
       {
         type: reportTypes.THREAD_INCONSISTENCY,
         platformDetails: getConfig().platformDetails,
         beforeAction: beforeStateCheck,
         action: sanitizeActionSecrets(action),
         pushResult: afterStateCheck,
         lastActions: actionLogger.interestingActionSummaries,
         time: Date.now(),
         id: generateReportID(),
       },
     ];
   },
   selector,
 });
 
 const emptyArray: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest> =
   [];
diff --git a/lib/types/report-types.js b/lib/types/report-types.js
index ceabebce6..1805bae5f 100644
--- a/lib/types/report-types.js
+++ b/lib/types/report-types.js
@@ -1,235 +1,235 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface } from 'tcomb';
 
 import { type PlatformDetails } from './device-types.js';
 import { type RawEntryInfo, type CalendarQuery } from './entry-types.js';
 import { type MediaMission } from './media-types.js';
 import type { AppState, BaseAction } from './redux-types.js';
-import { type RawThreadInfos } from './thread-types.js';
+import { type LegacyRawThreadInfos } from './thread-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import { tPlatformDetails, tShape } from '../utils/validation-utils.js';
 
 export type EnabledReports = {
   +crashReports: boolean,
   +inconsistencyReports: boolean,
   +mediaReports: boolean,
 };
 
 export type SupportedReports = $Keys<EnabledReports>;
 
 export const defaultEnabledReports: EnabledReports = {
   crashReports: false,
   inconsistencyReports: false,
   mediaReports: false,
 };
 
 export const defaultDevEnabledReports: EnabledReports = {
   crashReports: true,
   inconsistencyReports: true,
   mediaReports: true,
 };
 
 export type ReportStore = {
   +enabledReports: EnabledReports,
   +queuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
 };
 
 export const reportTypes = Object.freeze({
   ERROR: 0,
   THREAD_INCONSISTENCY: 1,
   ENTRY_INCONSISTENCY: 2,
   MEDIA_MISSION: 3,
   USER_INCONSISTENCY: 4,
 });
 type ReportType = $Values<typeof reportTypes>;
 export function assertReportType(reportType: number): ReportType {
   invariant(
     reportType === 0 ||
       reportType === 1 ||
       reportType === 2 ||
       reportType === 3 ||
       reportType === 4,
     'number is not ReportType enum',
   );
   return reportType;
 }
 
 export type ErrorInfo = { componentStack: string, ... };
 export type ErrorData = { error: Error, info?: ErrorInfo };
 export type FlatErrorData = {
   errorMessage: string,
   stack?: string,
   componentStack?: ?string,
 };
 
 export type ActionSummary = {
   +type: $PropertyType<BaseAction, 'type'>,
   +time: number,
   +summary: string,
 };
 export type ThreadInconsistencyReportShape = {
   +platformDetails: PlatformDetails,
-  +beforeAction: RawThreadInfos,
+  +beforeAction: LegacyRawThreadInfos,
   +action: BaseAction,
-  +pollResult?: ?RawThreadInfos,
-  +pushResult: RawThreadInfos,
+  +pollResult?: ?LegacyRawThreadInfos,
+  +pushResult: LegacyRawThreadInfos,
   +lastActionTypes?: ?$ReadOnlyArray<$PropertyType<BaseAction, 'type'>>,
   +lastActions?: ?$ReadOnlyArray<ActionSummary>,
   +time?: ?number,
 };
 export type EntryInconsistencyReportShape = {
   +platformDetails: PlatformDetails,
   +beforeAction: { +[id: string]: RawEntryInfo },
   +action: BaseAction,
   +calendarQuery: CalendarQuery,
   +pollResult?: ?{ +[id: string]: RawEntryInfo },
   +pushResult: { +[id: string]: RawEntryInfo },
   +lastActionTypes?: ?$ReadOnlyArray<$PropertyType<BaseAction, 'type'>>,
   +lastActions?: ?$ReadOnlyArray<ActionSummary>,
   +time: number,
 };
 export type UserInconsistencyReportShape = {
   +platformDetails: PlatformDetails,
   +action: BaseAction,
   +beforeStateCheck: UserInfos,
   +afterStateCheck: UserInfos,
   +lastActions: $ReadOnlyArray<ActionSummary>,
   +time: number,
 };
 
 export type ErrorReportCreationRequest = {
   +type: 0,
   +platformDetails: PlatformDetails,
   +errors: $ReadOnlyArray<FlatErrorData>,
   +preloadedState: AppState,
   +currentState: AppState,
   +actions: $ReadOnlyArray<BaseAction>,
 };
 export type ThreadInconsistencyReportCreationRequest = {
   ...ThreadInconsistencyReportShape,
   +type: 1,
 };
 export type EntryInconsistencyReportCreationRequest = {
   ...EntryInconsistencyReportShape,
   +type: 2,
 };
 export type MediaMissionReportCreationRequest = {
   +type: 3,
   +platformDetails: PlatformDetails,
   +time: number, // ms
   +mediaMission: MediaMission,
   +uploadServerID?: ?string,
   +uploadLocalID?: ?string,
   +mediaLocalID?: ?string, // deprecated
   +messageServerID?: ?string,
   +messageLocalID?: ?string,
 };
 export type UserInconsistencyReportCreationRequest = {
   ...UserInconsistencyReportShape,
   +type: 4,
 };
 export type ReportCreationRequest =
   | ErrorReportCreationRequest
   | ThreadInconsistencyReportCreationRequest
   | EntryInconsistencyReportCreationRequest
   | MediaMissionReportCreationRequest
   | UserInconsistencyReportCreationRequest;
 
 export type ClientThreadInconsistencyReportShape = {
   +platformDetails: PlatformDetails,
-  +beforeAction: RawThreadInfos,
+  +beforeAction: LegacyRawThreadInfos,
   +action: BaseAction,
-  +pushResult: RawThreadInfos,
+  +pushResult: LegacyRawThreadInfos,
   +lastActions: $ReadOnlyArray<ActionSummary>,
   +time: number,
 };
 export type ClientEntryInconsistencyReportShape = {
   +platformDetails: PlatformDetails,
   +beforeAction: { +[id: string]: RawEntryInfo },
   +action: BaseAction,
   +calendarQuery: CalendarQuery,
   +pushResult: { +[id: string]: RawEntryInfo },
   +lastActions: $ReadOnlyArray<ActionSummary>,
   +time: number,
 };
 
 export type ClientErrorReportCreationRequest = {
   ...ErrorReportCreationRequest,
   +id: string,
 };
 export type ClientThreadInconsistencyReportCreationRequest = {
   ...ClientThreadInconsistencyReportShape,
   +type: 1,
   +id: string,
 };
 export type ClientEntryInconsistencyReportCreationRequest = {
   ...ClientEntryInconsistencyReportShape,
   +type: 2,
   +id: string,
 };
 export type ClientMediaMissionReportCreationRequest = {
   ...MediaMissionReportCreationRequest,
   +id: string,
 };
 export type ClientUserInconsistencyReportCreationRequest = {
   ...UserInconsistencyReportCreationRequest,
   +id: string,
 };
 
 export type ClientReportCreationRequest =
   | ClientErrorReportCreationRequest
   | ClientThreadInconsistencyReportCreationRequest
   | ClientEntryInconsistencyReportCreationRequest
   | ClientMediaMissionReportCreationRequest
   | ClientUserInconsistencyReportCreationRequest;
 
 export type QueueReportsPayload = {
   +reports: $ReadOnlyArray<ClientReportCreationRequest>,
 };
 
 export type ClearDeliveredReportsPayload = {
   +reports: $ReadOnlyArray<ClientReportCreationRequest>,
 };
 
 export type ReportCreationResponse = {
   +id: string,
 };
 
 // Reports Service specific types
 export type ReportsServiceSendReportsRequest =
   | ClientReportCreationRequest
   | $ReadOnlyArray<ClientReportCreationRequest>;
 export type ReportsServiceSendReportsResponse = {
   +reportIDs: $ReadOnlyArray<string>,
 };
 
 // Keyserver specific types
 type ReportInfo = {
   +id: string,
   +viewerID: string,
   +platformDetails: PlatformDetails,
   +creationTime: number,
 };
 
 export const reportInfoValidator: TInterface<ReportInfo> = tShape<ReportInfo>({
   id: t.String,
   viewerID: t.String,
   platformDetails: tPlatformDetails,
   creationTime: t.Number,
 });
 
 export type FetchErrorReportInfosRequest = {
   +cursor: ?string,
 };
 
 export type FetchErrorReportInfosResponse = {
   +reports: $ReadOnlyArray<ReportInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type ReduxToolsImport = {
   +preloadedState: AppState,
   +payload: $ReadOnlyArray<BaseAction>,
 };