[RN] Update react-native to 0.55.4 (continued)

.gitignore

 */fastlane/report.xml
 */fastlane/Preview.html
 */fastlane/screenshots
+
+# Bundle artifact
+*.jsbundle

flow-typed/npm/lodash_v4.x.x.js

+// flow-typed signature: 99202f0cce15ad31fae01af918065827
+// flow-typed version: ce66c2353d/lodash_v4.x.x/flow_>=v0.63.x
+
 declare module "lodash" {
   declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
   declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, *>;
     // Array
     chunk<T>(array?: ?Array<T>, size?: ?number): Array<Array<T>>;
     compact<T, N: ?T>(array?: ?Array<N>): Array<T>;
-    concat<T>(base?: ?Array<T>, ...elements: Array<any>): Array<T | any>;
-    difference<T>(array?: ?$ReadOnlyArray<T>, values?: ?$ReadOnlyArray<T>): Array<T>;
+    concat<T>(base?: ?$ReadOnlyArray<T>, ...elements: Array<any>): Array<T | any>;
+    difference<T>(array?: ?$ReadOnlyArray<T>, ...values: Array<?$ReadOnlyArray<T>>): Array<T>;
     differenceBy<T>(
       array?: ?$ReadOnlyArray<T>,
       values?: ?$ReadOnlyArray<T>,
       fromIndex?: ?number
     ): -1;
     // alias of _.head
-    first<T>(array: ?Array<T>): T;
+    first<T>(array: ?$ReadOnlyArray<T>): T;
     flatten<T, X>(array?: ?Array<Array<T> | X>): Array<T | X>;
     flattenDeep<T>(array?: ?any[]): Array<T>;
     flattenDepth(array?: ?any[], depth?: ?number): any[];
     fromPairs<A, B>(pairs?: ?Array<[A, B]>): { [key: A]: B };
-    head<T>(array: ?Array<T>): T;
+    head<T>(array: ?$ReadOnlyArray<T>): T;
     indexOf<T>(array: Array<T>, value: T, fromIndex?: number): number;
     indexOf<T>(array: void | null, value?: ?T, fromIndex?: ?number): -1;
     initial<T>(array: ?Array<T>): Array<T>;
     remove<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
     reverse<T>(array: Array<T>): Array<T>;
     reverse<T: void | null>(array: T): T;
-    slice<T>(array?: ?Array<T>, start?: ?number, end?: ?number): Array<T>;
+    slice<T>(array?: ?$ReadOnlyArray<T>, start?: ?number, end?: ?number): Array<T>;
     sortedIndex<T>(array: Array<T>, value: T): number;
     sortedIndex<T>(array: void | null, value: ?T): 0;
     sortedIndexBy<T>(
     uniqWith<T>(array?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
     unzip<T>(array?: ?Array<T>): Array<T>;
     unzipWith<T>(array: ?Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
-    without<T>(array?: ?Array<T>, ...values?: Array<?T>): Array<T>;
+    without<T>(array?: ?$ReadOnlyArray<T>, ...values?: Array<?T>): Array<T>;
     xor<T>(...array: Array<Array<T>>): Array<T>;
     //Workaround until (...parameter: T, parameter2: U) works
     xorBy<T>(a1?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
     countBy<T>(array: void | null, iteratee?: ?ValueOnlyIteratee<T>): {};
     countBy<T: Object>(object: T, iteratee?: ?ValueOnlyIteratee<T>): Object;
     // alias of _.forEach
-    each<T>(array: Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
+    each<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
     each<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
     each<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
     // alias of _.forEachRight
-    eachRight<T>(array: Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
+    eachRight<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
     eachRight<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
     eachRight<T: Object>(object: T, iteratee?: OIteratee<T>): T;
     every<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): boolean;
     every<T: Object>(object: T, iteratee?: OIteratee<T>): boolean;
-    filter<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+    filter<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
     filter<A, T: { [id: string]: A }>(
       object: T,
       predicate?: OPredicate<A, T>
       iteratee?: OFlatMapIteratee<T, U>,
       depth?: number
     ): Array<U>;
-    forEach<T>(array: Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
+    forEach<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
     forEach<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
     forEach<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
-    forEachRight<T>(array: Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
+    forEachRight<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
     forEachRight<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
     forEachRight<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
     groupBy<V, T>(
       object: T,
       iteratee?: ValueOnlyIteratee<A>
     ): { [key: V]: Array<A> };
-    includes<T>(array: Array<T>, value: T, fromIndex?: ?number): boolean;
+    includes<T>(array: $ReadOnlyArray<T>, value: T, fromIndex?: ?number): boolean;
     includes<T>(array: void | null, value?: ?T, fromIndex?: ?number): false;
     includes<T: Object>(object: T, value: any, fromIndex?: number): boolean;
     includes(str: string, value: string, fromIndex?: number): boolean;
       iteratee?: ?(accumulator: U, value: any, key: string, object: T) => U,
       accumulator?: ?U
     ): U;
-    reject<T>(array: ?Array<T>, predicate?: Predicate<T>): Array<T>;
+    reject<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>): Array<T>;
     reject<V: Object, A, T: { [id: string]: A }>(
       object?: ?T,
       predicate?: ?OPredicate<A, T>
     sampleSize<V, T: Object>(object: T, n?: number): Array<V>;
     shuffle<T>(array: ?Array<T>): Array<T>;
     shuffle<V, T: Object>(object: T): Array<V>;
-    size(collection: Array<any> | Object | string): number;
+    size(collection: $ReadOnlyArray<any> | Object | string): number;
     some<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>): boolean;
     some<T>(array: void | null, predicate?: ?Predicate<T>): false;
     some<A, T: { [id: string]: A }>(
     random(lower?: number, upper?: number, floating?: boolean): number;
 
     // Object
-    assign(object?: ?Object, ...sources?: Array<Object>): Object;
+    assign(object?: ?Object, ...sources?: Array<?Object>): Object;
     assignIn(): {};
     assignIn<A, B>(a: A, b: B): A & B;
     assignIn<A, B, C>(a: A, b: B, c: C): A & B & C;
     at(object?: ?Object, paths: Array<string>): Array<any>;
     create<T>(prototype: T, properties: Object): $Supertype<T>;
     create(prototype: any, properties: void | null): {};
-    defaults(object?: ?Object, ...sources?: Array<Object>): Object;
-    defaultsDeep(object?: ?Object, ...sources?: Array<Object>): Object;
+    defaults(object?: ?Object, ...sources?: Array<?Object>): Object;
+    defaultsDeep(object?: ?Object, ...sources?: Array<?Object>): Object;
     // alias for _.toPairs
     entries(object?: ?Object): Array<[string, any]>;
     // alias for _.toPairsIn
     functions(object?: ?Object): Array<string>;
     functionsIn(object?: ?Object): Array<string>;
     get(
-      object?: ?Object | ?Array<any>,
-      path?: ?Array<string> | string,
+      object?: ?Object | ?$ReadOnlyArray<any>,
+      path?: ?$ReadOnlyArray<string> | string,
       defaultValue?: any
     ): any;
     has(object: Object, path: Array<string> | string): boolean;
       array: $ReadOnlyArray<T>
     ): number;
     // alias of _.head
-    first<T>(array: Array<T>): T;
+    first<T>(array: $ReadOnlyArray<T>): T;
     flatten<T, X>(array: Array<Array<T> | X>): Array<T | X>;
     unnest<T, X>(array: Array<Array<T> | X>): Array<T | X>;
     flattenDeep<T>(array: any[]): Array<T>;
     flattenDepth(depth: number): (array: any[]) => any[];
     flattenDepth(depth: number, array: any[]): any[];
     fromPairs<A, B>(pairs: Array<[A, B]>): { [key: A]: B };
-    head<T>(array: Array<T>): T;
+    head<T>(array: $ReadOnlyArray<T>): T;
     indexOf<T>(value: T): (array: Array<T>) => number;
     indexOf<T>(value: T, array: Array<T>): number;
     indexOfFrom<T>(
     // alias of _.forEach
     each<T>(
       iteratee: Iteratee<T> | OIteratee<T>
-    ): (collection: Array<T> | { [id: any]: T }) => Array<T>;
+    ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => Array<T>;
     each<T>(
       iteratee: Iteratee<T> | OIteratee<T>,
-      collection: Array<T> | { [id: any]: T }
+      collection: $ReadOnlyArray<T> | { [id: any]: T }
     ): Array<T>;
     // alias of _.forEachRight
     eachRight<T>(
       iteratee: Iteratee<T> | OIteratee<T>
-    ): (collection: Array<T> | { [id: any]: T }) => Array<T>;
+    ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => Array<T>;
     eachRight<T>(
       iteratee: Iteratee<T> | OIteratee<T>,
-      collection: Array<T> | { [id: any]: T }
+      collection: $ReadOnlyArray<T> | { [id: any]: T }
     ): Array<T>;
     every<T>(
       iteratee: Iteratee<T> | OIteratee<T>
     ): Array<U>;
     forEach<T>(
       iteratee: Iteratee<T> | OIteratee<T>
-    ): (collection: Array<T> | { [id: any]: T }) => Array<T>;
+    ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => Array<T>;
     forEach<T>(
       iteratee: Iteratee<T> | OIteratee<T>,
-      collection: Array<T> | { [id: any]: T }
+      collection: $ReadOnlyArray<T> | { [id: any]: T }
     ): Array<T>;
     forEachRight<T>(
       iteratee: Iteratee<T> | OIteratee<T>
-    ): (collection: Array<T> | { [id: any]: T }) => Array<T>;
+    ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => Array<T>;
     forEachRight<T>(
       iteratee: Iteratee<T> | OIteratee<T>,
-      collection: Array<T> | { [id: any]: T }
+      collection: $ReadOnlyArray<T> | { [id: any]: T }
     ): Array<T>;
     groupBy<V, T>(
       iteratee: ValueOnlyIteratee<T>
     ): (collection: Array<T> | { [id: any]: T }) => Array<T>;
     sampleSize<T>(n: number, collection: Array<T> | { [id: any]: T }): Array<T>;
     shuffle<T>(collection: Array<T> | { [id: any]: T }): Array<T>;
-    size(collection: Array<any> | Object | string): number;
+    size(collection: $ReadOnlyArray<any> | Object | string): number;
     some<T>(
       predicate: Predicate<T> | OPredicate<T>
     ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => boolean;
     forOwnRight(iteratee: OIteratee<*>, object: Object): Object;
     functions(object: Object): Array<string>;
     functionsIn(object: Object): Array<string>;
-    get(path: Array<string> | string): (object: Object | Array<any>) => any;
-    get(path: Array<string> | string, object: Object | Array<any>): any;
+    get(path: $ReadOnlyArray<string> | string): (object: Object | $ReadOnlyArray<any>) => any;
+    get(path: $ReadOnlyArray<string> | string, object: Object | $ReadOnlyArray<any>): any;
     prop(path: Array<string> | string): (object: Object | Array<any>) => any;
     prop(path: Array<string> | string, object: Object | Array<any>): any;
     path(path: Array<string> | string): (object: Object | Array<any>) => any;

flow-typed/npm/moment_v2.3.x.js

+// flow-typed signature: c30aa20539f52183d4d30dd36d8ab9c2
+// flow-typed version: 886cf7c002/moment_v2.3.x/flow_>=v0.63.x
+
+type moment$MomentOptions = {
+  y?: number | string,
+  year?: number | string,
+  years?: number | string,
+  M?: number | string,
+  month?: number | string,
+  months?: number | string,
+  d?: number | string,
+  day?: number | string,
+  days?: number | string,
+  date?: number | string,
+  h?: number | string,
+  hour?: number | string,
+  hours?: number | string,
+  m?: number | string,
+  minute?: number | string,
+  minutes?: number | string,
+  s?: number | string,
+  second?: number | string,
+  seconds?: number | string,
+  ms?: number | string,
+  millisecond?: number | string,
+  milliseconds?: number | string
+};
+
+type moment$MomentObject = {
+  years: number,
+  months: number,
+  date: number,
+  hours: number,
+  minutes: number,
+  seconds: number,
+  milliseconds: number
+};
+
+type moment$MomentCreationData = {
+  input: string,
+  format: string,
+  locale: Object,
+  isUTC: boolean,
+  strict: boolean
+};
+
+type moment$CalendarFormat = string | ((moment: moment$Moment) => string);
+
+type moment$CalendarFormats = {
+  sameDay?: moment$CalendarFormat,
+  nextDay?: moment$CalendarFormat,
+  nextWeek?: moment$CalendarFormat,
+  lastDay?: moment$CalendarFormat,
+  lastWeek?: moment$CalendarFormat,
+  sameElse?: moment$CalendarFormat
+};
+
+declare class moment$LocaleData {
+  months(moment: moment$Moment): string,
+  monthsShort(moment: moment$Moment): string,
+  monthsParse(month: string): number,
+  weekdays(moment: moment$Moment): string,
+  weekdaysShort(moment: moment$Moment): string,
+  weekdaysMin(moment: moment$Moment): string,
+  weekdaysParse(weekDay: string): number,
+  longDateFormat(dateFormat: string): string,
+  isPM(date: string): boolean,
+  meridiem(hours: number, minutes: number, isLower: boolean): string,
+  calendar(
+    key:
+      | "sameDay"
+      | "nextDay"
+      | "lastDay"
+      | "nextWeek"
+      | "prevWeek"
+      | "sameElse",
+    moment: moment$Moment
+  ): string,
+  relativeTime(
+    number: number,
+    withoutSuffix: boolean,
+    key: "s" | "m" | "mm" | "h" | "hh" | "d" | "dd" | "M" | "MM" | "y" | "yy",
+    isFuture: boolean
+  ): string,
+  pastFuture(diff: any, relTime: string): string,
+  ordinal(number: number): string,
+  preparse(str: string): any,
+  postformat(str: string): any,
+  week(moment: moment$Moment): string,
+  invalidDate(): string,
+  firstDayOfWeek(): number,
+  firstDayOfYear(): number
+}
+declare class moment$MomentDuration {
+  humanize(suffix?: boolean): string,
+  milliseconds(): number,
+  asMilliseconds(): number,
+  seconds(): number,
+  asSeconds(): number,
+  minutes(): number,
+  asMinutes(): number,
+  hours(): number,
+  asHours(): number,
+  days(): number,
+  asDays(): number,
+  months(): number,
+  asMonths(): number,
+  years(): number,
+  asYears(): number,
+  add(value: number | moment$MomentDuration | Object, unit?: string): this,
+  subtract(value: number | moment$MomentDuration | Object, unit?: string): this,
+  as(unit: string): number,
+  get(unit: string): number,
+  toJSON(): string,
+  toISOString(): string,
+  isValid(): boolean
+}
+declare class moment$Moment {
+  static ISO_8601: string,
+  static (
+    string?: string,
+    format?: string | Array<string>,
+    strict?: boolean
+  ): moment$Moment,
+  static (
+    string?: string,
+    format?: string | Array<string>,
+    locale?: string,
+    strict?: boolean
+  ): moment$Moment,
+  static (
+    initDate: ?Object | number | Date | Array<number> | moment$Moment | string
+  ): moment$Moment,
+  static unix(seconds: number): moment$Moment,
+  static utc(): moment$Moment,
+  static utc(number: number | Array<number>): moment$Moment,
+  static utc(
+    str: string,
+    str2?: string | Array<string>,
+    str3?: string
+  ): moment$Moment,
+  static utc(moment: moment$Moment): moment$Moment,
+  static utc(date: Date): moment$Moment,
+  static parseZone(): moment$Moment,
+  static parseZone(rawDate: string): moment$Moment,
+  static parseZone(
+    rawDate: string,
+    format: string | Array<string>
+  ): moment$Moment,
+  static parseZone(
+    rawDate: string,
+    format: string,
+    strict: boolean
+  ): moment$Moment,
+  static parseZone(
+    rawDate: string,
+    format: string,
+    locale: string,
+    strict: boolean
+  ): moment$Moment,
+  isValid(): boolean,
+  invalidAt(): 0 | 1 | 2 | 3 | 4 | 5 | 6,
+  creationData(): moment$MomentCreationData,
+  millisecond(number: number): this,
+  milliseconds(number: number): this,
+  millisecond(): number,
+  milliseconds(): number,
+  second(number: number): this,
+  seconds(number: number): this,
+  second(): number,
+  seconds(): number,
+  minute(number: number): this,
+  minutes(number: number): this,
+  minute(): number,
+  minutes(): number,
+  hour(number: number): this,
+  hours(number: number): this,
+  hour(): number,
+  hours(): number,
+  date(number: number): this,
+  dates(number: number): this,
+  date(): number,
+  dates(): number,
+  day(day: number | string): this,
+  days(day: number | string): this,
+  day(): number,
+  days(): number,
+  weekday(number: number): this,
+  weekday(): number,
+  isoWeekday(number: number): this,
+  isoWeekday(): number,
+  dayOfYear(number: number): this,
+  dayOfYear(): number,
+  week(number: number): this,
+  weeks(number: number): this,
+  week(): number,
+  weeks(): number,
+  isoWeek(number: number): this,
+  isoWeeks(number: number): this,
+  isoWeek(): number,
+  isoWeeks(): number,
+  month(number: number): this,
+  months(number: number): this,
+  month(): number,
+  months(): number,
+  quarter(number: number): this,
+  quarter(): number,
+  year(number: number): this,
+  years(number: number): this,
+  year(): number,
+  years(): number,
+  weekYear(number: number): this,
+  weekYear(): number,
+  isoWeekYear(number: number): this,
+  isoWeekYear(): number,
+  weeksInYear(): number,
+  isoWeeksInYear(): number,
+  get(string: string): number,
+  set(unit: string, value: number): this,
+  set(options: { [unit: string]: number }): this,
+  static max(...dates: Array<moment$Moment>): moment$Moment,
+  static max(dates: Array<moment$Moment>): moment$Moment,
+  static min(...dates: Array<moment$Moment>): moment$Moment,
+  static min(dates: Array<moment$Moment>): moment$Moment,
+  add(
+    value: number | moment$MomentDuration | moment$Moment | Object,
+    unit?: string
+  ): this,
+  subtract(
+    value: number | moment$MomentDuration | moment$Moment | string | Object,
+    unit?: string
+  ): this,
+  startOf(unit: string): this,
+  endOf(unit: string): this,
+  local(): this,
+  utc(): this,
+  utcOffset(
+    offset: number | string,
+    keepLocalTime?: boolean,
+    keepMinutes?: boolean
+  ): this,
+  utcOffset(): number,
+  format(format?: string): string,
+  fromNow(removeSuffix?: boolean): string,
+  from(
+    value: moment$Moment | string | number | Date | Array<number>,
+    removePrefix?: boolean
+  ): string,
+  toNow(removePrefix?: boolean): string,
+  to(
+    value: moment$Moment | string | number | Date | Array<number>,
+    removePrefix?: boolean
+  ): string,
+  calendar(refTime?: any, formats?: moment$CalendarFormats): string,
+  diff(
+    date: moment$Moment | string | number | Date | Array<number>,
+    format?: string,
+    floating?: boolean
+  ): number,
+  valueOf(): number,
+  unix(): number,
+  daysInMonth(): number,
+  toDate(): Date,
+  toArray(): Array<number>,
+  toJSON(): string,
+  toISOString(
+    keepOffset?: boolean
+  ): string,
+  toObject(): moment$MomentObject,
+  isBefore(
+    date?: moment$Moment | string | number | Date | Array<number>,
+    units?: ?string
+  ): boolean,
+  isSame(
+    date?: moment$Moment | string | number | Date | Array<number>,
+    units?: ?string
+  ): boolean,
+  isAfter(
+    date?: moment$Moment | string | number | Date | Array<number>,
+    units?: ?string
+  ): boolean,
+  isSameOrBefore(
+    date?: moment$Moment | string | number | Date | Array<number>,
+    units?: ?string
+  ): boolean,
+  isSameOrAfter(
+    date?: moment$Moment | string | number | Date | Array<number>,
+    units?: ?string
+  ): boolean,
+  isBetween(
+    fromDate: moment$Moment | string | number | Date | Array<number>,
+    toDate?: ?moment$Moment | string | number | Date | Array<number>,
+    granularity?: ?string,
+    inclusion?: ?string
+  ): boolean,
+  isDST(): boolean,
+  isDSTShifted(): boolean,
+  isLeapYear(): boolean,
+  clone(): moment$Moment,
+  static isMoment(obj: any): boolean,
+  static isDate(obj: any): boolean,
+  static locale(locale: string, localeData?: Object): string,
+  static updateLocale(locale: string, localeData?: ?Object): void,
+  static locale(locales: Array<string>): string,
+  locale(locale: string, customization?: Object | null): moment$Moment,
+  locale(): string,
+  static months(): Array<string>,
+  static monthsShort(): Array<string>,
+  static weekdays(): Array<string>,
+  static weekdaysShort(): Array<string>,
+  static weekdaysMin(): Array<string>,
+  static months(): string,
+  static monthsShort(): string,
+  static weekdays(): string,
+  static weekdaysShort(): string,
+  static weekdaysMin(): string,
+  static localeData(key?: string): moment$LocaleData,
+  static duration(
+    value: number | Object | string,
+    unit?: string
+  ): moment$MomentDuration,
+  static isDuration(obj: any): boolean,
+  static normalizeUnits(unit: string): string,
+  static invalid(object: any): moment$Moment
+}
+
+declare module "moment" {
+  declare module.exports: Class<moment$Moment>;
+}

flow-typed/npm/prop-types_v15.x.x.js

+// flow-typed signature: d9a983bb1ac458a256c31c139047bdbb
+// flow-typed version: 927687984d/prop-types_v15.x.x/flow_>=v0.41.x
+
 type $npm$propTypes$ReactPropsCheckType = (
   props: any,
   propName: string,

flow-typed/npm/react-redux_v5.x.x.js

+// flow-typed signature: d4e793bc07ef1dc9906a244b12960f7b
+// flow-typed version: cf33ff8762/react-redux_v5.x.x/flow_>=v0.63.0
+
 import type { Dispatch, Store } from "redux";
 
 declare module "react-redux" {
     mergeProps: MergeProps<RSP, RDP, MP, RMP>
   ): (component: Com) => ComponentType<CP & SP & DP & MP>;
 
+  declare export function connect<
+    Com: ComponentType<*>,
+    A,
+    S: Object,
+    DP: Object,
+    SP: Object,
+    RSP: Object,
+    RDP: Object,
+    MDP: Object,
+    MP: Object,
+    RMP: Object,
+    CP: $Diff<ElementConfig<Com>, RMP>
+    >(
+    mapStateToProps: MapStateToProps<S, SP, RSP>,
+    mapDispatchToProps: MDP,
+    mergeProps: MergeProps<RSP, RDP, MP, RMP>
+  ): (component: Com) => ComponentType<CP & SP & DP & MP>;
+
   declare export function connect<Com: ComponentType<*>,
     A,
     S: Object,
     options: ConnectOptions<S, SP & DP & MP, RSP, RMP>
   ): (component: Com) => ComponentType<$Diff<ElementConfig<Com>, RMP> & SP & DP & MP>;
 
+  declare export function connect<Com: ComponentType<*>,
+    A,
+    S: Object,
+    DP: Object,
+    SP: Object,
+    RSP: Object,
+    RDP: Object,
+    MDP: Object,
+    MP: Object,
+    RMP: Object
+    >(
+    mapStateToProps: ?MapStateToProps<S, SP, RSP>,
+    mapDispatchToProps: ?MapDispatchToProps<A, DP, RDP>,
+    mergeProps: MDP,
+    options: ConnectOptions<S, SP & DP & MP, RSP, RMP>
+  ): (component: Com) => ComponentType<$Diff<ElementConfig<Com>, RMP> & SP & DP & MP>;
+
   declare export default {
     Provider: typeof Provider,
     createProvider: typeof createProvider,

flow-typed/npm/uuid_v3.x.x.js

+// flow-typed signature: 3cf668e64747095cab0bb360cf2fb34f
+// flow-typed version: d659bd0cb8/uuid_v3.x.x/flow_>=v0.32.x
+
 declare module "uuid" {
   declare class uuid {
     static (

react/features/base/i18n/dateUtil.js

  * @returns {Object}
  */
 export function getLocalizedDurationFormatter(duration: number) {
+    // FIXME The flow-type definition of moment is v2.3 while our package.json
+    // states v2.19 so maybe locale on moment's duration was introduced in
+    // between?
+    //
+    // $FlowFixMe
     return moment.duration(duration).locale(_getSupportedLocale());
 }
 
                     `^${localeResult[1]}(-)*${`(${localeResult[3]})*` || ''}`);
 
             supportedLocale
+
+                // FIXME The flow-type definition of moment is v2.3 while our
+                // package.json states v2.19 so maybe locales on moment was
+                // introduced in between?
+                //
+                // $FlowFixMe
                 = moment.locales().find(lang => currentLocaleRegexp.exec(lang));
         }
     }