diff --git a/lib/types/media-types.js b/lib/types/media-types.js
index 36858dab0..c189ffe5a 100644
--- a/lib/types/media-types.js
+++ b/lib/types/media-types.js
@@ -1,918 +1,496 @@
 // @flow
 
-import PropTypes from 'prop-types';
-
 import type { Shape } from './core';
-import { type Platform, platformPropType } from './device-types';
+import { type Platform } from './device-types';
 
 export type Dimensions = $ReadOnly<{|
   height: number,
   width: number,
 |}>;
 
-export const dimensionsPropType = PropTypes.shape({
-  height: PropTypes.number.isRequired,
-  width: PropTypes.number.isRequired,
-});
-
 export type MediaType = 'photo' | 'video';
 
 export type Image = {|
   id: string,
   uri: string,
   type: 'photo',
   dimensions: Dimensions,
   // stored on native only during creation in case retry needed after state lost
   localMediaSelection?: NativeMediaSelection,
 |};
 
 export type Video = {|
   id: string,
   uri: string,
   type: 'video',
   dimensions: Dimensions,
   loop?: boolean,
   // stored on native only during creation in case retry needed after state lost
   localMediaSelection?: NativeMediaSelection,
 |};
 
 export type Media = Image | Video;
 
 export type Corners = Shape<{|
   topLeft: boolean,
   topRight: boolean,
   bottomLeft: boolean,
   bottomRight: boolean,
 |}>;
 
 export type MediaInfo =
   | {|
       ...Image,
       corners: Corners,
       index: number,
     |}
   | {|
       ...Video,
       corners: Corners,
       index: number,
     |};
 
-export const cornersPropType = PropTypes.shape({
-  topLeft: PropTypes.bool,
-  topRight: PropTypes.bool,
-  bottomLeft: PropTypes.bool,
-  bottomRight: PropTypes.bool,
-});
-
-export const mediaTypePropType = PropTypes.oneOf(['photo', 'video']);
-
-export const mediaInfoPropType = PropTypes.shape({
-  id: PropTypes.string.isRequired,
-  uri: PropTypes.string.isRequired,
-  type: mediaTypePropType.isRequired,
-  dimensions: dimensionsPropType.isRequired,
-  filename: PropTypes.string,
-  corners: cornersPropType.isRequired,
-  index: PropTypes.number.isRequired,
-});
-
 export type UploadMultimediaResult = {|
   id: string,
   uri: string,
   dimensions: Dimensions,
   mediaType: MediaType,
   loop: boolean,
 |};
 
 export type UpdateMultimediaMessageMediaPayload = {|
   messageID: string,
   currentMediaID: string,
   mediaUpdate: Shape<Media>,
 |};
 
 export type UploadDeletionRequest = {|
   id: string,
 |};
 
 export type FFmpegStatistics = {|
   // seconds of video being processed per second
   +speed: number,
   // total milliseconds of video processed so far
   +time: number,
   // total result file size in bytes so far
   +size: number,
   +videoQuality: number,
   +videoFrameNumber: number,
   +videoFps: number,
   +bitrate: number,
 |};
 
 export type VideoProbeMediaMissionStep = {|
   step: 'video_probe',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   path: string,
   validFormat: boolean,
   duration: ?number, // seconds
   codec: ?string,
   format: ?$ReadOnlyArray<string>,
   dimensions: ?Dimensions,
 |};
 
 export type ReadFileHeaderMediaMissionStep = {|
   step: 'read_file_header',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   uri: string,
   mime: ?string,
   mediaType: ?MediaType,
 |};
 
 export type DetermineFileTypeMediaMissionStep = {|
   step: 'determine_file_type',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   inputFilename: string,
   outputMIME: ?string,
   outputMediaType: ?MediaType,
   outputFilename: ?string,
 |};
 
 export type FrameCountMediaMissionStep = {|
   step: 'frame_count',
   success: boolean,
   exceptionMessage: ?string,
   time: number,
   path: string,
   mime: string,
   hasMultipleFrames: ?boolean,
 |};
 
 export type DisposeTemporaryFileMediaMissionStep = {|
   step: 'dispose_temporary_file',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   path: string,
 |};
 
 export type MakeDirectoryMediaMissionStep = {|
   step: 'make_directory',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   path: string,
 |};
 
 export type AndroidScanFileMediaMissionStep = {|
   step: 'android_scan_file',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   path: string,
 |};
 
 export type FetchFileHashMediaMissionStep = {|
   step: 'fetch_file_hash',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   path: string,
   hash: ?string,
 |};
 
 export type CopyFileMediaMissionStep = {|
   step: 'copy_file',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   source: string,
   destination: string,
 |};
 
 export type GetOrientationMediaMissionStep = {|
   step: 'exif_fetch',
   success: boolean,
   exceptionMessage: ?string,
   time: number, // ms
   orientation: ?number,
 |};
 
 export type MediaLibrarySelection =
   | {|
       step: 'photo_library',
       dimensions: Dimensions,
       filename: string,
       uri: string,
       mediaNativeID: string,
       selectTime: number, // ms timestamp
       sendTime: number, // ms timestamp
       retries: number,
     |}
   | {|
       step: 'video_library',
       dimensions: Dimensions,
       filename: string,
       uri: string,
       mediaNativeID: string,
       selectTime: number, // ms timestamp
       sendTime: number, // ms timestamp
       retries: number,
       duration: number, // seconds
     |};
 
-const photoLibrarySelectionPropType = PropTypes.shape({
-  step: PropTypes.oneOf(['photo_library']).isRequired,
-  dimensions: dimensionsPropType.isRequired,
-  filename: PropTypes.string.isRequired,
-  uri: PropTypes.string.isRequired,
-  mediaNativeID: PropTypes.string.isRequired,
-  selectTime: PropTypes.number.isRequired,
-  sendTime: PropTypes.number.isRequired,
-  retries: PropTypes.number.isRequired,
-});
-
-const videoLibrarySelectionPropType = PropTypes.shape({
-  step: PropTypes.oneOf(['video_library']).isRequired,
-  dimensions: dimensionsPropType.isRequired,
-  filename: PropTypes.string.isRequired,
-  uri: PropTypes.string.isRequired,
-  mediaNativeID: PropTypes.string.isRequired,
-  selectTime: PropTypes.number.isRequired,
-  sendTime: PropTypes.number.isRequired,
-  retries: PropTypes.number.isRequired,
-  duration: PropTypes.number.isRequired,
-});
-
-export const mediaLibrarySelectionPropType = PropTypes.oneOfType([
-  photoLibrarySelectionPropType,
-  videoLibrarySelectionPropType,
-]);
-
 export type PhotoCapture = {|
   step: 'photo_capture',
   time: number, // ms
   dimensions: Dimensions,
   filename: string,
   uri: string,
   captureTime: number, // ms timestamp
   selectTime: number, // ms timestamp
   sendTime: number, // ms timestamp
   retries: number,
 |};
 
 export type PhotoPaste = {|
   +step: 'photo_paste',
   +dimensions: Dimensions,
   +filename: string,
   +uri: string,
   +selectTime: number, // ms timestamp
   +sendTime: number, // ms timestamp
   +retries: number,
 |};
 
