diff --git a/lib/ops/report-store-ops.js b/lib/ops/report-store-ops.js
index 2e7823edc..b045b568c 100644
--- a/lib/ops/report-store-ops.js
+++ b/lib/ops/report-store-ops.js
@@ -1,104 +1,111 @@
 // @flow
 
 import type { ClientReportCreationRequest } from '../types/report-types.js';
 
 export type ReplaceQueuedReportOperation = {
   +type: 'replace_report',
   +payload: { +report: ClientReportCreationRequest },
 };
 
 export type RemoveQueuedReportsOperation = {
   +type: 'remove_reports',
   +payload: { +ids: $ReadOnlyArray<string> },
 };
 
 export type RemoveAllQueuedReportsOperation = {
   +type: 'remove_all_reports',
 };
 
 export type ReportStoreOperation =
   | ReplaceQueuedReportOperation
   | RemoveQueuedReportsOperation
   | RemoveAllQueuedReportsOperation;
 
 export type ClientDBReplaceQueuedReportOperation = {
   +type: 'replace_report',
   +payload: ClientDBReport,
 };
 
 export type ClientDBReportStoreOperation =
   | ClientDBReplaceQueuedReportOperation
   | RemoveQueuedReportsOperation
   | RemoveAllQueuedReportsOperation;
 
 export type ClientDBReport = { +id: string, +report: string };
 
 function processReportStoreOperations(
   queuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   reportStoreOps: $ReadOnlyArray<ReportStoreOperation>,
 ): $ReadOnlyArray<ClientReportCreationRequest> {
   if (reportStoreOps.length === 0) {
     return queuedReports;
   }
   let processedReports = [...queuedReports];
   for (const operation of reportStoreOps) {
     if (operation.type === 'replace_report') {
       const filteredReports = processedReports.filter(
         report => report.id !== operation.payload.report.id,
       );
       processedReports = [...filteredReports, { ...operation.payload.report }];
     } else if (operation.type === 'remove_reports') {
       processedReports = processedReports.filter(
         report => !operation.payload.ids.includes(report.id),
       );
     } else if (operation.type === 'remove_all_reports') {
       processedReports = [];
     }
   }
   return processedReports;
 }
 
 function convertReportsToReplaceReportOps(
   reports: $ReadOnlyArray<ClientReportCreationRequest>,
 ): $ReadOnlyArray<ReplaceQueuedReportOperation> {
   return reports.map(report => ({
     type: 'replace_report',
     payload: { report },
   }));
 }
 
 function convertReportsToRemoveReportsOperation(
   reports: $ReadOnlyArray<ClientReportCreationRequest>,
 ): RemoveQueuedReportsOperation {
   return {
     type: 'remove_reports',
     payload: { ids: reports.map(report => report.id) },
   };
 }
 
 function convertReportStoreOperationToClientDBReportStoreOperation(
   reportStoreOperations: $ReadOnlyArray<ReportStoreOperation>,
 ): $ReadOnlyArray<ClientDBReportStoreOperation> {
   return reportStoreOperations.map(operation => {
     if (
       operation.type === 'remove_reports' ||
       operation.type === 'remove_all_reports'
     ) {
       return operation;
     }
     return {
       type: 'replace_report',
       payload: {
         id: operation.payload.report.id,
         report: JSON.stringify(operation.payload.report),
       },
     };
   });
 }
 
+function convertClientDBReportToClientReportCreationRequest(
+  reports: $ReadOnlyArray<ClientDBReport>,
+): $ReadOnlyArray<ClientReportCreationRequest> {
+  return reports.map(reportRecord => JSON.parse(reportRecord.report));
+}
+
 export {
   processReportStoreOperations,
   convertReportsToReplaceReportOps,
   convertReportsToRemoveReportsOperation,
   convertReportStoreOperationToClientDBReportStoreOperation,
+  convertClientDBReportToClientReportCreationRequest,
 };