-const photoPasteSelectionPropType = PropTypes.exact({
-  step: PropTypes.oneOf(['photo_paste']).isRequired,
-  dimensions: dimensionsPropType.isRequired,
-  filename: PropTypes.string.isRequired,
-  uri: PropTypes.string.isRequired,
-  selectTime: PropTypes.number.isRequired,
-  sendTime: PropTypes.number.isRequired,
-  retries: PropTypes.number.isRequired,
-});
-
 export type NativeMediaSelection =
   | MediaLibrarySelection
   | PhotoCapture
   | PhotoPaste;
 
 export type MediaMissionStep =
   | NativeMediaSelection
   | {|
       step: 'web_selection',
       filename: string,
       size: number, // in bytes
       mime: string,
       selectTime: number, // ms timestamp
     |}
   | {|
       step: 'asset_info_fetch',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       localURI: ?string,
       orientation: ?number,
     |}
   | {|
       step: 'stat_file',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       uri: string,
       fileSize: ?number,
     |}
   | ReadFileHeaderMediaMissionStep
   | DetermineFileTypeMediaMissionStep
   | FrameCountMediaMissionStep
   | {|
       step: 'photo_manipulation',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       manipulation: Object,
       newMIME: ?string,
       newDimensions: ?Dimensions,
       newURI: ?string,
     |}
   | VideoProbeMediaMissionStep
   | {|
       step: 'video_ffmpeg_transcode',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       returnCode: ?number,
       newPath: ?string,
       stats: ?FFmpegStatistics,
     |}
   | DisposeTemporaryFileMediaMissionStep
   | {|
       step: 'save_media',
       uri: string,
       time: number, // ms timestamp
     |}
   | {|
       step: 'permissions_check',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       platform: Platform,
       permissions: $ReadOnlyArray<string>,
     |}
   | MakeDirectoryMediaMissionStep
   | AndroidScanFileMediaMissionStep
   | {|
       step: 'ios_save_to_library',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       uri: string,
     |}
   | {|
       step: 'fetch_blob',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       inputURI: string,
       uri: string,
       size: ?number,
       mime: ?string,
     |}
   | {|
       step: 'data_uri_from_blob',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       first255Chars: ?string,
     |}
   | {|
       step: 'array_buffer_from_blob',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
     |}
   | {|
       step: 'mime_check',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       mime: ?string,
     |}
   | {|
       step: 'write_file',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       path: string,
       length: number,
     |}
   | FetchFileHashMediaMissionStep
   | CopyFileMediaMissionStep
   | GetOrientationMediaMissionStep
   | {|
       step: 'preload_image',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       uri: string,
       dimensions: ?Dimensions,
     |}
   | {|
       step: 'reorient_image',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       uri: ?string,
     |}
   | {|
       step: 'upload',
       success: boolean,
       exceptionMessage: ?string,
       time: number, // ms
       inputFilename: string,
       outputMediaType: ?MediaType,
       outputURI: ?string,
       outputDimensions: ?Dimensions,
       outputLoop: ?boolean,
       hasWiFi?: boolean,
     |}
   | {|
       step: 'wait_for_capture_uri_unload',
       success: boolean,
       time: number, // ms
       uri: string,
     |};
 
 export type MediaMissionFailure =
   | {|
       success: false,
       reason: 'no_file_path',
     |}
   | {|
       success: false,
       reason: 'file_stat_failed',
       uri: string,
     |}
   | {|
       success: false,
       reason: 'photo_manipulation_failed',
       size: number, // in bytes
     |}
   | {|
       success: false,
       reason: 'media_type_fetch_failed',
       detectedMIME: ?string,
     |}
   | {|
       success: false,
       reason: 'mime_type_mismatch',
       reportedMediaType: MediaType,
       reportedMIME: string,
       detectedMIME: string,
     |}
   | {|
       success: false,
       reason: 'http_upload_failed',
       exceptionMessage: ?string,
     |}
   | {|
       success: false,
       reason: 'video_too_long',
       duration: number, // in seconds
     |}
   | {|
       success: false,
       reason: 'video_probe_failed',
     |}
   | {|
       success: false,
       reason: 'video_transcode_failed',
     |}
   | {|
       success: false,
       reason: 'processing_exception',
       time: number, // ms
       exceptionMessage: ?string,
     |}
   | {|
       success: false,
       reason: 'save_unsupported',
     |}
   | {|
       success: false,
       reason: 'missing_permission',
     |}
   | {|
       success: false,
       reason: 'make_directory_failed',
     |}
   | {|
       success: false,
       reason: 'resolve_failed',
       uri: string,
     |}
   | {|
       success: false,
       reason: 'save_to_library_failed',
       uri: string,
     |}
   | {|
       success: false,
       reason: 'fetch_failed',
     |}
   | {|
       success: false,
       reason: 'data_uri_failed',
     |}
   | {|
       success: false,
       reason: 'array_buffer_failed',
     |}
   | {|
       success: false,
       reason: 'mime_check_failed',
       mime: ?string,
     |}
   | {|
       success: false,
       reason: 'write_file_failed',
     |}
   | {|
       success: false,
       reason: 'fetch_file_hash_failed',
     |}
   | {|
       success: false,
       reason: 'copy_file_failed',
     |}
   | {|
       success: false,
       reason: 'exif_fetch_failed',
     |}
   | {|
       success: false,
       reason: 'reorient_image_failed',
     |}
   | {|
       success: false,
       reason: 'web_sibling_validation_failed',
     |};
 
 export type MediaMissionResult = MediaMissionFailure | {| success: true |};
 
 export type MediaMission = {|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionResult,
   userTime: number,
   totalTime: number,
 |};
-
-export const mediaMissionStepPropType = PropTypes.oneOfType([
-  photoLibrarySelectionPropType,
-  videoLibrarySelectionPropType,
-  photoPasteSelectionPropType,
-  PropTypes.shape({
-    step: PropTypes.oneOf(['photo_capture']).isRequired,
-    time: PropTypes.number.isRequired,
-    dimensions: dimensionsPropType.isRequired,
-    filename: PropTypes.string.isRequired,
-    uri: PropTypes.string.isRequired,
-    captureTime: PropTypes.number.isRequired,
-    selectTime: PropTypes.number.isRequired,
-    sendTime: PropTypes.number.isRequired,
-    retries: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['web_selection']).isRequired,
-    filename: PropTypes.string.isRequired,
-    size: PropTypes.number.isRequired,
-    mime: PropTypes.string.isRequired,
-    selectTime: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['asset_info_fetch']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    localURI: PropTypes.string,
-    orientation: PropTypes.number,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['stat_file']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string.isRequired,
-    fileSize: PropTypes.number,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['read_file_header']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string.isRequired,
-    mime: PropTypes.string,
-    mediaType: mediaTypePropType,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['determine_file_type']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    inputFilename: PropTypes.string.isRequired,
-    outputMIME: PropTypes.string,
-    outputMediaType: mediaTypePropType,
-    outputFilename: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['frame_count']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-    mime: PropTypes.string.isRequired,
-    hasMultipleFrames: PropTypes.bool,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['photo_manipulation']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    manipulation: PropTypes.object.isRequired,
-    newMIME: PropTypes.string,
-    newDimensions: dimensionsPropType,
-    newURI: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['video_probe']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-    validFormat: PropTypes.bool.isRequired,
-    duration: PropTypes.number,
-    codec: PropTypes.string,
-    format: PropTypes.arrayOf(PropTypes.string),
-    dimensions: dimensionsPropType,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['video_ffmpeg_transcode']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    returnCode: PropTypes.number,
-    newPath: PropTypes.string,
-    stats: PropTypes.object,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['dispose_temporary_file']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['save_media']).isRequired,
-    uri: PropTypes.string.isRequired,
-    time: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['permissions_check']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    platform: platformPropType.isRequired,
-    permissions: PropTypes.arrayOf(PropTypes.string).isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['make_directory']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['android_scan_file']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['fetch_file_hash']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-    hash: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['copy_file']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    source: PropTypes.string.isRequired,
-    destination: PropTypes.string.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['ios_save_to_library']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['fetch_blob']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    inputURI: PropTypes.string.isRequired,
-    uri: PropTypes.string.isRequired,
-    size: PropTypes.number,
-    mime: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['data_uri_from_blob']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    first255Chars: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['array_buffer_from_blob']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['mime_check']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    mime: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['write_file']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    path: PropTypes.string.isRequired,
-    length: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['exif_fetch']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    orientation: PropTypes.number,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['preload_image']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string.isRequired,
-    dimensions: dimensionsPropType,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['reorient_image']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['upload']).isRequired,
-    success: PropTypes.bool.isRequired,
-    exceptionMessage: PropTypes.string,
-    time: PropTypes.number.isRequired,
-    inputFilename: PropTypes.string.isRequired,
-    outputMediaType: mediaTypePropType,
-    outputURI: PropTypes.string,
-    outputDimensions: dimensionsPropType,
-    outputLoop: PropTypes.bool,
-    hasWiFi: PropTypes.bool,
-  }),
-  PropTypes.shape({
-    step: PropTypes.oneOf(['wait_for_capture_uri_unload']).isRequired,
-    success: PropTypes.bool.isRequired,
-    time: PropTypes.number.isRequired,
-    uri: PropTypes.string.isRequired,
-  }),
-]);
-
-export const mediaMissionPropType = PropTypes.shape({
-  steps: PropTypes.arrayOf(mediaMissionStepPropType).isRequired,
-  result: PropTypes.oneOfType([
-    PropTypes.shape({
-      success: PropTypes.oneOf([true]).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['no_file_path']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['file_stat_failed']).isRequired,
-      uri: PropTypes.string.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['photo_manipulation_failed']).isRequired,
-      size: PropTypes.number.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['media_type_fetch_failed']).isRequired,
-      detectedMIME: PropTypes.string,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['mime_type_mismatch']).isRequired,
-      reportedMediaType: mediaTypePropType.isRequired,
-      reportedMIME: PropTypes.string.isRequired,
-      detectedMIME: PropTypes.string.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['http_upload_failed']).isRequired,
-      exceptionMessage: PropTypes.string,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['video_too_long']).isRequired,
-      duration: PropTypes.number.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['video_probe_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['video_transcode_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['processing_exception']).isRequired,
-      time: PropTypes.number.isRequired,
-      exceptionMessage: PropTypes.string,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['save_unsupported']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['missing_permission']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['make_directory_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['resolve_failed']).isRequired,
-      uri: PropTypes.string.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['save_to_library_failed']).isRequired,
-      uri: PropTypes.string.isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['fetch_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['data_uri_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['array_buffer_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['mime_check_failed']).isRequired,
-      mime: PropTypes.string,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['write_file_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['fetch_file_hash_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['copy_file_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['exif_fetch_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['reorient_image_failed']).isRequired,
-    }),
-    PropTypes.shape({
-      success: PropTypes.oneOf([false]).isRequired,
-      reason: PropTypes.oneOf(['web_sibling_validation_failed']).isRequired,
-    }),
-  ]),
-  userTime: PropTypes.number.isRequired,
-  totalTime: PropTypes.number.isRequired,
-});
diff --git a/lib/types/report-types.js b/lib/types/report-types.js
index e00d0dd09..09db4bd36 100644
--- a/lib/types/report-types.js
+++ b/lib/types/report-types.js
@@ -1,233 +1,178 @@
 // @flow
 
 import invariant from 'invariant';
-import PropTypes from 'prop-types';
-
-import { type PlatformDetails, platformDetailsPropType } from './device-types';
-import {
-  type RawEntryInfo,
-  type CalendarQuery,
-  rawEntryInfoPropType,
-  calendarQueryPropType,
-} from './entry-types';
-import { type MediaMission, mediaMissionPropType } from './media-types';
+
+import { type PlatformDetails } from './device-types';
+import { type RawEntryInfo, type CalendarQuery } from './entry-types';
+import { type MediaMission } from './media-types';
 import type { AppState, BaseAction } from './redux-types';
-import { type RawThreadInfo, rawThreadInfoPropType } from './thread-types';
+import { type RawThreadInfo } from './thread-types';
 import type { UserInfo, UserInfos } from './user-types';
 
 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: { [id: string]: RawThreadInfo },
   action: BaseAction,
   pollResult?: { [id: string]: RawThreadInfo },
   pushResult: { [id: string]: RawThreadInfo },
   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,
 |};
 
 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: { [id: string]: RawThreadInfo },
   action: BaseAction,
   pushResult: { [id: string]: RawThreadInfo },
   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 ClientThreadInconsistencyReportCreationRequest = {|
   ...ClientThreadInconsistencyReportShape,
   type: 1,
 |};
 export type ClientEntryInconsistencyReportCreationRequest = {|
   ...ClientEntryInconsistencyReportShape,
   type: 2,
 |};
 
 export type ClientReportCreationRequest =
   | ErrorReportCreationRequest
   | ClientThreadInconsistencyReportCreationRequest
   | ClientEntryInconsistencyReportCreationRequest
   | MediaMissionReportCreationRequest
   | UserInconsistencyReportCreationRequest;
 
 export type QueueReportsPayload = {|
   reports: $ReadOnlyArray<ClientReportCreationRequest>,
 |};
 
 export type ClearDeliveredReportsPayload = {|
   reports: $ReadOnlyArray<ClientReportCreationRequest>,
 |};
 
-const actionSummaryPropType = PropTypes.shape({
-  type: PropTypes.string.isRequired,
-  time: PropTypes.number.isRequired,
-  summary: PropTypes.string.isRequired,
-});
-export const queuedClientReportCreationRequestPropType = PropTypes.oneOfType([
-  PropTypes.shape({
-    type: PropTypes.oneOf([reportTypes.THREAD_INCONSISTENCY]).isRequired,
-    platformDetails: platformDetailsPropType.isRequired,
-    beforeAction: PropTypes.objectOf(rawThreadInfoPropType).isRequired,
-    action: PropTypes.object.isRequired,
-    pollResult: PropTypes.objectOf(rawThreadInfoPropType),
-    pushResult: PropTypes.objectOf(rawThreadInfoPropType).isRequired,
-    lastActions: PropTypes.arrayOf(actionSummaryPropType).isRequired,
-    time: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    type: PropTypes.oneOf([reportTypes.ENTRY_INCONSISTENCY]).isRequired,
-    platformDetails: platformDetailsPropType.isRequired,
-    beforeAction: PropTypes.objectOf(rawEntryInfoPropType).isRequired,
-    action: PropTypes.object.isRequired,
-    calendarQuery: calendarQueryPropType.isRequired,
-    pollResult: PropTypes.objectOf(rawEntryInfoPropType),
-    pushResult: PropTypes.objectOf(rawEntryInfoPropType).isRequired,
-    lastActions: PropTypes.arrayOf(actionSummaryPropType).isRequired,
-    time: PropTypes.number.isRequired,
-  }),
-  PropTypes.shape({
-    type: PropTypes.oneOf([reportTypes.MEDIA_MISSION]).isRequired,
-    platformDetails: platformDetailsPropType.isRequired,
-    time: PropTypes.number.isRequired,
-    mediaMission: mediaMissionPropType.isRequired,
-    uploadServerID: PropTypes.string,
-    uploadLocalID: PropTypes.string,
-    mediaLocalID: PropTypes.string,
-    messageServerID: PropTypes.string,
-    messageLocalID: PropTypes.string,
-  }),
-  PropTypes.shape({
-    type: PropTypes.oneOf([reportTypes.USER_INCONSISTENCY]).isRequired,
-    platformDetails: platformDetailsPropType.isRequired,
-    action: PropTypes.object.isRequired,
-    beforeStateCheck: PropTypes.objectOf(rawThreadInfoPropType).isRequired,
-    afterStateCheck: PropTypes.objectOf(rawThreadInfoPropType).isRequired,
-    lastActions: PropTypes.arrayOf(actionSummaryPropType).isRequired,
-    time: PropTypes.number.isRequired,
-  }),
-]);
-
 export type ReportCreationResponse = {|
   id: string,
 |};
 
 type ReportInfo = {|
   id: string,
   viewerID: string,
   platformDetails: PlatformDetails,
   creationTime: number,
 |};
 
 export type FetchErrorReportInfosRequest = {|
   cursor: ?string,
 |};
 
 export type FetchErrorReportInfosResponse = {|
   reports: $ReadOnlyArray<ReportInfo>,
   userInfos: $ReadOnlyArray<UserInfo>,
 |};
 
 export type ReduxToolsImport = {|
   preloadedState: AppState,
   payload: $ReadOnlyArray<BaseAction>,
 |};