diff --git a/lib/reducers/message-reducer.test.js b/lib/reducers/message-reducer.test.js
index b0ddd3bb3..3459bfc99 100644
--- a/lib/reducers/message-reducer.test.js
+++ b/lib/reducers/message-reducer.test.js
@@ -1,318 +1,319 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { reduceMessageStore } from './message-reducer.js';
 import { createPendingThread } from '../shared/thread-utils.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import type { MessageStore } from '../types/message-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
 
 const messageStoreBeforeMediaUpdate: MessageStore = {
   messages: {
     local1: {
       type: 14,
       threadID: '91140',
       creatorID: '91097',
       time: 1639522317443,
       media: [
         {
           id: 'localUpload2',
           uri: 'assets-library://asset/asset.HEIC?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=HEIC',
           type: 'photo',
           dimensions: { height: 3024, width: 4032 },
           thumbHash: 'some_thumb_hash',
           localMediaSelection: {
             step: 'photo_library',
             dimensions: { height: 3024, width: 4032 },
             uri: 'assets-library://asset/asset.HEIC?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=HEIC',
             filename: 'IMG_0006.HEIC',
             mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
             selectTime: 1639522317349,
             sendTime: 1639522317349,
             retries: 0,
           },
         },
       ],
       localID: 'local1',
     },
   },
   threads: {
     '91140': {
       messageIDs: ['local1'],
       startReached: true,
       lastNavigatedTo: 1639522314170,
       lastPruned: 1639522292271,
     },
   },
   local: {},
   currentAsOf: 1639522292174,
 };
 
 describe('UPDATE_MULTIMEDIA_MESSAGE_MEDIA', () => {
   const updateMultiMediaMessageMediaAction = {
     type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
     payload: {
       messageID: 'local1',
       currentMediaID: 'localUpload2',
       mediaUpdate: {
         id: '91172',
         type: 'photo',
         uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
         dimensions: { height: 1440, width: 1920 },
         localMediaSelection: undefined,
       },
     },
   };
   const { messageStore: updatedMessageStore } = reduceMessageStore(
     messageStoreBeforeMediaUpdate,
     updateMultiMediaMessageMediaAction,
     {},
   );
 
   test('replace local media with uploaded media', () => {
     expect(
       updatedMessageStore.messages[
         updateMultiMediaMessageMediaAction.payload.messageID
       ],
     ).toStrictEqual({
       type: 14,
       threadID: '91140',
       creatorID: '91097',
       time: 1639522317443,
       media: [
         {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
           thumbHash: 'some_thumb_hash',
         },
       ],
       localID: 'local1',
     });
   });
 
   test('localMediaSelection is unset when undefined in update', () => {
     const msg =
       updatedMessageStore.messages[
         updateMultiMediaMessageMediaAction.payload.messageID
       ];
 
     expect(msg.type).toEqual(messageTypes.IMAGES);
     invariant(msg.type === messageTypes.IMAGES, 'message is of type IMAGES');
     expect(msg.media[0]).not.toHaveProperty('localMediaSelection');
   });
 
   test('localMediaSelection is unchanged when missing in update', () => {
     const actionWithoutLocalMediaSelectionUpdate = {
       type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       payload: {
         messageID: 'local1',
         currentMediaID: 'localUpload2',
         mediaUpdate: {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
         },
       },
     };
     const { messageStore: storeWithoutLocalMediaSelectionUpdate } =
       reduceMessageStore(
         messageStoreBeforeMediaUpdate,
         actionWithoutLocalMediaSelectionUpdate,
         {},
       );
     const prevMsg =
       messageStoreBeforeMediaUpdate.messages[
         actionWithoutLocalMediaSelectionUpdate.payload.messageID
       ];
     const updatedMsg =
       storeWithoutLocalMediaSelectionUpdate.messages[
         actionWithoutLocalMediaSelectionUpdate.payload.messageID
       ];
 
     expect(updatedMsg.type).toEqual(messageTypes.IMAGES);
     expect(prevMsg.type).toEqual(messageTypes.IMAGES);
     invariant(
       updatedMsg.type === messageTypes.IMAGES &&
         prevMsg.type === messageTypes.IMAGES,
       'message is of type IMAGES',
     );
 
     expect(updatedMsg.media[0].localMediaSelection).toStrictEqual(
       prevMsg.media[0].localMediaSelection,
     );
   });
 
   test('localMediaSelection is updated when included in update', () => {
     const updateMultiMediaMessageMediaActionWithReplacement = {
       type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       payload: {
         messageID: 'local1',
         currentMediaID: 'localUpload2',
         mediaUpdate: {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
           localMediaSelection: {
             step: 'photo_library',
             dimensions: { height: 10, width: 10 },
             uri: 'assets-library://asset/new/path',
             filename: 'NEWNAME.PNG',
             mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
             selectTime: 1639522317349,
             sendTime: 1639522317349,
             retries: 1,
           },
         },
       },
     };
     const { messageStore: updatedMessageStoreWithReplacement } =
       reduceMessageStore(
         messageStoreBeforeMediaUpdate,
         updateMultiMediaMessageMediaActionWithReplacement,
         {},
       );
     const updatedMsg =
       updatedMessageStoreWithReplacement.messages[
         updateMultiMediaMessageMediaActionWithReplacement.payload.messageID
       ];
     expect(updatedMsg.type).toEqual(messageTypes.IMAGES);
     invariant(
       updatedMsg.type === messageTypes.IMAGES,
       'message is of type IMAGES',
     );
 
     expect(updatedMsg.media[0].localMediaSelection).toStrictEqual({
       step: 'photo_library',
       dimensions: { height: 10, width: 10 },
       uri: 'assets-library://asset/new/path',
       filename: 'NEWNAME.PNG',
       mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
       selectTime: 1639522317349,
       sendTime: 1639522317349,
       retries: 1,
     });
   });
 });
 
 describe('SET_MESSAGE_STORE_MESSAGES', () => {
   const clientDBMessages = [
     {
       id: '103502',
       local_id: null,
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[103501]',
       time: '1658168455316',
       media_infos: [
         {
           id: '103501',
           uri: 'http://localhost/comm/upload/103501/425db25471f3acd5',
           type: 'photo',
           extras: '{"dimensions":{"width":1920,"height":1440},"loop":false}',
         },
       ],
     },
     {
       id: 'local10',
       local_id: 'local10',
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[null]',
       time: '1658172650495',
       media_infos: [
         {
           id: 'localUpload0',
           uri: 'assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic',
           type: 'photo',
           extras:
             '{"dimensions":{"height":3024,"width":4032},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":3024,"width":4032},"uri":"assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic","filename":"IMG_0006.HEIC","mediaNativeID":"CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001","selectTime":1658172650370,"sendTime":1658172650370,"retries":0}}',
         },
       ],
     },
     {
       id: 'local11',
       local_id: 'local11',
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[null,null]',
       time: '1658172656976',
       media_infos: [
         {
           id: 'localUpload2',
           uri: 'assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic',
           type: 'photo',
           extras:
             '{"dimensions":{"height":3024,"width":4032},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":3024,"width":4032},"uri":"assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic","filename":"IMG_0006.HEIC","mediaNativeID":"CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001","selectTime":1658172656826,"sendTime":1658172656826,"retries":0}}',
         },
         {
           id: 'localUpload4',
           uri: 'assets-library://asset/asset.jpg?id=ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED&ext=jpg',
           type: 'photo',
           extras:
             '{"dimensions":{"height":2002,"width":3000},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":2002,"width":3000},"uri":"assets-library://asset/asset.jpg?id=ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED&ext=jpg","filename":"IMG_0005.JPG","mediaNativeID":"ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED/L0/001","selectTime":1658172656826,"sendTime":1658172656826,"retries":0}}',
         },
       ],
     },
   ];
 
   const threads = {
     '88471': {
       messageIDs: ['local11', 'local10', '103502'],
       startReached: false,
       lastNavigatedTo: 1658172614602,
       lastPruned: 1658169913623,
     },
   };
 
   const { messageStore: updatedMessageStore } = reduceMessageStore(
     {
       messages: {},
       threads,
       local: {},
       currentAsOf: 1234567890123,
     },
     {
       type: 'SET_CLIENT_DB_STORE',
       payload: {
         currentUserID: '',
         drafts: [],
         threadStore: {
           threadInfos: {},
         },
         messageStoreThreads: [],
         messages: clientDBMessages,
+        reports: [],
       },
     },
     {
       [88471]: createPendingThread({
         viewerID: '',
         threadType: threadTypes.LOCAL,
         members: [{ id: '', username: '' }],
       }),
     },
   );
   test('removes local media when constructing messageStore.messages', () => {
     expect(updatedMessageStore.messages).toHaveProperty('103502');
     expect(updatedMessageStore.messages).not.toHaveProperty('local10');
     expect(updatedMessageStore.messages).not.toHaveProperty('local11');
   });
 
   test('removes local media when constructing messageStore.threads', () => {
     expect(updatedMessageStore).toBeDefined();
     expect(updatedMessageStore.threads).toBeDefined();
     expect(updatedMessageStore.threads['88471']).toBeDefined();
     expect(updatedMessageStore.threads['88471'].messageIDs).toBeDefined();
     expect(updatedMessageStore.threads['88471'].messageIDs).toEqual(['103502']);
   });
 });