diff --git a/native/media/media-gallery-media.react.js b/native/media/media-gallery-media.react.js
index 855898f66..89cc130ca 100644
--- a/native/media/media-gallery-media.react.js
+++ b/native/media/media-gallery-media.react.js
@@ -1,306 +1,288 @@
 // @flow
 
 import LottieView from 'lottie-react-native';
-import PropTypes from 'prop-types';
 import * as React from 'react';
 import {
   TouchableOpacity,
   StyleSheet,
   View,
   Text,
   Platform,
   Animated,
   Easing,
 } from 'react-native';
 import Reanimated, {
   Easing as ReanimatedEasing,
 } from 'react-native-reanimated';
 import Icon from 'react-native-vector-icons/FontAwesome';
 import MaterialIcon from 'react-native-vector-icons/MaterialIcons';
 import Video from 'react-native-video';
 
-import {
-  type MediaLibrarySelection,
-  mediaLibrarySelectionPropType,
-} from 'lib/types/media-types';
+import { type MediaLibrarySelection } from 'lib/types/media-types';
 
 import GestureTouchableOpacity from '../components/gesture-touchable-opacity.react';
-import {
-  type DimensionsInfo,
-  dimensionsInfoPropType,
-} from '../redux/dimensions-updater.react';
+import { type DimensionsInfo } from '../redux/dimensions-updater.react';
 import type { ViewStyle, ImageStyle } from '../types/styles';
 
 const animatedSpec = {
   duration: 400,
   easing: Easing.inOut(Easing.ease),
   useNativeDriver: true,
 };
 const reanimatedSpec = {
   duration: 400,
   easing: ReanimatedEasing.inOut(ReanimatedEasing.ease),
 };
 
 type Props = {|
   +selection: MediaLibrarySelection,
   +containerHeight: number,
   +queueModeActive: boolean,
   +isQueued: boolean,
   +setMediaQueued: (media: MediaLibrarySelection, isQueued: boolean) => void,
   +sendMedia: (media: MediaLibrarySelection) => void,
   +isFocused: boolean,
   +setFocus: (media: MediaLibrarySelection, isFocused: boolean) => void,
   +dimensions: DimensionsInfo,
 |};
 class MediaGalleryMedia extends React.PureComponent<Props> {
-  static propTypes = {
-    selection: mediaLibrarySelectionPropType.isRequired,
-    containerHeight: PropTypes.number.isRequired,
-    queueModeActive: PropTypes.bool.isRequired,
-    isQueued: PropTypes.bool.isRequired,
-    setMediaQueued: PropTypes.func.isRequired,
-    sendMedia: PropTypes.func.isRequired,
-    isFocused: PropTypes.bool.isRequired,
-    setFocus: PropTypes.func.isRequired,
-    dimensions: dimensionsInfoPropType.isRequired,
-  };
   // eslint-disable-next-line import/no-named-as-default-member
   focusProgress = new Reanimated.Value(0);
   buttonsStyle: ViewStyle;
   mediaStyle: ImageStyle;
   checkProgress = new Animated.Value(0);
 
   constructor(props: Props) {
     super(props);
 
     // eslint-disable-next-line import/no-named-as-default-member
     const buttonsScale = Reanimated.interpolate(this.focusProgress, {
       inputRange: [0, 1],
       outputRange: [1.3, 1],
     });
     this.buttonsStyle = {
       ...styles.buttons,
       opacity: this.focusProgress,
       transform: [{ scale: buttonsScale }],
       marginBottom: this.props.dimensions.bottomInset,
     };
 
     // eslint-disable-next-line import/no-named-as-default-member
     const mediaScale = Reanimated.interpolate(this.focusProgress, {
       inputRange: [0, 1],
       outputRange: [1, 1.3],
     });
     this.mediaStyle = {
       transform: [{ scale: mediaScale }],
     };
   }
 
   static isActive(props: Props) {
     return props.isFocused || props.isQueued;
   }
 
   componentDidUpdate(prevProps: Props) {
     const isActive = MediaGalleryMedia.isActive(this.props);
     const wasActive = MediaGalleryMedia.isActive(prevProps);
     if (isActive && !wasActive) {
       // eslint-disable-next-line import/no-named-as-default-member
       Reanimated.timing(this.focusProgress, {
         ...reanimatedSpec,
         toValue: 1,
       }).start();
     } else if (!isActive && wasActive) {
       // eslint-disable-next-line import/no-named-as-default-member
       Reanimated.timing(this.focusProgress, {
         ...reanimatedSpec,
         toValue: 0,
       }).start();
     }
 
     if (this.props.isQueued && !prevProps.isQueued) {
       // When I updated to React Native 0.60, I also updated Lottie. At that
       // time, on iOS the last frame of the animation drops the circle outlining
       // the checkmark. This is a hack to get around that
       const maxValue = Platform.OS === 'ios' ? 0.99 : 1;
       Animated.timing(this.checkProgress, {
         ...animatedSpec,
         toValue: maxValue,
       }).start();
     } else if (!this.props.isQueued && prevProps.isQueued) {
       Animated.timing(this.checkProgress, {
         ...animatedSpec,
         toValue: 0,
       }).start();
     }
   }
 
   render() {
     const { selection, containerHeight } = this.props;
     const {
       uri,
       dimensions: { width, height },
       step,
     } = selection;
     const active = MediaGalleryMedia.isActive(this.props);
     const scaledWidth = height ? (width * containerHeight) / height : 0;
     const dimensionsStyle = {
       height: containerHeight,
       width: Math.max(Math.min(scaledWidth, this.props.dimensions.width), 150),
     };
 
     let buttons = null;
     const { queueModeActive } = this.props;
     if (!queueModeActive) {
       buttons = (
         <>
           <TouchableOpacity
             onPress={this.onPressSend}
             style={styles.sendButton}
             activeOpacity={0.6}
             disabled={!active}
           >
             <Icon name="send" style={styles.buttonIcon} />
             <Text style={styles.buttonText}>Send</Text>
           </TouchableOpacity>
           <TouchableOpacity
             onPress={this.onPressEnqueue}
             style={styles.enqueueButton}
             activeOpacity={0.6}
             disabled={!active}
           >
             <MaterialIcon name="add-to-photos" style={styles.buttonIcon} />
             <Text style={styles.buttonText}>Queue</Text>
           </TouchableOpacity>
         </>
       );
     }
 
     let media;
     const source = { uri };
     if (step === 'video_library') {
       let resizeMode = 'contain';
       if (Platform.OS === 'ios') {
         const [major, minor] = Platform.Version.split('.');
         if (parseInt(major, 10) === 14 && parseInt(minor, 10) < 2) {
           resizeMode = 'stretch';
         }
       }
       media = (
         <Reanimated.View style={this.mediaStyle}>
           <Video
             source={source}
             repeat={true}
             muted={true}
             resizeMode={resizeMode}
             style={dimensionsStyle}
           />
         </Reanimated.View>
       );
     } else {
       media = (
         <Reanimated.Image
           source={source}
           style={[this.mediaStyle, dimensionsStyle]}
         />
       );
     }
 
     const overlay = (
       <Reanimated.View style={this.buttonsStyle}>
         <LottieView
           source={require('../animations/check.json')}
           progress={this.checkProgress}
           style={styles.checkAnimation}
           resizeMode="cover"
         />
       </Reanimated.View>
     );
 
     return (
       <View style={[styles.container, dimensionsStyle]}>
         <GestureTouchableOpacity
           onPress={this.onPressBackdrop}
           overlay={overlay}
           stickyActive={active}
         >
           {media}
         </GestureTouchableOpacity>
         <Reanimated.View
           style={this.buttonsStyle}
           pointerEvents={active ? 'box-none' : 'none'}
         >
           {buttons}
         </Reanimated.View>
       </View>
     );
   }
 
   onPressBackdrop = () => {
     if (this.props.isQueued) {
       this.props.setMediaQueued(this.props.selection, false);
     } else if (this.props.queueModeActive) {
       this.props.setMediaQueued(this.props.selection, true);
     } else {
       this.props.setFocus(this.props.selection, !this.props.isFocused);
     }
   };
 
   onPressSend = () => {
     this.props.sendMedia(this.props.selection);
   };
 
   onPressEnqueue = () => {
     this.props.setMediaQueued(this.props.selection, true);
   };
 }
 
 const buttonStyle = {
   flexDirection: 'row',
   alignItems: 'flex-start',
   margin: 10,
   borderRadius: 20,
   paddingLeft: 20,
   paddingRight: 20,
   paddingTop: 10,
   paddingBottom: 10,
 };
 const styles = StyleSheet.create({
   buttonIcon: {
     alignSelf: Platform.OS === 'android' ? 'center' : 'flex-end',
     color: 'white',
     fontSize: 18,
     marginRight: 6,
     paddingRight: 5,
   },
   buttonText: {
     color: 'white',
     fontSize: 16,
   },
   buttons: {
     alignItems: 'center',
     bottom: 0,
     justifyContent: 'center',
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   checkAnimation: {
     position: 'absolute',
     width: 128,
   },
   container: {
     flex: 1,
     overflow: 'hidden',
   },
   enqueueButton: {
     ...buttonStyle,
     backgroundColor: '#2A78E5',
   },
   sendButton: {
     ...buttonStyle,
     backgroundColor: '#7ED321',
     paddingLeft: 18,
   },
 });
 
 export default MediaGalleryMedia;
diff --git a/native/media/multimedia.react.js b/native/media/multimedia.react.js
index a5b1bd2be..bd422d427 100644
--- a/native/media/multimedia.react.js
+++ b/native/media/multimedia.react.js
@@ -1,154 +1,144 @@
 // @flow
 
 import invariant from 'invariant';
-import PropTypes from 'prop-types';
 import * as React from 'react';
 import { View, Image, StyleSheet } from 'react-native';
 
-import { type MediaInfo, mediaInfoPropType } from 'lib/types/media-types';
+import { type MediaInfo } from 'lib/types/media-types';
 
-import {
-  type InputState,
-  inputStatePropType,
-  InputStateContext,
-} from '../input/input-state';
+import { type InputState, InputStateContext } from '../input/input-state';
 import RemoteImage from './remote-image.react';
 
 type BaseProps = {|
   +mediaInfo: MediaInfo,
   +spinnerColor: string,
 |};
 type Props = {|
   ...BaseProps,
   // withInputState
   +inputState: ?InputState,
 |};
 type State = {|
   +currentURI: string,
   +departingURI: ?string,
 |};
 class Multimedia extends React.PureComponent<Props, State> {
-  static propTypes = {
-    mediaInfo: mediaInfoPropType.isRequired,
-    spinnerColor: PropTypes.string.isRequired,
-    inputState: inputStatePropType,
-  };
   static defaultProps = {
     spinnerColor: 'black',
   };
 
   constructor(props: Props) {
     super(props);
     this.state = {
       currentURI: props.mediaInfo.uri,
       departingURI: null,
     };
   }
 
   get inputState() {
     const { inputState } = this.props;
     invariant(inputState, 'inputState should be set in Multimedia');
     return inputState;
   }
 
   componentDidMount() {
     this.inputState.reportURIDisplayed(this.state.currentURI, true);
   }
 
   componentWillUnmount() {
     const { inputState } = this;
     const { currentURI, departingURI } = this.state;
     inputState.reportURIDisplayed(currentURI, false);
     if (departingURI) {
       inputState.reportURIDisplayed(departingURI, false);
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     const { inputState } = this;
 
     const newURI = this.props.mediaInfo.uri;
     const oldURI = this.state.currentURI;
     if (newURI !== oldURI) {
       inputState.reportURIDisplayed(newURI, true);
 
       const { departingURI } = this.state;
       if (departingURI && oldURI !== departingURI) {
         // If there's currently an existing departingURI, that means that oldURI
         // hasn't loaded yet. Since it's being replaced anyways we don't need to
         // display it anymore, so we can unlink it now
         inputState.reportURIDisplayed(oldURI, false);
         this.setState({ currentURI: newURI });
       } else {
         this.setState({ currentURI: newURI, departingURI: oldURI });
       }
     }
 
     const newDepartingURI = this.state.departingURI;
     const oldDepartingURI = prevState.departingURI;
     if (oldDepartingURI && oldDepartingURI !== newDepartingURI) {
       inputState.reportURIDisplayed(oldDepartingURI, false);
     }
   }
 
   render() {
     const images = [];
     const { currentURI, departingURI } = this.state;
     if (departingURI) {
       images.push(this.renderURI(currentURI, true));
       images.push(this.renderURI(departingURI, true));
     } else {
       images.push(this.renderURI(currentURI));
     }
     return <View style={styles.container}>{images}</View>;
   }
 
   renderURI(uri: string, invisibleLoad?: boolean = false) {
     if (uri.startsWith('http')) {
       return (
         <RemoteImage
           uri={uri}
           onLoad={this.onLoad}
           spinnerColor={this.props.spinnerColor}
           style={styles.image}
           invisibleLoad={invisibleLoad}
           key={uri}
         />
       );
     } else {
       const source = { uri };
       return (
         <Image
           source={source}
           onLoad={this.onLoad}
           style={styles.image}
           key={uri}
         />
       );
     }
   }
 
   onLoad = () => {
     this.setState({ departingURI: null });
   };
 }
 
 const styles = StyleSheet.create({
   container: {
     flex: 1,
   },
   image: {
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
 });
 
 export default React.memo<BaseProps>(function ConnectedMultimedia(
   props: BaseProps,
 ) {
   const inputState = React.useContext(InputStateContext);
   return <Multimedia {...props} inputState={inputState} />;
 });
diff --git a/web/chat/chat-input-bar.react.js b/web/chat/chat-input-bar.react.js
index b54c80852..034a0d895 100644
--- a/web/chat/chat-input-bar.react.js
+++ b/web/chat/chat-input-bar.react.js
@@ -1,480 +1,462 @@
 // @flow
 
 import { faFileImage } from '@fortawesome/free-regular-svg-icons';
 import { faChevronRight } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference';
-import PropTypes from 'prop-types';
 import * as React from 'react';
 
 import { joinThreadActionTypes, joinThread } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { trimMessage } from 'lib/shared/message-utils';
 import {
   threadHasPermission,
   viewerIsMember,
   threadFrozenDueToViewerBlock,
   threadActualMembers,
   useRealThreadCreator,
 } from 'lib/shared/thread-utils';
 import type { CalendarQuery } from 'lib/types/entry-types';
-import { loadingStatusPropType } from 'lib/types/loading-types';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import { messageTypes } from 'lib/types/message-types';
 import {
   type ThreadInfo,
-  threadInfoPropType,
   threadPermissions,
   type ClientThreadJoinRequest,
   type ThreadJoinPayload,
 } from 'lib/types/thread-types';
-import { type UserInfos, userInfoPropType } from 'lib/types/user-types';
+import { type UserInfos } from 'lib/types/user-types';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import {
-  inputStatePropType,
   type InputState,
   type PendingMultimediaUpload,
 } from '../input/input-state';
 import LoadingIndicator from '../loading-indicator.react';
 import { allowedMimeTypeString } from '../media/file-utils';
 import Multimedia from '../media/multimedia.react';
 import FailedSendModal from '../modals/chat/failed-send.react';
 import { useSelector } from '../redux/redux-utils';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors';
 import css from './chat-message-list.css';
 
 type BaseProps = {|
   +threadInfo: ThreadInfo,
   +inputState: InputState,
   +setModal: (modal: ?React.Node) => void,
 |};
 type Props = {|
   ...BaseProps,
   // Redux state
   +viewerID: ?string,
   +joinThreadLoadingStatus: LoadingStatus,
   +calendarQuery: () => CalendarQuery,
   +nextLocalID: number,
   +isThreadActive: boolean,
   +userInfos: UserInfos,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +joinThread: (request: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>,
   +getServerThreadID: () => Promise<?string>,
 |};
 class ChatInputBar extends React.PureComponent<Props> {
-  static propTypes = {
-    threadInfo: threadInfoPropType.isRequired,
-    inputState: inputStatePropType.isRequired,
-    setModal: PropTypes.func.isRequired,
-    viewerID: PropTypes.string,
-    joinThreadLoadingStatus: loadingStatusPropType.isRequired,
-    calendarQuery: PropTypes.func.isRequired,
-    nextLocalID: PropTypes.number.isRequired,
-    isThreadActive: PropTypes.bool.isRequired,
-    userInfos: PropTypes.objectOf(userInfoPropType).isRequired,
-    dispatchActionPromise: PropTypes.func.isRequired,
-    joinThread: PropTypes.func.isRequired,
-    getServerThreadID: PropTypes.func.isRequired,
-  };
   textarea: ?HTMLTextAreaElement;
   multimediaInput: ?HTMLInputElement;
 
   componentDidMount() {
     this.updateHeight();
     if (this.props.isThreadActive) {
       this.addReplyListener();
     }
   }
 
   componentWillUnmount() {
     if (this.props.isThreadActive) {
       this.removeReplyListener();
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     if (this.props.isThreadActive && !prevProps.isThreadActive) {
       this.addReplyListener();
     } else if (!this.props.isThreadActive && prevProps.isThreadActive) {
       this.removeReplyListener();
     }
 
     const { inputState } = this.props;
     const prevInputState = prevProps.inputState;
     if (inputState.draft !== prevInputState.draft) {
       this.updateHeight();
     }
     const curUploadIDs = ChatInputBar.unassignedUploadIDs(
       inputState.pendingUploads,
     );
     const prevUploadIDs = ChatInputBar.unassignedUploadIDs(
       prevInputState.pendingUploads,
     );
     if (
       this.multimediaInput &&
       _difference(prevUploadIDs)(curUploadIDs).length > 0
     ) {
       // Whenever a pending upload is removed, we reset the file
       // HTMLInputElement's value field, so that if the same upload occurs again
       // the onChange call doesn't get filtered
       this.multimediaInput.value = '';
     } else if (
       this.textarea &&
       _difference(curUploadIDs)(prevUploadIDs).length > 0
     ) {
       // Whenever a pending upload is added, we focus the textarea
       this.textarea.focus();
       return;
     }
 
     if (this.props.threadInfo.id !== prevProps.threadInfo.id && this.textarea) {
       this.textarea.focus();
     }
   }
 
   static unassignedUploadIDs(
     pendingUploads: $ReadOnlyArray<PendingMultimediaUpload>,
   ) {
     return pendingUploads
       .filter(
         (pendingUpload: PendingMultimediaUpload) => !pendingUpload.messageID,
       )
       .map((pendingUpload: PendingMultimediaUpload) => pendingUpload.localID);
   }
 
   updateHeight() {
     const textarea = this.textarea;
     if (textarea) {
       textarea.style.height = 'auto';
       const newHeight = Math.min(textarea.scrollHeight, 150);
       textarea.style.height = `${newHeight}px`;
     }
   }
 
   addReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in addReplyListener',
     );
     this.props.inputState.addReplyListener(this.focusAndUpdateText);
   }
 
   removeReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in removeReplyListener',
     );
     this.props.inputState.removeReplyListener(this.focusAndUpdateText);
   }
 
   render() {
     const isMember = viewerIsMember(this.props.threadInfo);
     const canJoin = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.JOIN_THREAD,
     );
     let joinButton = null;
     if (!isMember && canJoin) {
       let buttonContent;
       if (this.props.joinThreadLoadingStatus === 'loading') {
         buttonContent = (
           <LoadingIndicator
             status={this.props.joinThreadLoadingStatus}
             size="medium"
             color="white"
           />
         );
       } else {
         buttonContent = <span className={css.joinButtonText}>Join Thread</span>;
       }
       joinButton = (
         <div className={css.joinButtonContainer}>
           <a onClick={this.onClickJoin}>{buttonContent}</a>
         </div>
       );
     }
 
     const { pendingUploads, cancelPendingUpload } = this.props.inputState;
     const multimediaPreviews = pendingUploads.map((pendingUpload) => (
       <Multimedia
         uri={pendingUpload.uri}
         pendingUpload={pendingUpload}
         remove={cancelPendingUpload}
         multimediaCSSClass={css.multimedia}
         multimediaImageCSSClass={css.multimediaImage}
         key={pendingUpload.localID}
       />
     ));
     const previews =
       multimediaPreviews.length > 0 ? (
         <div className={css.previews}>{multimediaPreviews}</div>
       ) : null;
 
     let content;
     if (threadHasPermission(this.props.threadInfo, threadPermissions.VOICED)) {
       const sendIconStyle = { color: `#${this.props.threadInfo.color}` };
       content = (
         <div className={css.inputBarTextInput}>
           <textarea
             rows="1"
             placeholder="Send a message..."
             value={this.props.inputState.draft}
             onChange={this.onChangeMessageText}
             onKeyDown={this.onKeyDown}
             ref={this.textareaRef}
             autoFocus
           />
           <a className={css.multimediaUpload} onClick={this.onMultimediaClick}>
             <input
               type="file"
               onChange={this.onMultimediaFileChange}
               ref={this.multimediaInputRef}
               accept={allowedMimeTypeString}
               multiple
             />
             <FontAwesomeIcon icon={faFileImage} />
           </a>
           <a className={css.send} onClick={this.onSend}>
             <FontAwesomeIcon
               icon={faChevronRight}
               className={css.sendButton}
               style={sendIconStyle}
             />
             Send
           </a>
         </div>
       );
     } else if (
       threadFrozenDueToViewerBlock(
         this.props.threadInfo,
         this.props.viewerID,
         this.props.userInfos,
       ) &&
       threadActualMembers(this.props.threadInfo.members).length === 2
     ) {
       content = (
         <span className={css.explanation}>
           You can&apos;t send messages to a user that you&apos;ve blocked.
         </span>
       );
     } else if (isMember) {
       content = (
         <span className={css.explanation}>
           You don&apos;t have permission to send messages.
         </span>
       );
     } else {
       const defaultRoleID = Object.keys(this.props.threadInfo.roles).find(
         (roleID) => this.props.threadInfo.roles[roleID].isDefault,
       );
       invariant(
         defaultRoleID !== undefined,
         'all threads should have a default role',
       );
       const defaultRole = this.props.threadInfo.roles[defaultRoleID];
       const membersAreVoiced = !!defaultRole.permissions[
         threadPermissions.VOICED
       ];
       if (membersAreVoiced && canJoin) {
         content = (
           <span className={css.explanation}>
             Join this thread to send messages.
           </span>
         );
       } else {
         content = (
           <span className={css.explanation}>
             You don&apos;t have permission to send messages.
           </span>
         );
       }
     }
 
     return (
       <div className={css.inputBar}>
         {joinButton}
         {previews}
         {content}
       </div>
     );
   }
 
   textareaRef = (textarea: ?HTMLTextAreaElement) => {
     this.textarea = textarea;
     if (textarea) {
       textarea.focus();
     }
   };
 
   onChangeMessageText = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     this.props.inputState.setDraft(event.currentTarget.value);
   };
 
   focusAndUpdateText = (text: string) => {
     // We need to call focus() first on Safari, otherwise the cursor
     // ends up at the start instead of the end for some reason
     const { textarea } = this;
     invariant(textarea, 'textarea should be set');
     textarea.focus();
 
     // We reset the textarea to an empty string at the start so that the cursor
     // always ends up at the end, even if the text doesn't actually change
     textarea.value = '';
     const currentText = this.props.inputState.draft;
     if (!currentText.startsWith(text)) {
       const prependedText = text.concat(currentText);
       this.props.inputState.setDraft(prependedText);
       textarea.value = prependedText;
     } else {
       textarea.value = currentText;
     }
 
     // The above strategies make sure the cursor is at the end,
     // but we also need to make sure that we're scrolled to the bottom
     textarea.scrollTop = textarea.scrollHeight;
   };
 
   onKeyDown = (event: SyntheticKeyboardEvent<HTMLTextAreaElement>) => {
     if (event.keyCode === 13 && !event.shiftKey) {
       event.preventDefault();
       this.send();
     }
   };
 
   onSend = async (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     await this.send();
   };
 
   async send() {
     let { nextLocalID } = this.props;
 
     const text = trimMessage(this.props.inputState.draft);
     if (text) {
       // TODO we should make the send button appear dynamically
       // iff trimmed text is nonempty, just like native
       await this.dispatchTextMessageAction(text, nextLocalID);
       nextLocalID++;
     }
 
     this.props.inputState.createMultimediaMessage(nextLocalID);
   }
 
   async dispatchTextMessageAction(text: string, nextLocalID: number) {
     this.props.inputState.setDraft('');
 
     const localID = `local${nextLocalID}`;
     const creatorID = this.props.viewerID;
     invariant(creatorID, 'should have viewer ID in order to send a message');
 
     const threadID = await this.props.getServerThreadID();
     if (!threadID) {
       return;
     }
 
     this.props.inputState.sendTextMessage({
       type: messageTypes.TEXT,
       localID,
       threadID,
       text,
       creatorID,
       time: Date.now(),
     });
   }
 
   multimediaInputRef = (multimediaInput: ?HTMLInputElement) => {
     this.multimediaInput = multimediaInput;
   };
 
   onMultimediaClick = () => {
     if (this.multimediaInput) {
       this.multimediaInput.click();
     }
   };
 
   onMultimediaFileChange = async (
     event: SyntheticInputEvent<HTMLInputElement>,
   ) => {
     const result = await this.props.inputState.appendFiles([
       ...event.target.files,
     ]);
     if (!result && this.multimediaInput) {
       this.multimediaInput.value = '';
     }
   };
 
   onClickJoin = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     this.props.dispatchActionPromise(joinThreadActionTypes, this.joinAction());
   };
 
   async joinAction() {
     const query = this.props.calendarQuery();
     return await this.props.joinThread({
       threadID: this.props.threadInfo.id,
       calendarQuery: {
         startDate: query.startDate,
         endDate: query.endDate,
         filters: [
           ...query.filters,
           { type: 'threads', threadIDs: [this.props.threadInfo.id] },
         ],
       },
     });
   }
 }
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 
 export default React.memo<BaseProps>(function ConnectedChatInputBar(
   props: BaseProps,
 ) {
   const viewerID = useSelector(
     (state) => state.currentUserInfo && state.currentUserInfo.id,
   );
   const nextLocalID = useSelector((state) => state.nextLocalID);
   const isThreadActive = useSelector(
     (state) => props.threadInfo.id === state.navInfo.activeChatThreadID,
   );
   const userInfos = useSelector((state) => state.userStore.userInfos);
   const joinThreadLoadingStatus = useSelector(joinThreadLoadingStatusSelector);
   const calendarQuery = useSelector(nonThreadCalendarQuery);
   const dispatchActionPromise = useDispatchActionPromise();
   const callJoinThread = useServerCall(joinThread);
 
   const { setModal } = props;
   const showErrorModal = React.useCallback(
     () => setModal(<FailedSendModal setModal={setModal} />),
     [setModal],
   );
   const sourceMessageID = useSelector((state) => state.navInfo.sourceMessageID);
   const getServerThreadID = useRealThreadCreator(
     { threadInfo: props.threadInfo, sourceMessageID },
     showErrorModal,
   );
 
   return (
     <ChatInputBar
       {...props}
       viewerID={viewerID}
       joinThreadLoadingStatus={joinThreadLoadingStatus}
       calendarQuery={calendarQuery}
       nextLocalID={nextLocalID}
       isThreadActive={isThreadActive}
       userInfos={userInfos}
       dispatchActionPromise={dispatchActionPromise}
       joinThread={callJoinThread}
       getServerThreadID={getServerThreadID}
     />
   );
 });