diff --git a/lib/reducers/report-store-reducer.js b/lib/reducers/report-store-reducer.js
index f54a3f751..266f03bee 100644
--- a/lib/reducers/report-store-reducer.js
+++ b/lib/reducers/report-store-reducer.js
@@ -1,167 +1,192 @@
 // @flow
 
+import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   sendReportActionTypes,
   sendReportsActionTypes,
   queueReportsActionType,
 } from '../actions/report-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import type { ReportStoreOperation } from '../ops/report-store-ops.js';
 import {
   convertReportsToRemoveReportsOperation,
   convertReportsToReplaceReportOps,
   processReportStoreOperations,
 } from '../ops/report-store-ops.js';
 import { isStaff } from '../shared/staff-utils.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   type ReportStore,
   defaultEnabledReports,
   defaultDevEnabledReports,
   type ClientReportCreationRequest,
 } from '../types/report-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { isDev } from '../utils/dev-utils.js';
 import { isReportEnabled } from '../utils/report-utils.js';
 
 export const updateReportsEnabledActionType = 'UPDATE_REPORTS_ENABLED';
 
 export default function reduceReportStore(
   state: ReportStore,
   action: BaseAction,
   newInconsistencies: $ReadOnlyArray<ClientReportCreationRequest>,
 ): {
   reportStore: ReportStore,
   reportStoreOperations: $ReadOnlyArray<ReportStoreOperation>,
 } {
   const newReports = newInconsistencies.filter(report =>
     isReportEnabled(report, state.enabledReports),
   );
 
   if (action.type === updateReportsEnabledActionType) {
     const newEnabledReports = { ...state.enabledReports, ...action.payload };
     const newFilteredReports = newReports.filter(report =>
       isReportEnabled(report, newEnabledReports),
     );
     const reportsToRemove = state.queuedReports.filter(
       report => !isReportEnabled(report, newEnabledReports),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       convertReportsToRemoveReportsOperation(reportsToRemove),
       ...convertReportsToReplaceReportOps(newFilteredReports),
     ];
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         queuedReports,
         enabledReports: newEnabledReports,
       },
       reportStoreOperations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return {
       reportStore: {
         queuedReports: [],
         enabledReports: isDev
           ? defaultDevEnabledReports
           : defaultEnabledReports,
       },
       reportStoreOperations: [{ type: 'remove_all_reports' }],
     };
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     return {
       reportStore: {
         queuedReports: [],
         enabledReports:
           isStaff(action.payload.currentUserInfo.id) || isDev
             ? defaultDevEnabledReports
             : defaultEnabledReports,
       },
       reportStoreOperations: [{ type: 'remove_all_reports' }],
     };
   } else if (
     (action.type === sendReportActionTypes.success ||
       action.type === sendReportsActionTypes.success) &&
     action.payload
   ) {
     const { payload } = action;
     const sentReports = state.queuedReports.filter(response =>
       payload.reports.includes(response),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       convertReportsToRemoveReportsOperation(sentReports),
       ...convertReportsToReplaceReportOps(newReports),
     ];
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: { ...state, queuedReports },
       reportStoreOperations,
     };
   } else if (action.type === queueReportsActionType) {
     const { reports } = action.payload;
     const filteredReports = reports.filter(report =>
       isReportEnabled(report, state.enabledReports),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> =
       convertReportsToReplaceReportOps([...newReports, ...filteredReports]);
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         ...state,
         queuedReports,
       },
       reportStoreOperations,
     };