diff --git a/web/input/input-state.js b/web/input/input-state.js
index 652de0438..26c56db05 100644
--- a/web/input/input-state.js
+++ b/web/input/input-state.js
@@ -1,99 +1,57 @@
 // @flow
 
-import PropTypes from 'prop-types';
 import * as React from 'react';
 
 import {
   type MediaType,
-  mediaTypePropType,
   type Dimensions,
-  dimensionsPropType,
   type MediaMissionStep,
-  mediaMissionStepPropType,
 } from 'lib/types/media-types';
 import type { RawTextMessageInfo } from 'lib/types/messages/text';
 
 export type PendingMultimediaUpload = {|
   localID: string,
   // Pending uploads are assigned a serverID once they are complete
   serverID: ?string,
   // Pending uploads are assigned a messageID once they are sent
   messageID: ?string,
   // This is set to truthy if the upload fails for whatever reason
   failed: ?string,
   file: File,
   mediaType: MediaType,
   dimensions: ?Dimensions,
   uri: string,
   loop: boolean,
   // URLs created with createObjectURL aren't considered "real". The distinction
   // is required because those "fake" URLs must be disposed properly
   uriIsReal: boolean,
   progressPercent: number,
   // This is set once the network request begins and used if the upload is
   // cancelled
   abort: ?() => void,
   steps: MediaMissionStep[],
   selectTime: number,
 |};
-const pendingMultimediaUploadPropType = PropTypes.shape({
-  localID: PropTypes.string.isRequired,
-  serverID: PropTypes.string,
-  messageID: PropTypes.string,
-  failed: PropTypes.string,
-  file: PropTypes.object.isRequired,
-  mediaType: mediaTypePropType.isRequired,
-  dimensions: dimensionsPropType,
-  uri: PropTypes.string.isRequired,
-  loop: PropTypes.bool.isRequired,
-  uriIsReal: PropTypes.bool.isRequired,
-  progressPercent: PropTypes.number.isRequired,
-  abort: PropTypes.func,
-  steps: PropTypes.arrayOf(mediaMissionStepPropType).isRequired,
-  selectTime: PropTypes.number.isRequired,
-});
 
 // This type represents the input state for a particular thread
 export type InputState = {|
   pendingUploads: $ReadOnlyArray<PendingMultimediaUpload>,
   assignedUploads: {
     [messageID: string]: $ReadOnlyArray<PendingMultimediaUpload>,
   },
   draft: string,
   appendFiles: (files: $ReadOnlyArray<File>) => Promise<boolean>,
   cancelPendingUpload: (localUploadID: string) => void,
   sendTextMessage: (messageInfo: RawTextMessageInfo) => void,
   createMultimediaMessage: (localID: number) => void,
   setDraft: (draft: string) => void,
   messageHasUploadFailure: (localMessageID: string) => boolean,
   retryMultimediaMessage: (localMessageID: string) => void,
   addReply: (text: string) => void,
   addReplyListener: ((message: string) => void) => void,
   removeReplyListener: ((message: string) => void) => void,
 |};