+  } else if (action.type === setClientDBStoreActionType) {
+    const { reports } = action.payload;
+    if (!reports) {
+      return {
+        reportStore: state,
+        reportStoreOperations: [],
+      };
+    }
+    const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
+      {
+        type: 'remove_all_reports',
+      },
+      ...convertReportsToReplaceReportOps(reports),
+    ];
+
+    const queuedReports = processReportStoreOperations(
+      state.queuedReports,
+      reportStoreOperations,
+    );
+
+    return {
+      reportStore: { ...state, queuedReports },
+      reportStoreOperations: [],
+    };
   }
 
   if (newReports) {
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> =
       convertReportsToReplaceReportOps(newReports);
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         ...state,
         queuedReports,
       },
       reportStoreOperations,
     };
   }
 
   return { reportStore: state, reportStoreOperations: [] };
 }
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index f7d2ceace..7f3fde3d9 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1155 +1,1157 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
   ClientDBThreadMessageInfo,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
+  ClientReportCreationRequest,
 } from './report-types.js';
 import type {
   ProcessServerRequestsPayload,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionInfo,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { Shape } from '../types/core.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo> = {
   navInfo: NavInfo,
   currentUserInfo: ?CurrentUserInfo,
   draftStore: DraftStore,
   entryStore: EntryStore,
   threadStore: ThreadStore,
   userStore: UserStore,
   messageStore: MessageStore,
   updatesCurrentAsOf: number, // millisecond timestamp
   loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   calendarFilters: $ReadOnlyArray<CalendarFilter>,
   urlPrefix: string,
   notifPermissionAlertInfo: NotifPermissionAlertInfo,
   connection: ConnectionInfo,
   watchedThreadIDs: $ReadOnlyArray<string>,
   lifecycleState: LifecycleState,
   enabledApps: EnabledApps,
   reportStore: ReportStore,
   nextLocalID: number,
   dataLoaded: boolean,
   userPolicies: UserPolicies,
   deviceToken: ?string,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   ...
 };
 
 // Web JS runtime doesn't have access to the cookie for security reasons.
 // Native JS doesn't have a sessionID because the cookieID is used instead.
 export type NativeAppState = BaseAppState<*> & {
   sessionID?: void,
   cookie: ?string,
   ...
 };
 export type WebAppState = BaseAppState<*> & {
   sessionID: ?string,
   cookie?: void,
   cryptoStore: CryptoStore,
   pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type BaseAction =
   | {
       +type: '@@redux/INIT',
       +payload?: void,
     }
   | {
       +type: 'FETCH_ENTRIES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_SUCCESS',
       +payload: FetchEntryInfosResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_LOCAL_ENTRY',
       +payload: RawEntryInfo,
     }
   | {
       +type: 'CREATE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_SUCCESS',
       +payload: CreateEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_SUCCESS',
       +payload: SaveEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CONCURRENT_MODIFICATION_RESET',
       +payload: {
         +id: string,
         +dbText: string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: {
         +localID: ?string,
         +serverID: ?string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ENTRY_SUCCESS',
       +payload: ?DeleteEntryResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_SUCCESS',
       +payload: NewThreadResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
       +payload: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_SUCCESS',
       +payload: RestoreEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_SUCCESS',
       +payload: ThreadJoinPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_NEW_SESSION',
       +payload: SetSessionPayload,
     }
   | {
       +type: 'persist/REHYDRATE',
       +payload: ?BaseAppState<*>,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
       +payload: SimpleMessagesPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawTextMessageInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawMultimediaMessageInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawReactionMessageInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
         +targetMessageID: string,
         +reaction: string,
         +action: string,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_SUCCESS',
       +payload: UserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_SUCCESS',
       +payload: ExactUserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
         +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
         +threadStore: ?ThreadStore,
         +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
+        +reports: ?$ReadOnlyArray<ClientReportCreationRequest>,
       },
     }
   | {
       +type: 'UPDATE_ACTIVITY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_SUCCESS',
       +payload: ActivityUpdateSuccessPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: ?string,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'QUEUE_REPORTS',
       +payload: QueueReportsPayload,
     }
   | {
       +type: 'SET_URL_PREFIX',
       +payload: string,
     }
   | {
       +type: 'SAVE_MESSAGES',
       +payload: SaveMessagesPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_THREAD_FILTER',
       +payload: CalendarThreadFilter,
     }
   | {
       +type: 'CLEAR_CALENDAR_THREAD_FILTER',
       +payload?: void,
     }
   | {
       +type: 'SET_CALENDAR_DELETED_FILTER',
       +payload: SetCalendarDeletedFilterPayload,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
       +payload: SubscriptionUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: CalendarQueryUpdateStartingPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
       +payload: CalendarQueryUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FULL_STATE_SYNC',
       +payload: StateSyncFullActionPayload,
     }
   | {
       +type: 'INCREMENTAL_STATE_SYNC',
       +payload: StateSyncIncrementalActionPayload,
     }
   | {
       +type: 'PROCESS_SERVER_REQUESTS',
       +payload: ProcessServerRequestsPayload,
     }
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<EnabledReports>,
     }
   | {
       +type: 'PROCESS_UPDATES',
       +payload: ClientUpdatesResultWithUserInfos,
     }
   | {
       +type: 'PROCESS_MESSAGES',
       +payload: NewMessagesPayload,
     }
   | {
       +type: 'MESSAGE_STORE_PRUNE',
       +payload: MessageStorePrunePayload,
     }
   | {
       +type: 'SET_LATE_RESPONSE',
       +payload: SetLateResponsePayload,
     }
   | {
       +type: 'UPDATE_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +type: 'REQUEST_ACCESS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       +payload: UpdateMultimediaMessageMediaPayload,
     }
   | {
       +type: 'CREATE_LOCAL_MESSAGE',
       +payload: LocallyComposedMessageInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
       +payload: RelationshipErrors,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
       +payload: {
         +threadID: string,
         +unread: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
       +payload: SetThreadUnreadStatusPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_USER_SETTINGS_SUCCESS',
       +payload: DefaultNotificationPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_SUCCESS',
       +payload: MessageReportCreationResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
       +payload: ForcePolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
       +payload: PolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +type: 'UPDATE_USER_AVATAR_STARTED',
       +payload: UpdateUserAvatarRequest,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_SUCCESS',
       +payload: UpdateUserAvatarResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_SUCCESS',
       +payload: EditMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
       +payload: ToggleMessagePinResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
       +payload: FetchPinnedMessagesResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_SUCCESS',
       +payload: InviteLinkVerificationResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
       +payload: FetchInviteLinksResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'SEARCH_MESSAGES_STARTED',
       +payload: void,
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_SUCCESS',
       +payload: SearchMessagesResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
       +payload: InviteLink,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_SUCCESS',
       +payload: DisableInviteLinkPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
       +payload: GetOlmSessionInitializationDataResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/native/data/sqlite-data-handler.js b/native/data/sqlite-data-handler.js
index 645d61081..1b89a3d8b 100644
--- a/native/data/sqlite-data-handler.js
+++ b/native/data/sqlite-data-handler.js
@@ -1,210 +1,215 @@
 // @flow
 
 import * as React from 'react';
 import { Alert } from 'react-native';
 import { useDispatch } from 'react-redux';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
+import { convertClientDBReportToClientReportCreationRequest } from 'lib/ops/report-store-ops.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import {
   logInActionSources,
   type LogInActionSource,
 } from 'lib/types/account-types.js';
 import { fetchNewCookieFromNativeCredentials } from 'lib/utils/action-utils.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { convertClientDBThreadInfosToRawThreadInfos } from 'lib/utils/thread-ops-utils.js';
 
 import { filesystemMediaCache } from '../media/media-cache.js';
 import { commCoreModule } from '../native-modules.js';
 import { setStoreLoadedActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { StaffContext } from '../staff/staff-context.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 function SQLiteDataHandler(): React.Node {
   const storeLoaded = useSelector(state => state.storeLoaded);
 
   const dispatch = useDispatch();
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const cookie = useSelector(state => state.cookie);
   const urlPrefix = useSelector(state => state.urlPrefix);
   const staffCanSee = useStaffCanSee();
   const { staffUserHasBeenLoggedIn } = React.useContext(StaffContext);
   const loggedIn = useSelector(isLoggedIn);
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
   const mediaCacheContext = React.useContext(MediaCacheContext);
 
   const callFetchNewCookieFromNativeCredentials = React.useCallback(
     async (source: LogInActionSource) => {
       try {
         await fetchNewCookieFromNativeCredentials(
           dispatch,
           cookie,
           urlPrefix,
           source,
         );
         dispatch({ type: setStoreLoadedActionType });
       } catch (fetchCookieException) {
         if (staffCanSee) {
           Alert.alert(
             `Error fetching new cookie from native credentials: ${
               getMessageForException(fetchCookieException) ??
               '{no exception message}'
             }. Please kill the app.`,
           );
         } else {
           commCoreModule.terminate();
         }
       }
     },
     [cookie, dispatch, staffCanSee, urlPrefix],
   );
 
   const callClearSensitiveData = React.useCallback(
     async (triggeredBy: string) => {
       if (staffCanSee || staffUserHasBeenLoggedIn) {
         Alert.alert('Starting SQLite database deletion process');
       }
       await commCoreModule.clearSensitiveData();
       try {
         await filesystemMediaCache.clearCache();
       } catch {
         throw new Error('clear_media_cache_failed');
       }
       if (staffCanSee || staffUserHasBeenLoggedIn) {
         Alert.alert(
           'SQLite database successfully deleted',
           `SQLite database deletion was triggered by ${triggeredBy}`,
         );
       }
     },
     [staffCanSee, staffUserHasBeenLoggedIn],
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     try {
       const databaseCurrentUserInfoID = await commCoreModule.getCurrentUserID();
       if (
         databaseCurrentUserInfoID &&
         databaseCurrentUserInfoID !== currentLoggedInUserID
       ) {
         await callClearSensitiveData('change in logged-in user credentials');
       }
       if (currentLoggedInUserID) {
         await commCoreModule.setCurrentUserID(currentLoggedInUserID);
       }
       const databaseDeviceID = await commCoreModule.getDeviceID();
       if (!databaseDeviceID) {
         await commCoreModule.setDeviceID('MOBILE');
       }
     } catch (e) {
       if (isTaskCancelledError(e)) {
         return;
       }
       if (__DEV__) {
         throw e;
       }
       console.log(e);
       if (e.message !== 'clear_media_cache_failed') {
         commCoreModule.terminate();
       }
     }
   }, [callClearSensitiveData, currentLoggedInUserID]);
 
   React.useEffect(() => {
     if (!rehydrateConcluded) {
       return;
     }
 
     const databaseNeedsDeletion = commCoreModule.checkIfDatabaseNeedsDeletion();
     if (databaseNeedsDeletion) {
       (async () => {
         try {
           await callClearSensitiveData('detecting corrupted database');
         } catch (e) {
           if (__DEV__) {
             throw e;
           }
           console.log(e);
           if (e.message !== 'clear_media_cache_failed') {
             commCoreModule.terminate();
           }
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.corruptedDatabaseDeletion,
         );
       })();
       return;
     }
 
     const sensitiveDataHandled = handleSensitiveData();
     if (storeLoaded) {
       return;
     }
     if (!loggedIn) {
       dispatch({ type: setStoreLoadedActionType });
       return;
     }
     (async () => {
       await Promise.all([
         sensitiveDataHandled,
         mediaCacheContext?.evictCache(),
       ]);
       try {
-        const { threads, messages, drafts, messageStoreThreads } =
+        const { threads, messages, drafts, messageStoreThreads, reports } =
           await commCoreModule.getClientDBStore();
         const threadInfosFromDB =
           convertClientDBThreadInfosToRawThreadInfos(threads);
+        const reportsFromDb =
+          convertClientDBReportToClientReportCreationRequest(reports);
+
         dispatch({
           type: setClientDBStoreActionType,
           payload: {
             drafts,
             messages,
             threadStore: { threadInfos: threadInfosFromDB },
             currentUserID: currentLoggedInUserID,
             messageStoreThreads,
+            reports: reportsFromDb,
           },
         });
       } catch (setStoreException) {
         if (isTaskCancelledError(setStoreException)) {
           dispatch({ type: setStoreLoadedActionType });
           return;
         }
         if (staffCanSee) {
           Alert.alert(
             'Error setting threadStore or messageStore',
             getMessageForException(setStoreException) ??
               '{no exception message}',
           );
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.sqliteLoadFailure,
         );
       }
     })();
   }, [
     currentLoggedInUserID,
     handleSensitiveData,
     loggedIn,
     cookie,
     dispatch,
     rehydrateConcluded,
     staffCanSee,
     storeLoaded,
     urlPrefix,
     staffUserHasBeenLoggedIn,
     callFetchNewCookieFromNativeCredentials,
     callClearSensitiveData,
     mediaCacheContext,
   ]);
 
   return null;
 }
 
 export { SQLiteDataHandler };