-const arrayOfUploadsPropType = PropTypes.arrayOf(
-  pendingMultimediaUploadPropType,
-);
-const inputStatePropType = PropTypes.shape({
-  pendingUploads: arrayOfUploadsPropType.isRequired,
-  assignedUploads: PropTypes.objectOf(arrayOfUploadsPropType).isRequired,
-  draft: PropTypes.string.isRequired,
-  appendFiles: PropTypes.func.isRequired,
-  cancelPendingUpload: PropTypes.func.isRequired,
-  sendTextMessage: PropTypes.func.isRequired,
-  createMultimediaMessage: PropTypes.func.isRequired,
-  setDraft: PropTypes.func.isRequired,
-  messageHasUploadFailure: PropTypes.func.isRequired,
-  retryMultimediaMessage: PropTypes.func.isRequired,
-  addReply: PropTypes.func.isRequired,
-  addReplyListener: PropTypes.func.isRequired,
-  removeReplyListener: PropTypes.func.isRequired,
-});
 
 const InputStateContext = React.createContext<?InputState>(null);
 
-export {
-  pendingMultimediaUploadPropType,
-  inputStatePropType,
-  InputStateContext,
-};
+export { InputStateContext };
diff --git a/web/media/multimedia.react.js b/web/media/multimedia.react.js
index 0fb5886ae..9ac8360d3 100644
--- a/web/media/multimedia.react.js
+++ b/web/media/multimedia.react.js
@@ -1,128 +1,115 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
-import PropTypes from 'prop-types';
 import * as React from 'react';
 import { CircularProgressbar } from 'react-circular-progressbar';
 import 'react-circular-progressbar/dist/styles.css';
 import {
   XCircle as XCircleIcon,
   AlertCircle as AlertCircleIcon,
 } from 'react-feather';
 
-import {
-  type PendingMultimediaUpload,
-  pendingMultimediaUploadPropType,
-} from '../input/input-state';
+import { type PendingMultimediaUpload } from '../input/input-state';
 import css from './media.css';
 import MultimediaModal from './multimedia-modal.react';
 
 type Props = {|
   uri: string,
   pendingUpload?: ?PendingMultimediaUpload,
   remove?: (uploadID: string) => void,
   setModal?: (modal: ?React.Node) => void,
   multimediaCSSClass: string,
   multimediaImageCSSClass: string,
 |};
 class Multimedia extends React.PureComponent<Props> {
-  static propTypes = {
-    uri: PropTypes.string.isRequired,
-    pendingUpload: pendingMultimediaUploadPropType,
-    remove: PropTypes.func,
-    setModal: PropTypes.func,
-    multimediaCSSClass: PropTypes.string.isRequired,
-    multimediaImageCSSClass: PropTypes.string.isRequired,
-  };
-
   componentDidUpdate(prevProps: Props) {
     const { uri, pendingUpload } = this.props;
     if (uri === prevProps.uri) {
       return;
     }
     if (
       (!pendingUpload || pendingUpload.uriIsReal) &&
       (!prevProps.pendingUpload || !prevProps.pendingUpload.uriIsReal)
     ) {
       URL.revokeObjectURL(prevProps.uri);
     }
   }
 
   render() {
     let progressIndicator, errorIndicator, removeButton;
 
     const { pendingUpload, remove, setModal } = this.props;
     if (pendingUpload) {
       const { progressPercent, failed } = pendingUpload;
 
       if (progressPercent !== 0 && progressPercent !== 1) {
         const outOfHundred = Math.floor(progressPercent * 100);
         const text = `${outOfHundred}%`;
         progressIndicator = (
           <CircularProgressbar
             value={outOfHundred}
             text={text}
             background
             backgroundPadding={6}
             className={css.progressIndicator}
           />
         );
       }
 
       if (failed) {
         errorIndicator = (
           <AlertCircleIcon className={css.uploadError} size={36} />
         );
       }
 
       if (remove) {
         removeButton = (
           <XCircleIcon onClick={this.remove} className={css.removeUpload} />
         );
       }
     }
 
     const imageContainerClasses = [
       css.multimediaImage,
       this.props.multimediaImageCSSClass,
     ];
     let onClick;
     if (setModal) {
       imageContainerClasses.push(css.clickable);
       onClick = this.onClick;
     }
 
     const containerClasses = [css.multimedia, this.props.multimediaCSSClass];
     return (
       <span className={classNames(containerClasses)}>
         <span className={classNames(imageContainerClasses)} onClick={onClick}>
           <img src={this.props.uri} />
           {removeButton}
         </span>
         {progressIndicator}
         {errorIndicator}
       </span>
     );
   }
 
   remove = () => {
     const { remove, pendingUpload } = this.props;
     invariant(
       remove && pendingUpload,
       'Multimedia cannot be removed as either remove or pendingUpload ' +
         'are unspecified',
     );
     remove(pendingUpload.localID);
   };
 
   onClick = (event: SyntheticEvent<HTMLSpanElement>) => {
     event.stopPropagation();
 
     const { setModal, uri } = this.props;
     invariant(setModal, 'should be set');
     setModal(<MultimediaModal uri={uri} setModal={setModal} />);
   };
 }
 
 export default Multimedia;