diff --git a/cli/src/commands/__tests__/runTests-test.js b/cli/src/commands/__tests__/runTests-test.js
index b58db78177..5a49b0917b 100644
--- a/cli/src/commands/__tests__/runTests-test.js
+++ b/cli/src/commands/__tests__/runTests-test.js
@@ -26,7 +26,7 @@ describe('run-tests (command)', () => {
 
     it('console logs about unused suppression', async () => {
       const expectedError = `Unused suppression`;
-      const calls = ((console.log: any): JestMockFn<*, *>).mock.calls;
+      const calls = ((console.log: any): JestMockFn<any, any>).mock.calls;
       const lastErrorMsg = calls[calls.length - 1][1];
       expect(lastErrorMsg).toContain(expectedError);
     });
diff --git a/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-/react-components_v3.x.x.js b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-v.200.x/react-components_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-/react-components_v3.x.x.js
rename to definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-v.200.x/react-components_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-/test_react-components_v3.x.x.js b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-v.200.x/test_react-components_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-/test_react-components_v3.x.x.js
rename to definitions/npm/@apollo/react-components_v3.x.x/flow_v0.104.x-v.200.x/test_react-components_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/react-components_v3.x.x.js b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/react-components_v3.x.x.js
new file mode 100644
index 0000000000..bbd729967d
--- /dev/null
+++ b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/react-components_v3.x.x.js
@@ -0,0 +1,1050 @@
+declare module '@apollo/react-components' {
+  import type { ComponentType, Element, Node } from 'react';
+
+  declare export type MakeOptional = <V>(V) => ?V;
+  declare export type MakeDataOptional<TData> = $ObjMap<
+    TData,
+    MakeOptional
+  > | void;
+
+  declare export type Record<T, U> = {
+    [key: T]: U,
+    ...,
+  };
+
+  declare export type Dict = Record<string, any>;
+  /**
+   * Copied types from Apollo Client libdef
+   * Please update apollo-client libdef as well if updating these types
+   */
+  declare class ObservableQuery<
+    T,
+    V = { [key: string]: any, ... }
+  > extends Observable<ApolloQueryResult<T>> {
+    options: WatchQueryOptions;
+    queryId: string;
+    variables: V;
+    isCurrentlyPolling: boolean;
+    shouldSubscribe: boolean;
+    isTornDown: boolean;
+    scheduler: QueryScheduler<any>;
+    queryManager: QueryManager<any>;
+    observers: Observer<ApolloQueryResult<T>>[];
+    subscriptionHandles: SubscriptionLINK[];
+    lastResult: ApolloQueryResult<T>;
+    lastError: ApolloError;
+    lastVariables: V;
+
+    constructor(data: {
+      scheduler: QueryScheduler<any>,
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean,
+      ...
+    }): this;
+    result(): Promise<ApolloQueryResult<T>>;
+    currentResult(): ApolloCurrentResult<T>;
+    getLastResult(): ApolloQueryResult<T>;
+    getLastError(): ApolloError;
+    resetLastResults(): void;
+    refetch(variables?: V): Promise<ApolloQueryResult<T>>;
+    fetchMore(
+      fetchMoreOptions: FetchMoreQueryOptions<any> & FetchMoreOptions<any, any>
+    ): Promise<ApolloQueryResult<T>>;
+    subscribeToMore(options: SubscribeToMoreOptions<any, any>): () => void;
+    setOptions(
+      opts: ModifiableWatchQueryOptions
+    ): Promise<ApolloQueryResult<T>>;
+    setVariables(
+      variables: V,
+      tryFetch?: boolean,
+      fetchResults?: boolean
+    ): Promise<ApolloQueryResult<T>>;
+    updateQuery(
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ): void;
+    stopPolling(): void;
+    startPolling(pollInterval: number): void;
+  }
+
+  declare class QueryManager<TStore> {
+    scheduler: QueryScheduler<TStore>;
+    link: ApolloLink;
+    mutationStore: MutationStore;
+    queryStore: QueryStore;
+    dataStore: DataStore<TStore>;
+
+    constructor({
+      link: ApolloLink,
+      queryDeduplication?: boolean,
+      store: DataStore<TStore>,
+      onBroadcast?: () => mixed,
+      ssrMode?: boolean,
+      ...
+    }): this;
+
+    mutate<T>(options: MutationOptions<>): Promise<FetchResult<T>>;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType?: FetchType,
+      fetchMoreForQueryId?: string
+    ): Promise<FetchResult<T>>;
+    queryListenerForObserver<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      observer: Observer<ApolloQueryResult<T>>
+    ): QueryListener;
+    watchQuery<T>(
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean
+    ): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    generateQueryId(): string;
+    stopQueryInStore(queryId: string): void;
+    addQueryListener(queryId: string, listener: QueryListener): void;
+    updateQueryWatch(
+      queryId: string,
+      document: DocumentNode,
+      options: WatchQueryOptions
+    ): void;
+    addFetchQueryPromise<T>(
+      requestId: number,
+      promise: Promise<ApolloQueryResult<T>>,
+      resolve: (result: ApolloQueryResult<T>) => void,
+      reject: (error: Error) => void
+    ): void;
+    removeFetchQueryPromise(requestId: number): void;
+    addObservableQuery<T>(
+      queryId: string,
+      observableQuery: ObservableQuery<T>
+    ): void;
+    removeObservableQuery(queryId: string): void;
+    clearStore(): Promise<void>;
+    resetStore(): Promise<ApolloQueryResult<any>[]>;
+  }
+
+  declare class QueryStore {
+    getStore(): { [queryId: string]: QueryStoreValue, ... };
+    get(queryId: string): QueryStoreValue;
+    initQuery(query: {
+      queryId: string,
+      document: DocumentNode,
+      storePreviousVariables: boolean,
+      variables: any,
+      isPoll: boolean,
+      isRefetch: boolean,
+      metadata: any,
+      fetchMoreForQueryId: string | void,
+      ...
+    }): void;
+    markQueryResult(
+      queryId: string,
+      result: ExecutionResult<>,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryError(
+      queryId: string,
+      error: Error,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryResultClient(queryId: string, complete: boolean): void;
+    stopQuery(queryId: string): void;
+    reset(observableQueryIds: string[]): void;
+  }
+
+  declare class QueryScheduler<TCacheShape> {
+    inFlightQueries: { [queryId: string]: WatchQueryOptions, ... };
+    registeredQueries: { [queryId: string]: WatchQueryOptions, ... };
+    intervalQueries: { [interval: number]: string[], ... };
+    queryManager: QueryManager<TCacheShape>;
+    constructor({
+      queryManager: QueryManager<TCacheShape>,
+      ssrMode?: boolean,
+      ...
+    }): this;
+    checkInFlight(queryId: string): ?boolean;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType: FetchType
+    ): Promise<FetchResult<T>>;
+    startPollingQuery<T>(
+      options: WatchQueryOptions,
+      queryId: string,
+      listener?: QueryListener
+    ): string;
+    stopPollingQuery(queryId: string): void;
+    fetchQueriesOnInterval<T>(interval: number): void;
+    addQueryOnInterval<T>(
+      queryId: string,
+      queryOptions: WatchQueryOptions
+    ): void;
+    registerPollingQuery<T>(
+      queryOptions: WatchQueryOptions
+    ): ObservableQuery<T>;
+    markMutationError(mutationId: string, error: Error): void;
+    reset(): void;
+  }
+
+  declare class DataStore<TSerialized> {
+    constructor(initialCache: ApolloCache<TSerialized>): this;
+    getCache(): ApolloCache<TSerialized>;
+    markQueryResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      fetchMoreForQueryId: string | void,
+      ignoreErrors?: boolean
+    ): void;
+    markSubscriptionResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any
+    ): void;
+    markMutationInit(mutation: {
+      mutationId: string,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: any) => mixed) | void,
+      optimisticResponse: Dict,
+      ...
+    }): void;
+    markMutationResult(mutation: {
+      mutationId: string,
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: any) => mixed) | void,
+      ...
+    }): void;
+    markMutationComplete({
+      mutationId: string,
+      optimisticResponse?: Dict,
+      ...
+    }): void;
+    markUpdateQueryResult(
+      document: DocumentNode,
+      variables: any,
+      newResult: any
+    ): void;
+    reset(): Promise<void>;
+  }
+
+  declare export type QueryWithUpdater = {
+    updater: MutationQueryReducer<any>,
+    query: QueryStoreValue,
+    ...
+  };
+
+  declare export interface MutationStoreValue {
+    mutationString: string;
+    variables: any;
+    loading: boolean;
+    error: Error | null;
+  }
+
+  declare class MutationStore {
+    getStore(): { [mutationId: string]: MutationStoreValue, ... };
+    get(mutationId: string): MutationStoreValue;
+    initMutation(
+      mutationId: string,
+      mutationString: string,
+      variables: any
+    ): void;
+  }
+
+  declare export interface FetchMoreOptions<TData, TVariables> {
+    updateQuery: (
+      previousQueryResult: TData,
+      options: {
+        fetchMoreResult?: TData,
+        variables: TVariables,
+        ...
+      }
+    ) => TData;
+  }
+
+  declare export interface UpdateQueryOptions {
+    variables?: any;
+  }
+
+  declare export type ApolloCurrentResult<T> = {
+    data: T | { ... },
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    error?: ApolloError,
+    partial?: boolean,
+    ...
+  };
+
+  declare export interface ModifiableWatchQueryOptions {
+    variables?: Dict;
+    pollInterval?: number;
+    fetchPolicy?: FetchPolicy;
+    errorPolicy?: ErrorPolicy;
+    fetchResults?: boolean;
+    notifyOnNetworkStatusChange?: boolean;
+  }
+
+  declare export interface WatchQueryOptions
+    extends ModifiableWatchQueryOptions {
+    query: DocumentNode;
+    metadata?: any;
+    context?: any;
+  }
+
+  declare export type RefetchQueryDescription = $ReadOnlyArray<
+    string | PureQueryOptions
+  >;
+
+  declare export interface MutationBaseOptions<T = Dict> {
+    optimisticResponse?: Dict;
+    updateQueries?: MutationQueryReducersMap<T>;
+    refetchQueries?:
+      | ((result: ExecutionResult<>) => RefetchQueryDescription)
+      | RefetchQueryDescription;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: any;
+  }
+
+  declare export interface MutationOptions<T = Dict>
+    extends MutationBaseOptions<T> {
+    mutation: DocumentNode;
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+  }
+
+  declare export interface SubscriptionOptions {
+    query: DocumentNode;
+    variables?: Dict;
+  }
+
+  declare export type FetchPolicy =
+    | 'cache-first'
+    | 'cache-and-network'
+    | 'network-only'
+    | 'cache-only'
+    | 'no-cache'
+    | 'standby';
+
+  declare export type ErrorPolicy = 'none' | 'ignore' | 'all';
+
+  declare export interface FetchMoreQueryOptions<TVariables> {
+    variables: $Shape<TVariables>;
+  }
+
+  declare export type SubscribeToMoreOptions<
+    TData,
+    TSubscriptionData,
+    TSubscriptionVariables = void
+  > = {
+    document?: DocumentNode,
+    variables?: TSubscriptionVariables,
+    updateQuery?: (
+      previousResult: TData,
+      result: {
+        subscriptionData: { data?: TSubscriptionData, ... },
+        variables: TSubscriptionVariables,
+        ...
+      }
+    ) => TData,
+    onError?: (error: Error) => mixed,
+    ...
+  };
+
+  declare export type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => mixed;
+
+  declare export type NetworkStatus = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare export type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => mixed;
+
+  declare export type QueryStoreValue = {
+    document: DocumentNode,
+    variables: any,
+    previousVariables: any,
+    networkStatus: NetworkStatus,
+    networkError: Error | null,
+    graphQLErrors: GraphQLError[],
+    metadata: any,
+    ...
+  };
+
+  declare export type PureQueryOptions = {
+    query: DocumentNode,
+    variables?: Dict,
+    ...
+  };
+
+  declare export type ApolloQueryResult<T> = {
+    data: T,
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    stale: boolean,
+    ...
+  };
+
+  declare export type FetchType = 1 | 2 | 3;
+
+  declare export type MutationQueryReducer<T> = (
+    previousResult: Dict,
+    options: {
+      mutationResult: FetchResult<T>,
+      queryName: string | void,
+      queryVariables: Dict,
+      ...
+    }
+  ) => Dict;
+
+  declare export type MutationQueryReducersMap<T = Dict> = {
+    [queryName: string]: MutationQueryReducer<T>,
+    ...,
+  };
+
+  declare class $ApolloError extends Error {
+    message: string;
+    graphQLErrors: Array<GraphQLError>;
+    networkError: Error | null;
+    extraInfo: any;
+    constructor(info: ErrorConstructor): this;
+  }
+  declare export type ApolloError = $ApolloError;
+
+  declare export interface ErrorConstructor {
+    graphQLErrors?: Array<GraphQLError>;
+    networkError?: Error | null;
+    errorMessage?: string;
+    extraInfo?: any;
+  }
+
+  declare export interface DefaultOptions {
+    +watchQuery?: ModifiableWatchQueryOptions;
+    +query?: ModifiableWatchQueryOptions;
+    +mutate?: MutationBaseOptions<>;
+  }
+
+  declare export type ApolloClientOptions<TCacheShape> = {
+    link: ApolloLink,
+    cache: ApolloCache<TCacheShape>,
+    ssrMode?: boolean,
+    ssrForceFetchDelay?: number,
+    connectToDevTools?: boolean,
+    queryDeduplication?: boolean,
+    defaultOptions?: DefaultOptions,
+    ...
+  };
+
+  declare export class ApolloClient<TCacheShape> {
+    link: ApolloLink;
+    store: DataStore<TCacheShape>;
+    cache: ApolloCache<TCacheShape>;
+    queryManager: QueryManager<TCacheShape>;
+    disableNetworkFetches: boolean;
+    version: string;
+    queryDeduplication: boolean;
+    defaultOptions: DefaultOptions;
+    devToolsHookCb: any;
+    proxy: ApolloCache<TCacheShape> | void;
+    ssrMode: boolean;
+    resetStoreCallbacks: Array<() => Promise<any>>;
+
+    constructor(options: ApolloClientOptions<TCacheShape>): this;
+    watchQuery<T>(options: WatchQueryOptions): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    mutate<T>(options: MutationOptions<T>): Promise<FetchResult<T>>;
+    subscribe(options: SubscriptionOptions): Observable<any>;
+    readQuery<T>(options: DataProxyReadQueryOptions): T | null;
+    readFragment<T>(options: DataProxyReadFragmentOptions): T | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+    __actionHookForDevTools(cb: () => mixed): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    clearStore(): Promise<void | null>;
+    resetStore(): Promise<Array<ApolloQueryResult<any>> | null>;
+    onResetStore(cb: () => Promise<any>): () => void;
+    reFetchObservableQueries(
+      includeStandby?: boolean
+    ): Promise<ApolloQueryResult<any>[]> | Promise<null>;
+    extract(optimistic?: boolean): TCacheShape;
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+  }
+
+  /* apollo-link types */
+  declare class ApolloLink {
+    constructor(request?: RequestHandler): this;
+
+    static empty(): ApolloLink;
+    static from(links: Array<ApolloLink>): ApolloLink;
+    static split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+    static execute(
+      link: ApolloLink,
+      operation: GraphQLRequest
+    ): Observable<FetchResult<>>;
+
+    split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+
+    request(
+      operation: Operation,
+      forward?: NextLink
+    ): Observable<FetchResult<>> | null;
+  }
+
+  declare export interface GraphQLRequest {
+    query: DocumentNode;
+    variables?: Dict;
+    operationName?: string;
+    context?: Dict;
+    extensions?: Dict;
+  }
+
+  declare export interface Operation {
+    query: DocumentNode;
+    variables: Dict;
+    operationName: string;
+    extensions: Dict;
+    setContext: (context: Dict) => Dict;
+    getContext: () => Dict;
+    toKey: () => string;
+  }
+
+  declare export type FetchResult<C = Dict, E = Dict> = ExecutionResult<C> & {
+    extension?: E,
+    context?: C,
+    ...
+  };
+
+  declare export type NextLink = (
+    operation: Operation
+  ) => Observable<FetchResult<>>;
+
+  declare export type RequestHandler = (
+    operation: Operation,
+    forward?: NextLink
+  ) => Observable<FetchResult<>> | null;
+
+  declare class Observable<T> {
+    subscribe(
+      observerOrNext: ((value: T) => mixed) | ZenObservableObserver<T>,
+      error?: (error: any) => mixed,
+      complete?: () => mixed
+    ): ZenObservableSubscription;
+
+    forEach(fn: (value: T) => mixed): Promise<void>;
+
+    map<R>(fn: (value: T) => R): Observable<R>;
+
+    filter(fn: (value: T) => boolean): Observable<T>;
+
+    reduce<R>(
+      fn: (previousValue: R | T, currentValue: T) => R | T,
+      initialValue?: R | T
+    ): Observable<R | T>;
+
+    flatMap<R>(fn: (value: T) => ZenObservableObservableLike<R>): Observable<R>;
+
+    from<R>(
+      observable: Observable<R> | ZenObservableObservableLike<R> | Array<R>
+    ): Observable<R>;
+
+    of<R>(...args: Array<R>): Observable<R>;
+  }
+
+  declare export interface Observer<T> {
+    start?: (subscription: SubscriptionLINK) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare export interface SubscriptionLINK {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare export interface ZenObservableSubscriptionObserver<T> {
+    closed: boolean;
+    next(value: T): void;
+    error(errorValue: any): void;
+    complete(): void;
+  }
+
+  declare export interface ZenObservableSubscription {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare export interface ZenObservableObserver<T> {
+    start?: (subscription: ZenObservableSubscription) => mixed;
+    next?: (value: T) => mixed;
+    error?: (errorValue: any) => mixed;
+    complete?: () => mixed;
+  }
+
+  declare export type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => mixed | (() => mixed) | SubscriptionLINK;
+
+  declare export interface ZenObservableObservableLike<T> {
+    subscribe?: ZenObservableSubscriber<T>;
+  }
+  /* apollo-link types */
+
+  /* apollo-cache types */
+  declare class ApolloCache<TSerialized> {
+    read<T>(query: CacheReadOptions): T | null;
+    write(write: CacheWriteOptions): void;
+    diff<T>(query: CacheDiffOptions): CacheDiffResult<T>;
+    watch(watch: CacheWatchOptions): () => void;
+    evict(query: CacheEvictOptions): CacheEvictionResult;
+    reset(): Promise<void>;
+
+    restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    extract(optimistic?: boolean): TSerialized;
+
+    removeOptimistic(id: string): void;
+
+    performTransaction(transaction: Transaction<TSerialized>): void;
+    recordOptimisticTransaction(
+      transaction: Transaction<TSerialized>,
+      id: string
+    ): void;
+
+    transformDocument(document: DocumentNode): DocumentNode;
+    transformForLink(document: DocumentNode): DocumentNode;
+
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: CacheWriteQueryOptions): void;
+    writeFragment(options: CacheWriteFragmentOptions): void;
+    writeData(options: CacheWriteDataOptions): void;
+  }
+
+  declare export type Transaction<T> = (c: ApolloCache<T>) => mixed;
+
+  declare export type CacheWatchCallback = (newData: any) => mixed;
+
+  declare export interface CacheEvictionResult {
+    success: boolean;
+  }
+
+  declare export interface CacheReadOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+    previousResult?: any;
+    optimistic: boolean;
+  }
+
+  declare export interface CacheWriteOptions extends DataProxyReadQueryOptions {
+    dataId: string;
+    result: any;
+  }
+
+  declare export interface CacheDiffOptions extends CacheReadOptions {
+    returnPartialData?: boolean;
+  }
+
+  declare export interface CacheWatchOptions extends CacheReadOptions {
+    callback: CacheWatchCallback;
+  }
+
+  declare export interface CacheEvictOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+  }
+
+  declare export type CacheDiffResult<T> = DataProxyDiffResult<T>;
+  declare export type CacheWriteQueryOptions = DataProxyWriteQueryOptions;
+  declare export type CacheWriteFragmentOptions = DataProxyWriteFragmentOptions;
+  declare export type CacheWriteDataOptions = DataProxyWriteDataOptions;
+
+  declare export interface DataProxyReadQueryOptions {
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare export interface DataProxyReadFragmentOptions {
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare export interface DataProxyWriteQueryOptions {
+    data: any;
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare export interface DataProxyWriteFragmentOptions {
+    data: any;
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare export interface DataProxyWriteDataOptions {
+    data: any;
+    id?: string;
+  }
+
+  declare export type DataProxyDiffResult<T> = {
+    result?: T,
+    complete?: boolean,
+    ...
+  };
+
+  declare export interface DataProxy {
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+  }
+  /* End apollo-cache types */
+
+  /** End from Apollo Client */
+
+  /**
+   * Types From graphql
+   * graphql types are maintained in the graphql-js repo
+   */
+  declare export type DocumentNode = any;
+  declare export type ExecutionResult<T> = {
+    data?: T,
+    extensions?: { [string]: any, ... },
+    errors?: any[],
+    ...
+  };
+  declare export type GraphQLError = any;
+  declare export type VariableDefinitionNode = any;
+  /** End From graphql */
+
+  declare export interface ApolloProviderProps<TCache> {
+    client: any; // ApolloClient<TCache>;
+    children: Node;
+  }
+
+  declare export interface ApolloConsumerProps {
+    children: (client: ApolloClient<any>) => Node;
+  }
+
+  declare export class ApolloConsumer extends React$Component<ApolloConsumerProps> {}
+
+  declare export class ApolloProvider<TCache> extends React$Component<
+    ApolloProviderProps<TCache>
+  > {
+    childContextTypes: {
+      client: ApolloClient<TCache>,
+      operations: Map<
+        string,
+        {
+          query: DocumentNode,
+          variables: any,
+          ...
+        }
+      >,
+      ...
+    };
+
+    getChildContext(): {
+      client: ApolloClient<TCache>,
+      operations: Map<
+        string,
+        {
+          query: DocumentNode,
+          variables: any,
+          ...
+        }
+      >,
+      ...
+    };
+  }
+
+  declare export type MutationFunc<TResult, TVariables> = (
+    opts: MutationOpts<TVariables>
+  ) => Promise<ApolloQueryResult<TResult>>;
+
+  declare export type GraphqlData<TResult, TVariables> = TResult &
+    GraphqlQueryControls<TVariables> & {
+      variables: TVariables,
+      refetch: (variables?: TVariables) => Promise<ApolloQueryResult<any>>,
+      ...
+    };
+
+  declare export type ChildProps<TOwnProps, TResult, TVariables> = {
+    data: GraphqlData<TResult, TVariables>,
+    mutate: MutationFunc<TResult, TVariables>,
+    ...
+  } & TOwnProps;
+
+  declare export type RefetchQueriesProviderFn = (
+    ...args: any[]
+  ) => RefetchQueryDescription;
+
+  declare export type MutationOpts<TVariables> = {|
+    variables?: TVariables,
+    optimisticResponse?: Dict,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    update?: MutationUpdaterFn<any>,
+    errorPolicy?: ErrorPolicy,
+  |};
+
+  declare export type QueryOpts<TVariables> = {|
+    ssr?: boolean,
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    pollInterval?: number,
+    skip?: boolean,
+    errorPolicy?: ErrorPolicy,
+    context?: Dict,
+  |};
+
+  declare export interface GraphqlQueryControls<
+    TGraphQLVariables = OperationVariables
+  > {
+    error?: ApolloError | any; // Added optional `any` to satisfy Flow < 0.62
+    networkStatus: NetworkStatus;
+    loading: boolean;
+    variables: TGraphQLVariables;
+    fetchMore: (
+      fetchMoreOptions: FetchMoreQueryOptions<TGraphQLVariables> &
+        FetchMoreOptions<any, TGraphQLVariables>
+    ) => Promise<ApolloQueryResult<any>>;
+    refetch: (variables?: TGraphQLVariables) => Promise<ApolloQueryResult<any>>;
+    startPolling: (pollInterval: number) => void;
+    stopPolling: () => void;
+    subscribeToMore: (options: SubscribeToMoreOptions<any, any>) => () => void;
+    updateQuery: (
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ) => void;
+  }
+
+  declare export interface OptionProps<TProps, TResult, TVariables> {
+    ownProps: TProps;
+    data?: GraphqlData<TResult, TVariables>;
+    mutate: MutationFunc<TResult, TVariables>;
+  }
+
+  declare export type OptionDescription<TProps, TVariables> =
+    | QueryOpts<TVariables>
+    | MutationOpts<TVariables>
+    | ((props: TProps) => QueryOpts<TVariables> | MutationOpts<TVariables>);
+
+  declare export type NamedProps<P, R> = P & { ownProps: R, ... };
+
+  declare export interface OperationOption<
+    TResult: { ... },
+    TProps: { ... },
+    TChildProps: { ... },
+    TVariables: { ... }
+  > {
+    +options?: OptionDescription<TProps, TVariables>;
+    props?: (
+      props: OptionProps<TProps, TResult, TVariables>
+    ) => TChildProps | ChildProps<TProps, TResult, TVariables>;
+    +skip?: boolean | ((props: any) => boolean);
+    name?: string;
+    withRef?: boolean;
+    shouldResubscribe?: (props: TProps, nextProps: TProps) => boolean;
+    alias?: string;
+  }
+
+  declare export interface OperationComponent<
+    TResult: { ... },
+    TOwnProps: { ... },
+    TVariables: { ... },
+    TMergedProps: ChildProps<TOwnProps, TResult, TVariables>
+  > {
+    (component: ComponentType<TMergedProps>): ComponentType<TOwnProps>;
+  }
+
+  declare export interface IDocumentDefinition {
+    type: DocumentType;
+    name: string;
+    variables: VariableDefinitionNode[];
+  }
+
+  declare export interface Context {
+    [key: string]: any;
+  }
+
+  declare export interface QueryResult {
+    query: Promise<ApolloQueryResult<mixed>>;
+    element: Element<any>;
+    context: Context;
+  }
+
+  declare export type QueryRenderProps<
+    TData = any,
+    TVariables = OperationVariables
+  > = {
+    data: MakeDataOptional<TData>,
+    loading: boolean,
+    error?: ApolloError,
+    variables: TVariables,
+    networkStatus: NetworkStatus,
+    refetch: (variables?: TVariables) => Promise<ApolloQueryResult<TData>>,
+    fetchMore: ((
+      options: FetchMoreOptions<TData, TVariables> &
+        FetchMoreQueryOptions<TVariables>
+    ) => Promise<ApolloQueryResult<TData>>) &
+      (<TData2, TVariables2>(
+        options: {
+          query: DocumentNode,
+          ...
+        } & FetchMoreQueryOptions<TVariables2> &
+          FetchMoreOptions<TData2, TVariables2>
+      ) => Promise<ApolloQueryResult<TData2>>),
+    load: () => void,
+    startPolling: (interval: number) => void,
+    stopPolling: () => void,
+    subscribeToMore: (
+      options: SubscribeToMoreOptions<TData, any, any>
+    ) => () => void,
+    updateQuery: (
+      mapFn: (
+        previousResult: TData,
+        options: { variables: TVariables, ... }
+      ) => TData
+    ) => mixed,
+    client: ApolloClient<any>,
+    ...
+  };
+
+  declare export type QueryRenderPropFunction<TData, TVariables> = (
+    QueryRenderProps<TData, TVariables>
+  ) => Node;
+
+  declare export class Query<TData, TVariables> extends React$Component<{
+    query: DocumentNode,
+    children: QueryRenderPropFunction<TData, TVariables>,
+    variables?: TVariables,
+    pollInterval?: number,
+    notifyOnNetworkStatusChange?: boolean,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    ssr?: boolean,
+    displayName?: string,
+    delay?: boolean,
+    context?: { [string]: any, ... },
+    ...
+  }> {}
+
+  declare export type SubscriptionResult<
+    TData,
+    TVariables = OperationVariables
+  > = {
+    loading: boolean,
+    data?: MakeDataOptional<TData>,
+    error?: ApolloError,
+    ...
+  };
+
+  declare export type SubscriptionRenderPropFunction<TData, TVariables> = (
+    result: SubscriptionResult<TData, TVariables>
+  ) => Node;
+
+  declare export type OnSubscriptionDataOptions<TData> = {
+    client: ApolloClient<any>,
+    subscriptionData: SubscriptionResult<TData>,
+    ...
+  };
+
+  declare export type SubscriptionProps<
+    TData,
+    TVariables = OperationVariables
+  > = {
+    subscription: DocumentNode,
+    variables?: TVariables,
+    shouldResubscribe?:
+      | boolean
+      | ((
+          SubscriptionProps<TData, TVariables>,
+          SubscriptionProps<TData, TVariables>
+        ) => boolean),
+    onSubscriptionData?: (OnSubscriptionDataOptions<TData>) => any,
+    children?: SubscriptionRenderPropFunction<TData, TVariables>,
+    ...
+  };
+
+  declare export class Subscription<TData, TVariables> extends React$Component<
+    SubscriptionProps<TData, TVariables>
+  > {}
+
+  declare export type OperationVariables = Dict;
+
+  declare export type MutationFunction<
+    TData = any,
+    TVariables = OperationVariables
+  > = (options?: {
+    variables?: TVariables,
+    optimisticResponse?: Dict,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    update?: MutationUpdaterFn<TData>,
+    ...
+  }) => Promise<void | FetchResult<TData>>;
+
+  declare export type MutationResult<TData = { [string]: any, ... }> = {
+    loading: boolean,
+    error?: ApolloError,
+    data?: TData,
+    called: boolean,
+    client: ApolloClient<any>,
+    ...
+  };
+
+  declare export type MutationRenderPropFunction<TData, TVariables> = (
+    mutate: MutationFunction<TData, TVariables>,
+    result: MutationResult<TData>
+  ) => Node;
+
+  declare export class Mutation<
+    TData,
+    TVariables = void
+  > extends React$Component<{
+    mutation: DocumentNode,
+    children: MutationRenderPropFunction<TData, TVariables>,
+    variables?: TVariables,
+    update?: MutationUpdaterFn<TData>,
+    ignoreResults?: boolean,
+    optimisticResponse?: Dict,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    onCompleted?: (data: TData) => mixed,
+    onError?: (error: ApolloError) => mixed,
+    context?: { [string]: any, ... },
+    ...
+  }> {}
+}
diff --git a/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/test_react-components_v3.x.x.js b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/test_react-components_v3.x.x.js
new file mode 100644
index 0000000000..6d05627b21
--- /dev/null
+++ b/definitions/npm/@apollo/react-components_v3.x.x/flow_v0.201.x-/test_react-components_v3.x.x.js
@@ -0,0 +1,682 @@
+// @flow
+import * as React from 'react';
+import { it, describe } from 'flow-typed-test';
+import {
+  ApolloProvider,
+  ApolloConsumer,
+  Query,
+  Mutation,
+  Subscription,
+  type ApolloClient,
+  type MutationFunction,
+  type MutationResult,
+  type QueryRenderProps,
+  type PureQueryOptions,
+  type SubscriptionResult,
+  type RefetchQueryDescription,
+} from '@apollo/react-components';
+
+const gql = (strings, ...args) => {}; // graphql-tag stub
+
+const query = gql`
+  {
+    foo
+  }
+`;
+const mutation = gql`
+  mutation {
+    foo
+  }
+`;
+
+type Hero = {
+  name: string,
+  id: string,
+  appearsIn: string[],
+  friends: Hero[],
+  ...
+};
+
+type IQuery = {
+  foo: string,
+  bar: string,
+  ...
+};
+
+const HERO_QUERY = gql`
+  query GetCharacter($episode: String!, $offset: Int) {
+    hero(episode: $episode, offset: $offset) {
+      name
+      id
+      friends {
+        name
+        id
+        appearsIn
+      }
+    }
+  }
+`;
+
+const OTHER_QUERY = gql`
+  query GetOther($other: String!) {
+    other(other: $other) {
+      name
+    }
+  }
+`;
+
+const HERO_MUTATION = gql`
+  mutation UpdateHero($input: HeroInput!) {
+    updateHero(input: $input) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+const HERO_SUBSCRIPTION = gql`
+  mutation onHeroUpdate($heroId: ID!) {
+    heroUpdated(heroId: $heroId) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+type HeroQueryVariables = {
+  episode: string,
+  offset?: ?number,
+  ...
+};
+class HeroQueryComp extends Query<
+  { hero: ?Hero, ... },
+  { episode: string, offset?: ?number, ... }
+> {}
+
+describe('<Query />', () => {
+  it('works', () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: 'bar' };
+    const q = (
+      <Query variables={vars} query={HERO_QUERY}>
+        {({ data }: QueryRenderProps<Res, Vars>) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          // $FlowExpectedError Cannot get `data.res` because property `res` is missing in object type
+          const s: string = data.res;
+          if (data.res) {
+            const _s: string = data.res;
+          }
+          return <div />;
+        }}
+      </Query>
+    );
+  });
+
+  it('works when extending Query with types', () => {
+    <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+      {({ data, loading, error }) => {
+        if (loading) return 'Loading....';
+        if (error) return 'Error!';
+        // $FlowExpectedError Cannot get `data.hero`. data may be undefined
+        data.hero;
+        if (!data || !data.hero) {
+          return <div />;
+        }
+        const hero = data.hero;
+
+        const nameAgain: string = hero.name;
+        // $FlowExpectedError unknown is not a property on Hero
+        const unknown = hero.unknown;
+
+        return <div>{nameAgain}</div>;
+      }}
+    </HeroQueryComp>;
+  });
+
+  it('raises an error if accessing a prop in children function that doesnt exist', () => {
+    <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+      {// $FlowExpectedError cannot render HeroQueryComp becuase errors is missing in children function (should be error instead of errors)
+      ({ data, loading, errors }) => {
+        if (loading) return 'Loading....';
+        if (errors) return 'Error!';
+        return String(data);
+      }}
+    </HeroQueryComp>;
+  });
+
+  describe('refetch', () => {
+    it('works if passed variablees that match the query', () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+        {({ data, refetch }) => {
+          const onClick = () => {
+            refetch();
+            refetch({ episode: 'otherEpisode' });
+            // $FlowExpectedError refetch variables do not match variables for query
+            refetch({ notEpisode: 'otherEpisode' });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+
+  describe('fetchMore', () => {
+    it('works when passed valid options', () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+        {({ data, fetchMore }) => {
+          const onClick = () => {
+            fetchMore({
+              variables: { episode: 'episode2' },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero,
+                };
+              },
+            });
+
+            const variables: $Shape<HeroQueryVariables> = { offset: 1 };
+            fetchMore({
+              variables: variables,
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero,
+                };
+              },
+            });
+
+            const otherVariables = { other: '1234' };
+            fetchMore({
+              query: OTHER_QUERY,
+              variables: otherVariables,
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  other: options.fetchMoreResult.other,
+                };
+              },
+            });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+
+    it('raises an error when passed invalid options', () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+        {({ data, fetchMore }) => {
+          const onClick = () => {
+            // $FlowExpectedError variables must match $Shape of query variables
+            fetchMore({
+              variables: { other: 'hello' },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero,
+                };
+              },
+            });
+
+            // $FlowExpectedError must pass query option if passing different variables than query
+            fetchMore({
+              variables: { other: '1234' },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  other: options.fetchMoreResult.other,
+                };
+              },
+            });
+
+            fetchMore({
+              variables: { episode: 'episode2' },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                // $FlowExpectedError updateQuery return type must match query response type
+                return {
+                  other: options.fetchMoreResult.hero,
+                };
+              },
+            });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+
+  describe('updateQuery', () => {
+    it('works', () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: 'episode' }}>
+        {({ updateQuery }) => {
+          // $FlowExpectedError updateQuery return type must match previous result type
+          updateQuery((previousResult, options) => ({ hello: 'flow' }));
+          const renameHero = (newName: string) =>
+            updateQuery((previousResult, options) => {
+              // $FlowExpectedError Cannot get `options.unknownProperty` because property `unknownProperty` is missing in options
+              const a = options.unknownProperty;
+              const { variables } = options;
+              return { ...previousResult, name: newName };
+            });
+          return <div />;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+});
+
+type HeroSubcriptionVariables = {
+  heroId: string,
+  ...
+};
+class HeroSubscriptionComp extends Subscription<
+  { hero: ?Hero, ... },
+  HeroSubcriptionVariables
+> {}
+
+describe('<Subscription />', () => {
+  it('works', () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: '1' };
+    const q = (
+      <Subscription variables={vars} subscription={HERO_SUBSCRIPTION}>
+        {({ data }: SubscriptionResult<Res, Vars>) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          // $FlowExpectedError Cannot get `data.res` because property `res` is missing in object type
+          const s: string = data.res;
+          const _s: ?string = data.res;
+          return <div />;
+        }}
+      </Subscription>
+    );
+  });
+  it('works when extending Subscription with types', () => {
+    <HeroSubscriptionComp
+      subscription={HERO_SUBSCRIPTION}
+      variables={{ heroId: '123' }}
+    >
+      {({ data, loading, error }) => {
+        if (loading) return 'Loading....';
+        if (error) return 'Error!';
+        // $FlowExpectedError Cannot get `data.hero`. data may be undefined
+        data.hero;
+        if (!data || !data.hero) {
+          return <div />;
+        }
+        const hero = data.hero;
+
+        const nameAgain: string = hero.name;
+        // $FlowExpectedError unknown is not a property on Hero
+        const unknown = hero.unknown;
+
+        return <div>{nameAgain}</div>;
+      }}
+    </HeroSubscriptionComp>;
+  });
+  it('errors if wrong variables passed', () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const q = (
+      // $FlowExpectedError variables must match shape of query variables
+      <Subscription variables={{ foo: 1 }} subscription={HERO_SUBSCRIPTION}>
+        {// $FlowExpectedError variables must match shape of query variables
+        ({ data }: SubscriptionResult<Res, Vars>) => {}}
+      </Subscription>
+    );
+  });
+  it('supports onSubscriptionData prop', function() {
+    const q = (
+      <Subscription
+        subscription={HERO_SUBSCRIPTION}
+        onSubscriptionData={({
+          client,
+          subscriptionData,
+        }: {
+          client: ApolloClient<any>,
+          subscriptionData: SubscriptionResult<{ hero: ?Hero, ... }>,
+          ...
+        }) => {
+          const hero: ?Hero =
+            subscriptionData.data && subscriptionData.data.hero
+              ? subscriptionData.data.hero
+              : null;
+        }}
+      />
+    );
+  });
+});
+
+type UpdateHeroMutationVariables = {
+  input: { id: string, name: string, ... },
+  ...
+};
+class UpdateHeroMutationComp extends Mutation<
+  { updateHero?: ?{ hero: ?Hero, ... }, ... },
+  UpdateHeroMutationVariables
+> {}
+
+describe('<Mutation />', () => {
+  it('mutate() args are optional', () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: 'bar' };
+    const q = (
+      <Mutation variables={vars} mutation={HERO_QUERY}>
+        {mutate => {
+          mutate();
+          return <div />;
+        }}
+      </Mutation>
+    );
+  });
+
+  it('works', () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: 'bar' };
+    const q = (
+      <Mutation variables={vars} mutation={HERO_QUERY}>
+        {(
+          update: MutationFunction<Res, Vars>,
+          { data, client }: MutationResult<Res>
+        ) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          const d1: Res = data;
+          const s: string = data.res;
+          client;
+          return <div />;
+        }}
+      </Mutation>
+    );
+  });
+
+  it('works when extending Mutation with types', () => {
+    <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+      {(updateHero, { loading, error, data, called }) => {
+        const onClick = () => {
+          updateHero({
+            variables: { input: { id: '1', name: 'hero1' } },
+          });
+          // $FlowExpectedError variables must match Mutation variables
+          updateHero({
+            variables: { id: '1', name: 'hero1' },
+          });
+        };
+        return (
+          <div>
+            <button disabled={loading} onClick={onClick}>
+              Click
+            </button>
+            {error && error.message}
+          </div>
+        );
+      }}
+    </UpdateHeroMutationComp>;
+  });
+
+  describe('optimisticResponse', () => {
+    it('works when passed an optimisticResponse object', () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const optimisticResponse = {
+            updateHero: {
+              __typename: 'UpdateHeroPayload',
+              hero: {
+                __typename: 'Hero',
+                name: 'Hero1',
+                id: '1',
+              },
+            },
+          };
+          const onClick = () => {
+            updateHero({
+              optimisticResponse,
+              variables: { input: { id: '1', name: 'hero1' } },
+            });
+
+            // $FlowExpectedError optimisticResponse must be an object
+            updateHero({
+              optimisticResponse: 'optimisticResponse',
+              variables: { input: { id: '1', name: 'hero1' } },
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+
+  describe('refetchQueries', () => {
+    it('works when passed refetchQueries to Mutation component', () => {
+      const queryOption = {
+        query: HERO_QUERY,
+        variables: { episode: 'episode' },
+      };
+      const refetchQueries: RefetchQueryDescription = [queryOption, 'foo'];
+
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        refetchQueries={refetchQueries}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+
+      // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        refetchQueries={queryOption}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+
+    it('works when passed refetchQueries to mutation function', () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const onClick = () => {
+            const queryOption = {
+              query: HERO_QUERY,
+              variables: { episode: 'episode' },
+            };
+            const refetchQueries: PureQueryOptions[] = [queryOption];
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+              refetchQueries,
+            });
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+              refetchQueries: () => refetchQueries,
+            });
+
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+              // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+              refetchQueries: () => queryOption,
+            });
+            // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+              refetchQueries: queryOption,
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+
+  describe('update', () => {
+    it('can manually update the cache after a mutation by passing update prop to the Mutation component', () => {
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        update={(cache, { data }) => {
+          // $FlowExpectedError data may be undefined
+          data.updateHero;
+          if (data && data.updateHero) {
+            const hero = cache.readQuery({
+              query: HERO_QUERY,
+              variables: { episoe: 'episode' },
+            });
+            cache.writeQuery({
+              query: HERO_QUERY,
+              variables: { episode: 'episode' },
+              data: { hero: data.updateHero },
+            });
+          }
+        }}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+
+    it('can manually update the cache after a mutation using update on the mutation function', () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: '1', name: 'hero1' } },
+              update: (cache, { data }) => {
+                // $FlowExpectedError data may be undefined
+                data.updateHero;
+
+                if (data && data.updateHero) {
+                  const hero = cache.readQuery({
+                    query: HERO_QUERY,
+                    variables: { episoe: 'episode' },
+                  });
+                  cache.writeQuery({
+                    query: HERO_QUERY,
+                    variables: { episode: 'episode' },
+                    data: { hero: data.updateHero },
+                  });
+                  if (data.updateHero && data.updateHero.hero) {
+                    cache.writeFragment({
+                      id: '1',
+                      fragment: gql`
+                        fragment myHero on Hero {
+                          name
+                        }
+                      `,
+                      data: {
+                        name: data.updateHero.hero.name,
+                      },
+                    });
+                  }
+
+                  // $FlowExpectedError readQuery requires query
+                  cache.readQuery({
+                    variables: { episode: 'episode' },
+                  });
+                  // $FlowExpectedError writeQuery requires data
+                  cache.writeQuery({
+                    query: HERO_QUERY,
+                    variables: { episode: 'episode' },
+                  });
+                  // $FlowExpectedError writeFragment requires id
+                  cache.writeFragment({
+                    fragment: gql`
+                      fragment myHero on Hero {
+                        name
+                      }
+                    `,
+                    data: {
+                      name: 'name',
+                    },
+                  });
+                  // $FlowExpectedError cannot call unknownFunction on cache
+                  cache.unknwonFunction();
+                }
+              },
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+});
+
+describe('<ApolloProvider />', () => {
+  it('works when passed client', () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+    <ApolloProvider client={client}>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed a client', () => {
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed children', () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider client={client} />;
+  });
+});
+
+describe('<ApolloConsumer />', () => {
+  it('passes ApolloClient to the consumer children', () => {
+    <ApolloConsumer>
+      {client => {
+        const onClick = () => {
+          client.resetStore();
+          client.query({ query: HERO_QUERY });
+          client.readQuery({
+            query: HERO_QUERY,
+            variables: { episode: 'episode' },
+          });
+          // $FlowExpectedError doSomethingElse is not a method of ApolloClient
+          client.doSomethingElse();
+        };
+        return <button onClick={onClick}>Click</button>;
+      }}
+    </ApolloConsumer>;
+  });
+});
diff --git a/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-/react-hoc_v3.x.x.js b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-v.200.x/react-hoc_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-/react-hoc_v3.x.x.js
rename to definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-v.200.x/react-hoc_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-/test_react-hoc_v3.x.x.js b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-v.200.x/test_react-hoc_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-/test_react-hoc_v3.x.x.js
rename to definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.104.x-v.200.x/test_react-hoc_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/react-hoc_v3.x.x.js b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/react-hoc_v3.x.x.js
new file mode 100644
index 0000000000..a3eefa25dc
--- /dev/null
+++ b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/react-hoc_v3.x.x.js
@@ -0,0 +1,935 @@
+declare module '@apollo/react-hoc' {
+  import type { ComponentType, Element, Node } from 'react';
+
+  declare type Dict = { [key: string]: any, ...};
+
+
+  declare type MakeOptional = <V>(V) => ?V;
+  declare type MakeDataOptional<TData> = $ObjMap<TData, MakeOptional> | void;
+  /**
+   * Copied types from Apollo Client libdef
+   * Please update apollo-client libdef as well if updating these types
+   */
+  declare class ObservableQuery<T, V = { [key: string]: any, ... }> extends Observable<ApolloQueryResult<T>> {
+    options: WatchQueryOptions;
+    queryId: string;
+    variables: V;
+    isCurrentlyPolling: boolean;
+    shouldSubscribe: boolean;
+    isTornDown: boolean;
+    scheduler: QueryScheduler<any>;
+    queryManager: QueryManager<any>;
+    observers: Observer<ApolloQueryResult<T>>[];
+    subscriptionHandles: SubscriptionLINK[];
+    lastResult: ApolloQueryResult<T>;
+    lastError: ApolloError;
+    lastVariables: V;
+
+    constructor(data: {
+      scheduler: QueryScheduler<any>,
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean,
+      ...
+    }): this;
+    result(): Promise<ApolloQueryResult<T>>;
+    currentResult(): ApolloCurrentResult<T>;
+    getLastResult(): ApolloQueryResult<T>;
+    getLastError(): ApolloError;
+    resetLastResults(): void;
+    refetch(variables?: V): Promise<ApolloQueryResult<T>>;
+    fetchMore(
+      fetchMoreOptions: FetchMoreQueryOptions<any> & FetchMoreOptions<any, any>
+    ): Promise<ApolloQueryResult<T>>;
+    subscribeToMore(options: SubscribeToMoreOptions<any, any>): () => void;
+    setOptions(
+      opts: ModifiableWatchQueryOptions
+    ): Promise<ApolloQueryResult<T>>;
+    setVariables(
+      variables: V,
+      tryFetch?: boolean,
+      fetchResults?: boolean
+    ): Promise<ApolloQueryResult<T>>;
+    updateQuery(
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ): void;
+    stopPolling(): void;
+    startPolling(pollInterval: number): void;
+  }
+
+  declare class QueryManager<TStore> {
+    scheduler: QueryScheduler<TStore>;
+    link: ApolloLink;
+    mutationStore: MutationStore;
+    queryStore: QueryStore;
+    dataStore: DataStore<TStore>;
+
+    constructor({
+      link: ApolloLink,
+      queryDeduplication?: boolean,
+      store: DataStore<TStore>,
+      onBroadcast?: () => mixed,
+      ssrMode?: boolean,
+      ...
+    }): this;
+
+    mutate<T>(options: MutationOptions<>): Promise<FetchResult<T>>;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType?: FetchType,
+      fetchMoreForQueryId?: string
+    ): Promise<FetchResult<T>>;
+    queryListenerForObserver<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      observer: Observer<ApolloQueryResult<T>>
+    ): QueryListener;
+    watchQuery<T>(
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean
+    ): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    generateQueryId(): string;
+    stopQueryInStore(queryId: string): void;
+    addQueryListener(queryId: string, listener: QueryListener): void;
+    updateQueryWatch(
+      queryId: string,
+      document: DocumentNode,
+      options: WatchQueryOptions
+    ): void;
+    addFetchQueryPromise<T>(
+      requestId: number,
+      promise: Promise<ApolloQueryResult<T>>,
+      resolve: (result: ApolloQueryResult<T>) => void,
+      reject: (error: Error) => void
+    ): void;
+    removeFetchQueryPromise(requestId: number): void;
+    addObservableQuery<T>(
+      queryId: string,
+      observableQuery: ObservableQuery<T>
+    ): void;
+    removeObservableQuery(queryId: string): void;
+    clearStore(): Promise<void>;
+    resetStore(): Promise<ApolloQueryResult<any>[]>;
+  }
+
+  declare class QueryStore {
+    getStore(): { [queryId: string]: QueryStoreValue, ... };
+    get(queryId: string): QueryStoreValue;
+    initQuery(query: {
+      queryId: string,
+      document: DocumentNode,
+      storePreviousVariables: boolean,
+      variables: Dict,
+      isPoll: boolean,
+      isRefetch: boolean,
+      metadata: any,
+      fetchMoreForQueryId: string | void,
+      ...
+    }): void;
+    markQueryResult(
+      queryId: string,
+      result: ExecutionResult<>,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryError(
+      queryId: string,
+      error: Error,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryResultClient(queryId: string, complete: boolean): void;
+    stopQuery(queryId: string): void;
+    reset(observableQueryIds: string[]): void;
+  }
+
+  declare class QueryScheduler<TCacheShape> {
+    inFlightQueries: { [queryId: string]: WatchQueryOptions, ... };
+    registeredQueries: { [queryId: string]: WatchQueryOptions, ... };
+    intervalQueries: { [interval: number]: string[], ... };
+    queryManager: QueryManager<TCacheShape>;
+    constructor({
+      queryManager: QueryManager<TCacheShape>,
+      ssrMode?: boolean,
+      ...
+    }): this;
+    checkInFlight(queryId: string): ?boolean;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType: FetchType
+    ): Promise<FetchResult<T>>;
+    startPollingQuery<T>(
+      options: WatchQueryOptions,
+      queryId: string,
+      listener?: QueryListener
+    ): string;
+    stopPollingQuery(queryId: string): void;
+    fetchQueriesOnInterval<T>(interval: number): void;
+    addQueryOnInterval<T>(
+      queryId: string,
+      queryOptions: WatchQueryOptions
+    ): void;
+    registerPollingQuery<T>(
+      queryOptions: WatchQueryOptions
+    ): ObservableQuery<T>;
+    markMutationError(mutationId: string, error: Error): void;
+    reset(): void;
+  }
+
+  declare class DataStore<TSerialized> {
+    constructor(initialCache: ApolloCache<TSerialized>): this;
+    getCache(): ApolloCache<TSerialized>;
+    markQueryResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      fetchMoreForQueryId: string | void,
+      ignoreErrors?: boolean
+    ): void;
+    markSubscriptionResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any
+    ): void;
+    markMutationInit(mutation: {
+      mutationId: string,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: Dict) => mixed) | void,
+      optimisticResponse: Dict,
+      ...
+    }): void;
+    markMutationResult(mutation: {
+      mutationId: string,
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: Dict) => mixed) | void,
+      ...
+    }): void;
+    markMutationComplete({
+      mutationId: string,
+      optimisticResponse?: any,
+      ...
+    }): void;
+    markUpdateQueryResult(
+      document: DocumentNode,
+      variables: any,
+      newResult: any
+    ): void;
+    reset(): Promise<void>;
+  }
+
+  declare type QueryWithUpdater = {
+    updater: MutationQueryReducer<Dict>,
+    query: QueryStoreValue,
+    ...
+  };
+
+  declare interface MutationStoreValue {
+    mutationString: string;
+    variables: Dict;
+    loading: boolean;
+    error: Error | null;
+  }
+
+  declare class MutationStore {
+    getStore(): { [mutationId: string]: MutationStoreValue, ... };
+    get(mutationId: string): MutationStoreValue;
+    initMutation(
+      mutationId: string,
+      mutationString: string,
+      variables: Dict
+    ): void;
+  }
+
+  declare interface FetchMoreOptions<TData, TVariables> {
+    updateQuery: (
+      previousQueryResult: TData,
+      options: {
+        fetchMoreResult?: TData,
+        variables: TVariables,
+        ...
+      }
+    ) => TData;
+  }
+
+  declare interface UpdateQueryOptions {
+    variables?: Dict;
+  }
+
+  declare type ApolloCurrentResult<T> = {
+    data: T | { ... },
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    error?: ApolloError,
+    partial?: boolean,
+    ...
+  };
+
+  declare interface ModifiableWatchQueryOptions {
+    variables?: { [key: string]: any, ... };
+    pollInterval?: number;
+    fetchPolicy?: FetchPolicy;
+    errorPolicy?: ErrorPolicy;
+    fetchResults?: boolean;
+    notifyOnNetworkStatusChange?: boolean;
+  }
+
+  declare interface WatchQueryOptions
+    extends ModifiableWatchQueryOptions {
+    query: DocumentNode;
+    metadata?: any;
+    context?: any;
+  }
+
+  declare type RefetchQueryDescription = $ReadOnlyArray<
+    string | PureQueryOptions
+  >;
+
+  declare interface MutationBaseOptions<T = { [key: string]: any, ... }> {
+    updateQueries?: MutationQueryReducersMap<T>;
+    optimisticResponse?: Dict;
+    refetchQueries?:
+      | ((result: ExecutionResult<>) => RefetchQueryDescription)
+      | RefetchQueryDescription;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: any;
+  }
+
+  declare interface MutationOptions<T = { [key: string]: any, ... }>
+    extends MutationBaseOptions<T> {
+    mutation: DocumentNode;
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+  }
+
+  declare interface SubscriptionOptions {
+    query: DocumentNode;
+    variables?: { [key: string]: any, ... };
+  }
+
+  declare type FetchPolicy =
+    | 'cache-first'
+    | 'cache-and-network'
+    | 'network-only'
+    | 'cache-only'
+    | 'no-cache'
+    | 'standby';
+
+  declare type ErrorPolicy = 'none' | 'ignore' | 'all';
+
+  declare interface FetchMoreQueryOptions<TVariables> {
+    variables: $Shape<TVariables>;
+  }
+
+  declare type SubscribeToMoreOptions<
+    TData,
+    TSubscriptionData,
+    TSubscriptionVariables = void
+  > = {
+    document?: DocumentNode,
+    variables?: TSubscriptionVariables,
+    updateQuery?: (
+      previousResult: TData,
+      result: {
+        subscriptionData: { data?: TSubscriptionData, ... },
+        variables: TSubscriptionVariables,
+        ...
+      }
+    ) => TData,
+    onError?: (error: Error) => mixed,
+    ...
+  };
+
+  declare type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => mixed;
+
+  declare type NetworkStatus = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => mixed;
+
+  declare type QueryStoreValue = {
+    document: DocumentNode,
+    variables: Dict,
+    previousVariables?: Dict,
+    networkStatus: NetworkStatus,
+    networkError: Error | null,
+    graphQLErrors: GraphQLError[],
+    metadata: any,
+    ...
+  };
+
+  declare type PureQueryOptions = {
+    query: DocumentNode,
+    variables?: { [key: string]: any, ... },
+    ...
+  };
+
+  declare type ApolloQueryResult<T> = {
+    data: T,
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    stale: boolean,
+    ...
+  };
+
+  declare type FetchType = 1 | 2 | 3;
+
+  declare type MutationQueryReducer<T> = (
+    previousResult: { [key: string]: any, ... },
+    options: {
+      mutationResult: FetchResult<T>,
+      queryName: string | void,
+      queryVariables: { [key: string]: any, ... },
+      ...
+    }
+  ) => { [key: string]: any, ... };
+
+  declare type MutationQueryReducersMap<
+    T = { [key: string]: any, ... }
+  > = { [queryName: string]: MutationQueryReducer<T>, ... };
+
+  declare class $ApolloError extends Error {
+    message: string;
+    graphQLErrors: Array<GraphQLError>;
+    networkError: Error | null;
+    extraInfo: any;
+    constructor(info: ErrorConstructor): this;
+  }
+  declare export type ApolloError = $ApolloError;
+
+  declare interface ErrorConstructor {
+    graphQLErrors?: Array<GraphQLError>;
+    networkError?: Error | null;
+    errorMessage?: string;
+    extraInfo?: any;
+  }
+
+  declare interface DefaultOptions {
+    +watchQuery?: ModifiableWatchQueryOptions;
+    +query?: ModifiableWatchQueryOptions;
+    +mutate?: MutationBaseOptions<>;
+  }
+
+  declare type ApolloClientOptions<TCacheShape> = {
+    link: ApolloLink,
+    cache: ApolloCache<TCacheShape>,
+    ssrMode?: boolean,
+    ssrForceFetchDelay?: number,
+    connectToDevTools?: boolean,
+    queryDeduplication?: boolean,
+    defaultOptions?: DefaultOptions,
+    ...
+  };
+
+  declare class ApolloClient<TCacheShape> {
+    link: ApolloLink;
+    store: DataStore<TCacheShape>;
+    cache: ApolloCache<TCacheShape>;
+    queryManager: QueryManager<TCacheShape>;
+    disableNetworkFetches: boolean;
+    version: string;
+    queryDeduplication: boolean;
+    defaultOptions: DefaultOptions;
+    devToolsHookCb: any;
+    proxy: ApolloCache<TCacheShape> | void;
+    ssrMode: boolean;
+    resetStoreCallbacks: Array<() => Promise<any>>;
+
+    constructor(options: ApolloClientOptions<TCacheShape>): this;
+    watchQuery<T>(options: WatchQueryOptions): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    mutate<T>(options: MutationOptions<T>): Promise<FetchResult<T>>;
+    subscribe(options: SubscriptionOptions): Observable<any>;
+    readQuery<T>(options: DataProxyReadQueryOptions): T | null;
+    readFragment<T>(options: DataProxyReadFragmentOptions): T | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+    __actionHookForDevTools(cb: () => mixed): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    clearStore(): Promise<void | null>;
+    resetStore(): Promise<Array<ApolloQueryResult<any>> | null>;
+    onResetStore(cb: () => Promise<any>): () => void;
+    reFetchObservableQueries(
+      includeStandby?: boolean
+    ): Promise<ApolloQueryResult<any>[]> | Promise<null>;
+    extract(optimistic?: boolean): TCacheShape;
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+  }
+
+  /* apollo-link types */
+  declare class ApolloLink {
+    constructor(request?: RequestHandler): this;
+
+    static empty(): ApolloLink;
+    static from(links: Array<ApolloLink>): ApolloLink;
+    static split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+    static execute(
+      link: ApolloLink,
+      operation: GraphQLRequest
+    ): Observable<FetchResult<>>;
+
+    split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+
+    request(
+      operation: Operation,
+      forward?: NextLink
+    ): Observable<FetchResult<>> | null;
+  }
+
+  declare interface GraphQLRequest {
+    query: DocumentNode;
+    variables?: { [key: string]: any, ... };
+    operationName?: string;
+    context?: { [key: string]: any, ... };
+    extensions?: { [key: string]: any, ... };
+  }
+
+  declare interface Operation {
+    query: DocumentNode;
+    variables: { [key: string]: any, ... };
+    operationName: string;
+    extensions: { [key: string]: any, ... };
+    setContext: (context: { [key: string]: any, ... }) => {
+      [key: string]: any,
+      ...,
+    };
+    getContext: () => { [key: string]: any, ... };
+    toKey: () => string;
+  }
+
+  declare type FetchResult<
+    C = { [key: string]: any, ... },
+    E = { [key: string]: any, ... }
+  > = ExecutionResult<C> & {
+    extension?: E,
+    context?: C,
+    ...
+  };
+
+  declare type NextLink = (operation: Operation) => Observable<FetchResult<>>;
+
+  declare type RequestHandler = (
+    operation: Operation,
+    forward?: NextLink
+  ) => Observable<FetchResult<>> | null;
+
+  declare class Observable<T> {
+    subscribe(
+      observerOrNext: ((value: T) => mixed) | ZenObservableObserver<T>,
+      error?: (error: any) => mixed,
+      complete?: () => mixed
+    ): ZenObservableSubscription;
+
+    forEach(fn: (value: T) => mixed): Promise<void>;
+
+    map<R>(fn: (value: T) => R): Observable<R>;
+
+    filter(fn: (value: T) => boolean): Observable<T>;
+
+    reduce<R>(
+      fn: (previousValue: R | T, currentValue: T) => R | T,
+      initialValue?: R | T
+    ): Observable<R | T>;
+
+    flatMap<R>(fn: (value: T) => ZenObservableObservableLike<R>): Observable<R>;
+
+    from<R>(
+      observable: Observable<R> | ZenObservableObservableLike<R> | Array<R>
+    ): Observable<R>;
+
+    of<R>(...args: Array<R>): Observable<R>;
+  }
+
+  declare interface Observer<T> {
+    start?: (subscription: SubscriptionLINK) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare interface SubscriptionLINK {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare interface ZenObservableSubscriptionObserver<T> {
+    closed: boolean;
+    next(value: T): void;
+    error(errorValue: any): void;
+    complete(): void;
+  }
+
+  declare interface ZenObservableSubscription {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare interface ZenObservableObserver<T> {
+    start?: (subscription: ZenObservableSubscription) => mixed;
+    next?: (value: T) => mixed;
+    error?: (errorValue: any) => mixed;
+    complete?: () => mixed;
+  }
+
+  declare type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => mixed | (() => mixed) | SubscriptionLINK;
+
+  declare interface ZenObservableObservableLike<T> {
+    subscribe?: ZenObservableSubscriber<T>;
+  }
+  /* apollo-link types */
+
+  /* apollo-cache types */
+  declare class ApolloCache<TSerialized> {
+    read<T>(query: CacheReadOptions): T | null;
+    write(write: CacheWriteOptions): void;
+    diff<T>(query: CacheDiffOptions): CacheDiffResult<T>;
+    watch(watch: CacheWatchOptions): () => void;
+    evict(query: CacheEvictOptions): CacheEvictionResult;
+    reset(): Promise<void>;
+
+    restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    extract(optimistic?: boolean): TSerialized;
+
+    removeOptimistic(id: string): void;
+
+    performTransaction(transaction: Transaction<TSerialized>): void;
+    recordOptimisticTransaction(
+      transaction: Transaction<TSerialized>,
+      id: string
+    ): void;
+
+    transformDocument(document: DocumentNode): DocumentNode;
+    transformForLink(document: DocumentNode): DocumentNode;
+
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: CacheWriteQueryOptions): void;
+    writeFragment(options: CacheWriteFragmentOptions): void;
+    writeData(options: CacheWriteDataOptions): void;
+  }
+
+  declare type Transaction<T> = (c: ApolloCache<T>) => mixed;
+
+  declare type CacheWatchCallback = (newData: any) => mixed;
+
+  declare interface CacheEvictionResult {
+    success: boolean;
+  }
+
+  declare interface CacheReadOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+    previousResult?: any;
+    optimistic: boolean;
+  }
+
+  declare interface CacheWriteOptions extends DataProxyReadQueryOptions {
+    dataId: string;
+    result: any;
+  }
+
+  declare interface CacheDiffOptions extends CacheReadOptions {
+    returnPartialData?: boolean;
+  }
+
+  declare interface CacheWatchOptions extends CacheReadOptions {
+    callback: CacheWatchCallback;
+  }
+
+  declare interface CacheEvictOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+  }
+
+  declare type CacheDiffResult<T> = DataProxyDiffResult<T>;
+  declare type CacheWriteQueryOptions = DataProxyWriteQueryOptions;
+  declare type CacheWriteFragmentOptions = DataProxyWriteFragmentOptions;
+  declare type CacheWriteDataOptions = DataProxyWriteDataOptions;
+
+  declare interface DataProxyReadQueryOptions {
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare interface DataProxyReadFragmentOptions {
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteQueryOptions {
+    data: any;
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteFragmentOptions {
+    data: any;
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteDataOptions {
+    data: any;
+    id?: string;
+  }
+
+  declare type DataProxyDiffResult<T> = {
+    result?: T,
+    complete?: boolean,
+    ...
+  };
+
+  declare interface DataProxy {
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+  }
+  /* End apollo-cache types */
+
+  /** End from Apollo Client */
+
+  /**
+   * Types From graphql
+   * graphql types are maintained in the graphql-js repo
+   */
+  declare type DocumentNode = any;
+  declare type ExecutionResult<T> = {
+    data?: T,
+    extensions?: { [string]: any, ... },
+    errors?: any[],
+    ...
+  };
+  declare type GraphQLError = any;
+  /** End From graphql */
+
+  declare export interface ApolloProviderProps<TCache> {
+    client: any; // ApolloClient<TCache>;
+    children: Node;
+  }
+
+  declare export interface ApolloConsumerProps {
+    children: (client: ApolloClient<any>) => Node;
+  }
+
+  declare export class ApolloConsumer extends React$Component<ApolloConsumerProps> {}
+
+  declare export class ApolloProvider<TCache> extends React$Component<
+    ApolloProviderProps<TCache>
+  > {
+    childContextTypes: {
+      client: ApolloClient<TCache>,
+      operations: Map<
+        string,
+        {
+          query: DocumentNode,
+          variables: any,
+          ...
+        }
+      >,
+      ...
+    };
+
+    getChildContext(): {
+      client: ApolloClient<TCache>,
+      operations: Map<
+        string,
+        {
+          query: DocumentNode,
+          variables: any,
+          ...
+        }
+      >,
+      ...
+    };
+  }
+
+  declare type MutationFunc<TResult, TVariables> = (
+    opts: MutationOpts<TVariables>
+  ) => Promise<ApolloQueryResult<TResult>>;
+
+  declare export type GraphqlData<TResult, TVariables> = TResult &
+    GraphqlQueryControls<TVariables> & {
+      variables: TVariables,
+      refetch: (variables?: TVariables) => Promise<ApolloQueryResult<any>>,
+      ...
+    };
+
+  declare export type ChildProps<
+    TOwnProps,
+    TResult,
+    TVariables: Dict = { ... }
+  > = {
+    data: GraphqlData<TResult, TVariables>,
+    mutate: MutationFunc<TResult, TVariables>,
+    ...
+  } & TOwnProps;
+
+  declare type RefetchQueriesProviderFn = (
+    ...args: any[]
+  ) => RefetchQueryDescription;
+
+  declare type MutationOpts<TVariables> = {|
+    variables?: TVariables,
+    optimisticResponse?: Dict,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    update?: MutationUpdaterFn<any>,
+    errorPolicy?: ErrorPolicy,
+  |};
+
+  declare type QueryOpts<TVariables> = {|
+    ssr?: boolean,
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    pollInterval?: number,
+    skip?: boolean,
+    errorPolicy?: ErrorPolicy,
+    context?: { [key: string]: any, ... },
+  |};
+
+  declare export interface GraphqlQueryControls<
+    TGraphQLVariables = OperationVariables
+  > {
+    error?: ApolloError | any; // Added optional `any` to satisfy Flow < 0.62
+    networkStatus: NetworkStatus;
+    loading: boolean;
+    variables: TGraphQLVariables;
+    fetchMore: (
+      fetchMoreOptions: FetchMoreQueryOptions<TGraphQLVariables> &
+        FetchMoreOptions<any, TGraphQLVariables>
+    ) => Promise<ApolloQueryResult<any>>;
+    refetch: (variables?: TGraphQLVariables) => Promise<ApolloQueryResult<any>>;
+    startPolling: (pollInterval: number) => void;
+    stopPolling: () => void;
+    subscribeToMore: (options: SubscribeToMoreOptions<any, any>) => () => void;
+    updateQuery: (
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ) => void;
+  }
+
+  declare interface OptionProps<TProps, TResult, TVariables> {
+    ownProps: TProps;
+    data?: GraphqlData<TResult, TVariables>;
+    mutate: MutationFunc<TResult, TVariables>;
+  }
+
+  declare type OptionDescription<TProps, TVariables> =
+    | QueryOpts<TVariables>
+    | MutationOpts<TVariables>
+    | ((props: TProps) => QueryOpts<TVariables> | MutationOpts<TVariables>);
+
+  declare interface OperationOption<
+    TResult: { ... },
+    TProps: { ... },
+    TChildProps: { ... },
+    TVariables: { ... }
+  > {
+    +options?: OptionDescription<TProps, TVariables>;
+    props?: (
+      props: OptionProps<TProps, TResult, TVariables>
+    ) => TChildProps | ChildProps<TProps, TResult, TVariables>;
+    +skip?: boolean | ((props: any) => boolean);
+    name?: string;
+    withRef?: boolean;
+    shouldResubscribe?: (props: TProps, nextProps: TProps) => boolean;
+    alias?: string;
+  }
+
+  declare export interface OperationComponent<
+    TResult: Dict = { ... },
+    TOwnProps: Dict = { ... },
+    TVariables: Dict = { ... },
+    TMergedProps: Dict = ChildProps<TOwnProps, TResult, TVariables>
+  > {
+    (component: ComponentType<TMergedProps>): ComponentType<TOwnProps>;
+  }
+
+  declare export function graphql<TResult, TProps, TVariables, TChildProps>(
+    document: DocumentNode,
+    operationOptions?: OperationOption<TResult, TProps, TChildProps, TVariables>
+  ): OperationComponent<TResult, TProps, TVariables, TChildProps>;
+
+  declare type WithApolloOptions = { withRef?: boolean, ... };
+
+  declare export function withApollo<TProps>(
+    component: ComponentType<{ client: ApolloClient<any>, ... } & TProps>,
+    operationOptions?: WithApolloOptions
+  ): ComponentType<TProps>;
+
+  declare type SubscriptionResult<
+    TData,
+    TVariables = OperationVariables
+  > = {
+    loading: boolean,
+    data?: MakeDataOptional<TData>,
+    error?: ApolloError,
+    ...
+  };
+
+  declare type SubscriptionRenderPropFunction<TData, TVariables> = (
+    result: SubscriptionResult<TData, TVariables>
+  ) => Node;
+
+  declare type OnSubscriptionDataOptions<TData> = {
+    client: ApolloClient<any>,
+    subscriptionData: SubscriptionResult<TData>,
+    ...
+  };
+
+  declare type SubscriptionProps<TData, TVariables = OperationVariables> = {
+    subscription: DocumentNode,
+    variables?: TVariables,
+    shouldResubscribe?:
+      | boolean
+      | ((
+          SubscriptionProps<TData, TVariables>,
+          SubscriptionProps<TData, TVariables>
+        ) => boolean),
+    onSubscriptionData?: (OnSubscriptionDataOptions<TData>) => any,
+    children?: SubscriptionRenderPropFunction<TData, TVariables>,
+    ...
+  };
+
+  declare type OperationVariables = { [key: string]: any, ... };
+}
diff --git a/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/test_react-hoc_v3.x.x.js b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/test_react-hoc_v3.x.x.js
new file mode 100644
index 0000000000..cb21dd51e3
--- /dev/null
+++ b/definitions/npm/@apollo/react-hoc_v3.x.x/flow_v0.201.x-/test_react-hoc_v3.x.x.js
@@ -0,0 +1,289 @@
+// @flow
+import * as React from 'react';
+import { it, describe } from 'flow-typed-test';
+import {
+  ApolloProvider,
+  ApolloConsumer,
+  graphql,
+  withApollo,
+  type OperationComponent,
+  type GraphqlQueryControls,
+  type ChildProps,
+  type GraphqlData,
+} from '@apollo/react-hoc';
+
+const gql = (strings, ...args) => {}; // graphql-tag stub
+
+const query = gql`
+  {
+    foo
+  }
+`;
+const mutation = gql`
+  mutation {
+    foo
+  }
+`;
+
+type Hero = {
+  name: string,
+  id: string,
+  appearsIn: string[],
+  friends: Hero[],
+  ...
+};
+
+type IQuery = {
+  foo: string,
+  bar: string,
+  ...
+};
+
+const withData: OperationComponent<IQuery> = graphql(query);
+
+it('works with functional component', () => {
+  const FunctionalWithData = withData(({ data }) => {
+    // $FlowExpectedError string type being treated as numerical
+    if (data.foo > 1) return <span />;
+
+    return null;
+  });
+});
+
+it('works with class component, this requires a stricter definition', () => {
+  type BasicComponentProps = ChildProps<{ ... }, IQuery>;
+  class BasicComponent extends React.Component<BasicComponentProps> {
+    render() {
+      const { foo, bar } = this.props.data;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return <div>{foo.length} string length</div>;
+    }
+  }
+  const BasicClassWithData = withData(BasicComponent);
+});
+
+it("works with class component with it's own variable", () => {
+  type CmplxOwnProps = { faz: string, ... };
+  type CmplxComponentProps = {
+    data: GraphqlQueryControls<> & IQuery,
+    // The mutation is actually required or we get a error at the withData
+    mutate: any,
+    ...
+  } & CmplxOwnProps;
+  class CmplxComponent extends React.Component<CmplxComponentProps> {
+    render() {
+      const {
+        data: { loading, error, bar, foo },
+        faz,
+      } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return (
+        <div>
+          {foo.length} string length compared to faz {faz.length} length
+        </div>
+      );
+    }
+  }
+  const withFancyData: OperationComponent<IQuery, CmplxOwnProps> = graphql(
+    query
+  );
+  const CmplxWithData = withFancyData(CmplxComponent);
+});
+
+it("works with class component with it's own variable Props specified at the end", () => {
+  // Same as above but with the Props specified at the end
+  // since we don't rely on the ChildProps<P, R> we don't need the mutate: any
+  type Cmplx2OwnProps = { faz: string, ... }; // We can have exact own props as we don't rely on the TMergedProps
+  type Cmplx2ComponentProps = {
+    data: IQuery & GraphqlQueryControls<>,
+    ...
+  } & Cmplx2OwnProps;
+  class Cmplx2Component extends React.Component<Cmplx2ComponentProps> {
+    render() {
+      const {
+        data: { loading, error, bar, foo },
+        faz,
+      } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return (
+        <div>
+          {foo.length} string length compared to faz {faz.length} length
+        </div>
+      );
+    }
+  }
+  const withFancyData2: OperationComponent<
+    IQuery,
+    Cmplx2OwnProps,
+    any,
+    Cmplx2ComponentProps
+  > = graphql(query);
+  const Cmplx2WithData = withFancyData2(Cmplx2Component);
+});
+
+const HERO_QUERY = gql`
+  query GetCharacter($episode: String!, $offset: Int) {
+    hero(episode: $episode, offset: $offset) {
+      name
+      id
+      friends {
+        name
+        id
+        appearsIn
+      }
+    }
+  }
+`;
+
+const OTHER_QUERY = gql`
+  query GetOther($other: String!) {
+    other(other: $other) {
+      name
+    }
+  }
+`;
+
+const HERO_MUTATION = gql`
+  mutation UpdateHero($input: HeroInput!) {
+    updateHero(input: $input) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+const HERO_SUBSCRIPTION = gql`
+  mutation onHeroUpdate($heroId: ID!) {
+    heroUpdated(heroId: $heroId) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+it('works with Variables specified', () => {
+  type Response = { hero: Hero, ... };
+
+  type InputProps = { episode: string, ... };
+
+  type Variables = { episode: string, ... };
+
+  type Props = GraphqlData<Response, Variables> & { someProp: string, ... };
+
+  const withCharacter: OperationComponent<
+    Response,
+    InputProps,
+    Variables,
+    Props
+  > = graphql(HERO_QUERY, {
+    options: ({ episode }) => {
+      // $FlowExpectedError [string] The operand of an arithmetic operation must be a number
+      episode * 10;
+      return {
+        // $FlowExpectedError [number] This type is incompatible with string
+        variables: { episode: 10 },
+      };
+    },
+    props: ({ data, ownProps }) => ({
+      ...data,
+      // $FlowExpectedError [string] This type cannot be compared to number
+      episode: ownProps.episode > 1,
+      // $FlowExpectedError property `isHero`. Property not found on object type
+      isHero: data && data.hero && data.hero.isHero,
+      // $FlowExpectedError Property `someProp`. This type is incompatible with string
+      someProp: 1,
+    }),
+  });
+
+  withCharacter(({ loading, error }) => {
+    if (loading) return <div>Loading</div>;
+    if (error) return <h1>ERROR</h1>;
+    return null;
+  });
+
+  class Character extends React.Component<Props> {
+    render() {
+      const { loading, hero, error } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+      return null; // actual component with data;
+    }
+  }
+  const CharacterWithData = withCharacter(Character);
+});
+
+it('works with withApollo HOC', () => {
+  const Manual = withApollo(({ client }) => {
+    // XXX please don't ever actually do this
+    client.query({ query: HERO_QUERY });
+    return null;
+  });
+
+  // withApollo passes `client` property so that it is no longer required
+  (Manual: React.ComponentType<{ ... }>);
+});
+
+describe('<ApolloProvider />', () => {
+  it('works when passed client', () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+    <ApolloProvider client={client}>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed a client', () => {
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed children', () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider client={client} />;
+  });
+});
+
+describe('<ApolloConsumer />', () => {
+  it('passes ApolloClient to the consumer children', () => {
+    <ApolloConsumer>
+      {client => {
+        const onClick = () => {
+          client.resetStore();
+          client.query({ query: HERO_QUERY });
+          client.readQuery({
+            query: HERO_QUERY,
+            variables: { episode: 'episode' },
+          });
+          // $FlowExpectedError doSomethingElse is not a method of ApolloClient
+          client.doSomethingElse();
+        };
+        return <button onClick={onClick}>Click</button>;
+      }}
+    </ApolloConsumer>;
+  });
+});
diff --git a/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-/test_tree-select_v1.x.x.js b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-v.200.x/test_tree-select_v1.x.x.js
similarity index 100%
rename from definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-/test_tree-select_v1.x.x.js
rename to definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-v.200.x/test_tree-select_v1.x.x.js
diff --git a/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-/tree-select_v1.x.x.js b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-v.200.x/tree-select_v1.x.x.js
similarity index 100%
rename from definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-/tree-select_v1.x.x.js
rename to definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.104.x-v.200.x/tree-select_v1.x.x.js
diff --git a/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/test_tree-select_v1.x.x.js b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/test_tree-select_v1.x.x.js
new file mode 100644
index 0000000000..2465abe6d5
--- /dev/null
+++ b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/test_tree-select_v1.x.x.js
@@ -0,0 +1,86 @@
+// @flow
+import treeSelect from '@automattic/tree-select';
+import { describe, it } from 'flow-typed-test';
+type Universe =
+  | 'Alien'
+  | 'Battlestar Galactica'
+  | 'Firefly'
+  | 'Star Wars'
+  | 'Star Trek'
+
+type Ship = {|
+  name: string,
+  universe: Universe,
+|}
+
+type State = {|
+  ships: Ship[],
+  selectedUniverses: Universe[],
+|}
+
+type Sorting<T> = (T, T) => -1 | 0 | 1;
+
+describe('#treeSelect', () => {
+  const shipsInUniverses = treeSelect(
+    (state: State) => [state.ships, state.selectedUniverses],
+    ([ships, universes], sortBy?: Sorting<Ship>) =>
+      ships
+        .filter(ship => universes.indexOf(ship.name) > -1)
+        .sort(sortBy)
+  );
+
+  it('infers correct arugment type', () => {
+    // $FlowExpectedError requires State as parameter
+    shipsInUniverses('hi');
+  });
+
+  it('infers correct return type', () => {
+    const state = {
+      ships: [],
+      selectedUniverses: [],
+    };
+
+    // $FlowExpectedError returns Ship[]
+    const badResult: String[] = shipsInUniverses(state);
+    const result: Ship[] = shipsInUniverses(state);
+  })
+
+  it('infers correct additinonal arguments', () => {
+    // $FlowExpectedError invalid sorting input types
+    shipsInUniverses(state, (a: string, b: string) => -1);
+
+    // $FlowExpectedError invalid return type in second fn argument
+    shipsInUniverses(state, (a: Ship, b: Ship) => 'a');
+
+    shipsInUniverses(state, (a, b) => {
+      // $FlowExpectedError a is a Ship has no speed prop
+      a.speed;
+      return 1;
+    })
+  })
+
+  it('infers correct dependency argument types', () => {
+    const findShip: (Ship[], (Ship) => boolean) => ?Ship = (ships, search) => {
+      return ships.find(search);
+    }
+    const selector = treeSelect(
+      (state: State) => [ state.ships, 'a', 1, false ],
+      ([ships, str, num, bool]) => {
+        // $FlowExpectedError ships should be Ship[]
+        (ships: boolean);
+        // $FlowExpectedError bool is boolean
+        (bool: string);
+        // $FlowExpectedError str is string
+        (str: boolean);
+        // $FlowExpectedError num is number
+        (num: boolean);
+        return ships.find(() => true);
+      }
+    );
+    // $FlowExpectedError should be ?Ship
+    const bad: ?string = selector({ships: [], selectedUniverses: []});
+    const good: ?Ship = selector({ships: [], selectedUniverses: []});
+  })
+});
+
+
diff --git a/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/tree-select_v1.x.x.js b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/tree-select_v1.x.x.js
new file mode 100644
index 0000000000..1b276d1626
--- /dev/null
+++ b/definitions/npm/@automattic/tree-select_v1.x.x/flow_v0.201.x-/tree-select_v1.x.x.js
@@ -0,0 +1,84 @@
+declare module '@automattic/tree-select' {
+	/**
+	 * Generics
+	 *
+	 * S: State - the application state
+	 * D: Dependents - the dependent values returned by the DependentsSelector
+	 * R: Result of Computation
+	 * O: Other parameters that the computation and resulting CachedSelector are provided
+	 */
+
+	/**
+	 * DependentsSelector is a function that accepts a State (S) object and
+	 * returns an array of values to be used in the Computation as well
+	 * as the values used by the caching/memoization layer.
+	 */
+	declare type DependentsSelector<S, O, D> = (S, ...O) => D;
+
+	/**
+	 * Function that computes a value based on the dependent values provided
+	 * by the DependentsSelector. It receives the values returned by
+	 * DependentsSelector as its first argument, the rest of the arguments
+	 * given to the computation are the same as the CachedSelector retured
+	 * by treeSelect.
+	 */
+	declare type Computation<D, R, O> = (D, ...O) => R;
+
+	/**
+	 * The cached selector is the returned function from treeSelect. It should
+	 * have the same signatrue as Computation except it accepts the State as its
+	 * first argument instead of the result of DependentsSelector. The rest of
+	 * the other (O) arguments are the same provided to the Computation.
+	 */
+	declare type CachedSelector<S, R, O> = (S, ...O) => R;
+
+	/**
+	 * Configuration options for treeSelect. Currently a single key
+	 * of getCacheKey that allows the implementor to calculate the cache
+	 * key for this use of treeSelect.
+	 */
+	declare type Options<O> = { /**
+     * getCachKey is given the dependent arguments and expects a string to
+     * use to identify the memoized return value
+     */
+    getCacheKey: (...O) => string, ... };
+
+	/**
+	 * Accepts two functions:
+	 * 1. (S) => D - Accepts state (S) and returns dependents (D) which is a list
+	 *      of values that 1) are used to memoize calling the Computation and 2)
+	 *      are provided as the first argument to the Computation
+	 * 2. (D, ...O) => R - Accepts the dependents (D) which is the result of the
+	 *      DependentsSelector<S, D> as well as any number of other (O) parameters.
+	 *      These same parameters will be used in the returned CachedSelector<S, R, O>
+	 *
+	 * Returns function of type:
+	 *
+	 * (S, ...O) => R
+   *
+   * The Computation<> is only executed if the dependencies form the first function change
+   * otherwise the memoized results are returned.
+	 *
+	 * A function that can be used as a selector accepting application state (S) as its
+	 * first argument. It is an identical function signature to the Computation<D, R, O>
+	 * except instead of accepting the state (S) and other (O) arguments it accepts the
+	 * dependents (D) from DependentsSelector<S, D> as its first argument and the other (O)
+	 * as the rest.
+   *
+   * Example:
+   *
+   *   const mySelector: (State, SecondArgType) => number = treeSelect(
+   *     (state) => [state.firstDependency, state.secondDependecy],
+   *     ([firstDepedency, secondDependency], secondArg) => {
+   *        // Do my CPU intensive calculation
+   *        return result;
+   *     }
+   *   );
+	 */
+	declare export default function treeSelect<S, D: Array<any>, R, O: Array<any>>(
+		DependentsSelector<S, O, D>,
+		Computation<D, R, O>,
+		Options<O> | void
+	): CachedSelector<S, R, O>;
+}
+
diff --git a/definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.104.x-/bottom-tabs_v5.x.x.js b/definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.104.x-v.200.x/bottom-tabs_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.104.x-/bottom-tabs_v5.x.x.js
rename to definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.104.x-v.200.x/bottom-tabs_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.201.x-/bottom-tabs_v5.x.x.js b/definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.201.x-/bottom-tabs_v5.x.x.js
new file mode 100644
index 0000000000..64eda742f6
--- /dev/null
+++ b/definitions/npm/@react-navigation/bottom-tabs_v5.x.x/flow_v0.201.x-/bottom-tabs_v5.x.x.js
@@ -0,0 +1,2100 @@
+declare module '@react-navigation/bottom-tabs' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * createBottomTabNavigator
+   */
+
+  declare export var createBottomTabNavigator: CreateNavigator<
+    TabNavigationState,
+    BottomTabOptions,
+    BottomTabNavigationEventMap,
+    ExtraBottomTabNavigatorProps,
+  >;
+
+  /**
+   * BottomTabBar
+   */
+
+  declare export var BottomTabBar: React$ComponentType<BottomTabBarProps>;
+
+  /**
+   * BottomTabView
+   */
+
+  declare export type BottomTabViewProps = {|
+    ...BottomTabNavigationConfig,
+    ...BottomTabNavigationBuilderResult,
+  |};
+  declare export var BottomTabView: React$ComponentType<BottomTabViewProps>;
+
+}
diff --git a/definitions/npm/@react-navigation/core_v5.x.x/flow_v0.104.x-/core_v5.x.x.js b/definitions/npm/@react-navigation/core_v5.x.x/flow_v0.104.x-v.200.x/core_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/core_v5.x.x/flow_v0.104.x-/core_v5.x.x.js
rename to definitions/npm/@react-navigation/core_v5.x.x/flow_v0.104.x-v.200.x/core_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/core_v5.x.x/flow_v0.201.x-/core_v5.x.x.js b/definitions/npm/@react-navigation/core_v5.x.x/flow_v0.201.x-/core_v5.x.x.js
new file mode 100644
index 0000000000..9ee38a7e1f
--- /dev/null
+++ b/definitions/npm/@react-navigation/core_v5.x.x/flow_v0.201.x-/core_v5.x.x.js
@@ -0,0 +1,2159 @@
+declare module '@react-navigation/core' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * Actions and routers
+   */
+
+  declare export var CommonActions: CommonActionsType;
+  declare export var StackActions: StackActionsType;
+  declare export var TabActions: TabActionsType;
+  declare export var DrawerActions: DrawerActionsType;
+
+  declare export var BaseRouter: RouterFactory<
+    NavigationState,
+    CommonAction,
+    DefaultRouterOptions,
+  >;
+  declare export var StackRouter: RouterFactory<
+    StackNavigationState,
+    StackAction,
+    StackRouterOptions,
+  >;
+  declare export var TabRouter: RouterFactory<
+    TabNavigationState,
+    TabAction,
+    TabRouterOptions,
+  >;
+  declare export var DrawerRouter: RouterFactory<
+    DrawerNavigationState,
+    DrawerAction,
+    DrawerRouterOptions,
+  >;
+
+  /**
+   * Navigator utils
+   */
+
+  declare export var BaseNavigationContainer: React$AbstractComponent<
+    BaseNavigationContainerProps,
+    BaseNavigationContainerInterface,
+  >;
+
+  declare export var createNavigatorFactory: CreateNavigatorFactory;
+
+  declare export var useNavigationBuilder: UseNavigationBuilder;
+
+  declare export var NavigationHelpersContext: React$Context<
+    ?NavigationHelpers<ParamListBase>,
+  >;
+
+  /**
+   * Navigation prop / route accessors
+   */
+
+  declare export var NavigationContext: React$Context<
+    ?NavigationProp<ParamListBase>,
+  >;
+  declare export function useNavigation(): NavigationProp<ParamListBase>;
+
+  declare export var NavigationRouteContext: React$Context<?LeafRoute<>>;
+  declare export function useRoute(): LeafRoute<>;
+
+  declare export function useNavigationState<T>(
+    selector: NavigationState => T,
+  ): T;
+
+  /**
+   * Focus utils
+   */
+
+  declare export function useFocusEffect(
+    effect: () => ?(() => mixed),
+  ): void;
+  declare export function useIsFocused(): boolean;
+
+  /**
+   * State utils
+   */
+
+  declare export var getStateFromPath: GetStateFromPath;
+
+  declare export var getPathFromState: GetPathFromState;
+
+  declare export function getActionFromState(
+    state: PossiblyStaleNavigationState,
+  ): ?NavigateAction;
+
+  declare export var getFocusedRouteNameFromRoute: GetFocusedRouteNameFromRoute;
+
+}
diff --git a/definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.104.x-/devtools_v5.x.x.js b/definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.104.x-v.200.x/devtools_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.104.x-/devtools_v5.x.x.js
rename to definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.104.x-v.200.x/devtools_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.201.x-/devtools_v5.x.x.js b/definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.201.x-/devtools_v5.x.x.js
new file mode 100644
index 0000000000..62bab03dde
--- /dev/null
+++ b/definitions/npm/@react-navigation/devtools_v5.x.x/flow_v0.201.x-/devtools_v5.x.x.js
@@ -0,0 +1,2077 @@
+declare module '@react-navigation/devtools' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  declare export function useReduxDevToolsExtension(
+    container: { +current: ?React$ElementRef<any>, ... },
+  ): void;
+
+}
diff --git a/definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.104.x-/drawer_v5.x.x.js b/definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.104.x-v.200.x/drawer_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.104.x-/drawer_v5.x.x.js
rename to definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.104.x-v.200.x/drawer_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.201.x-/drawer_v5.x.x.js b/definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.201.x-/drawer_v5.x.x.js
new file mode 100644
index 0000000000..94e3150878
--- /dev/null
+++ b/definitions/npm/@react-navigation/drawer_v5.x.x/flow_v0.201.x-/drawer_v5.x.x.js
@@ -0,0 +1,2159 @@
+declare module '@react-navigation/drawer' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * createDrawerNavigator
+   */
+
+  declare export var createDrawerNavigator: CreateNavigator<
+    DrawerNavigationState,
+    DrawerOptions,
+    DrawerNavigationEventMap,
+    ExtraDrawerNavigatorProps,
+  >;
+
+  /**
+   * DrawerView
+   */
+
+  declare export type DrawerViewProps = {|
+    ...DrawerNavigationConfig,
+    ...DrawerNavigationBuilderResult,
+  |};
+  declare export var DrawerView: React$ComponentType<DrawerViewProps>;
+
+  /**
+   * DrawerItem
+   */
+
+  declare export type DrawerItemProps = {|
+    +label:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    +onPress: () => mixed,
+    +icon?: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    +to?: string,
+    +focused?: boolean,
+    +activeTintColor?: string,
+    +inactiveTintColor?: string,
+    +activeBackgroundColor?: string,
+    +inactiveBackgroundColor?: string,
+    +labelStyle?: TextStyleProp,
+    +style?: ViewStyleProp,
+  |};
+  declare export var DrawerItem: React$ComponentType<DrawerItemProps>;
+
+  /**
+   * DrawerItemList
+   */
+
+  declare export type DrawerItemListProps = {|
+    ...DrawerItemListBaseOptions,
+    ...DrawerNavigationBuilderResult,
+  |};
+  declare export var DrawerItemList: React$ComponentType<DrawerItemListProps>;
+
+  /**
+   * DrawerContent
+   */
+
+  declare export var DrawerContent: React$ComponentType<DrawerContentProps>;
+
+  /**
+   * DrawerContentScrollView
+   */
+
+  declare export var DrawerContentScrollView: React$ComponentType<{
+    +children: React$Node,
+    ...
+  }>;
+
+  /**
+   * DrawerGestureContext
+   */
+
+  declare type GestureHandlerRef = React$Ref<
+    React$ComponentType<PanGestureHandlerProps>,
+  >;
+  declare export var DrawerGestureContext: React$Context<?GestureHandlerRef>;
+
+  /**
+   * useIsDrawerOpen
+   */
+
+  declare export function useIsDrawerOpen(): boolean;
+
+}
diff --git a/definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.104.x-/material-bottom-tabs_v5.x.x.js b/definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.104.x-v.200.x/material-bottom-tabs_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.104.x-/material-bottom-tabs_v5.x.x.js
rename to definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.104.x-v.200.x/material-bottom-tabs_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.201.x-/material-bottom-tabs_v5.x.x.js b/definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.201.x-/material-bottom-tabs_v5.x.x.js
new file mode 100644
index 0000000000..fd3f1f23c2
--- /dev/null
+++ b/definitions/npm/@react-navigation/material-bottom-tabs_v5.x.x/flow_v0.201.x-/material-bottom-tabs_v5.x.x.js
@@ -0,0 +1,2102 @@
+declare module '@react-navigation/material-bottom-tabs' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * createMaterialBottomTabNavigator
+   */
+
+  declare export var createMaterialBottomTabNavigator: CreateNavigator<
+    TabNavigationState,
+    MaterialBottomTabOptions,
+    MaterialBottomTabNavigationEventMap,
+    ExtraMaterialBottomTabNavigatorProps,
+  >;
+
+  /**
+   * MaterialBottomTabView
+   */
+
+  declare export type MaterialBottomTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+  declare export type MaterialBottomTabViewProps = {|
+    ...MaterialBottomTabNavigationConfig,
+    +state: TabNavigationState,
+    +navigation: MaterialBottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialBottomTabDescriptor |},
+  |};
+  declare export var MaterialBottomTabView: React$ComponentType<
+    MaterialBottomTabViewProps,
+  >;
+
+}
diff --git a/definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.104.x-/material-top-tabs_v5.x.x.js b/definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.104.x-v.200.x/material-top-tabs_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.104.x-/material-top-tabs_v5.x.x.js
rename to definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.104.x-v.200.x/material-top-tabs_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.201.x-/material-top-tabs_v5.x.x.js b/definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.201.x-/material-top-tabs_v5.x.x.js
new file mode 100644
index 0000000000..699e08b213
--- /dev/null
+++ b/definitions/npm/@react-navigation/material-top-tabs_v5.x.x/flow_v0.201.x-/material-top-tabs_v5.x.x.js
@@ -0,0 +1,2104 @@
+declare module '@react-navigation/material-top-tabs' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * createMaterialTopTabNavigator
+   */
+
+  declare export var createMaterialTopTabNavigator: CreateNavigator<
+    TabNavigationState,
+    MaterialTopTabOptions,
+    MaterialTopTabNavigationEventMap,
+    ExtraMaterialTopTabNavigatorProps,
+  >;
+
+  /**
+   * MaterialTopTabView
+   */
+
+  declare export type MaterialTopTabViewProps = {|
+    ...MaterialTopTabNavigationConfig,
+    ...MaterialTopTabNavigationBuilderResult,
+  |};
+  declare export var MaterialTopTabView: React$ComponentType<
+    MaterialTopTabViewProps,
+  >;
+
+  /**
+   * MaterialTopTabBar
+   */
+
+  declare export var MaterialTopTabBar: React$ComponentType<
+    MaterialTopTabBarProps,
+  >;
+
+}
diff --git a/definitions/npm/@react-navigation/native_v5.x.x/flow_v0.104.x-/native_v5.x.x.js b/definitions/npm/@react-navigation/native_v5.x.x/flow_v0.104.x-v.200.x/native_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/native_v5.x.x/flow_v0.104.x-/native_v5.x.x.js
rename to definitions/npm/@react-navigation/native_v5.x.x/flow_v0.104.x-v.200.x/native_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/native_v5.x.x/flow_v0.201.x-/native_v5.x.x.js b/definitions/npm/@react-navigation/native_v5.x.x/flow_v0.201.x-/native_v5.x.x.js
new file mode 100644
index 0000000000..b8ba5b2f55
--- /dev/null
+++ b/definitions/npm/@react-navigation/native_v5.x.x/flow_v0.201.x-/native_v5.x.x.js
@@ -0,0 +1,2241 @@
+declare module '@react-navigation/native' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * Actions and routers
+   */
+
+  declare export var CommonActions: CommonActionsType;
+  declare export var StackActions: StackActionsType;
+  declare export var TabActions: TabActionsType;
+  declare export var DrawerActions: DrawerActionsType;
+
+  declare export var BaseRouter: RouterFactory<
+    NavigationState,
+    CommonAction,
+    DefaultRouterOptions,
+  >;
+  declare export var StackRouter: RouterFactory<
+    StackNavigationState,
+    StackAction,
+    StackRouterOptions,
+  >;
+  declare export var TabRouter: RouterFactory<
+    TabNavigationState,
+    TabAction,
+    TabRouterOptions,
+  >;
+  declare export var DrawerRouter: RouterFactory<
+    DrawerNavigationState,
+    DrawerAction,
+    DrawerRouterOptions,
+  >;
+
+  /**
+   * Navigator utils
+   */
+
+  declare export var BaseNavigationContainer: React$AbstractComponent<
+    BaseNavigationContainerProps,
+    BaseNavigationContainerInterface,
+  >;
+
+  declare export var createNavigatorFactory: CreateNavigatorFactory;
+
+  declare export var useNavigationBuilder: UseNavigationBuilder;
+
+  declare export var NavigationHelpersContext: React$Context<
+    ?NavigationHelpers<ParamListBase>,
+  >;
+
+  /**
+   * Navigation prop / route accessors
+   */
+
+  declare export var NavigationContext: React$Context<
+    ?NavigationProp<ParamListBase>,
+  >;
+  declare export function useNavigation(): NavigationProp<ParamListBase>;
+
+  declare export var NavigationRouteContext: React$Context<?LeafRoute<>>;
+  declare export function useRoute(): LeafRoute<>;
+
+  declare export function useNavigationState<T>(
+    selector: NavigationState => T,
+  ): T;
+
+  /**
+   * Focus utils
+   */
+
+  declare export function useFocusEffect(
+    effect: () => ?(() => mixed),
+  ): void;
+  declare export function useIsFocused(): boolean;
+
+  /**
+   * State utils
+   */
+
+  declare export var getStateFromPath: GetStateFromPath;
+
+  declare export var getPathFromState: GetPathFromState;
+
+  declare export function getActionFromState(
+    state: PossiblyStaleNavigationState,
+  ): ?NavigateAction;
+
+  declare export var getFocusedRouteNameFromRoute: GetFocusedRouteNameFromRoute;
+
+  /**
+   * useScrollToTop
+   */
+
+  declare type ScrollToOptions = { y?: number, animated?: boolean, ... };
+  declare type ScrollToOffsetOptions = {
+    offset: number,
+    animated?: boolean,
+    ...
+  };
+  declare type ScrollableView =
+    | { scrollToTop(): void, ... }
+    | { scrollTo(options: ScrollToOptions): void, ... }
+    | { scrollToOffset(options: ScrollToOffsetOptions): void, ... }
+    | { scrollResponderScrollTo(options: ScrollToOptions): void, ... };
+  declare type ScrollableWrapper =
+    | { getScrollResponder(): React$Node, ... }
+    | { getNode(): ScrollableView, ... }
+    | ScrollableView;
+  declare export function useScrollToTop(
+    ref: { +current: ?ScrollableWrapper, ... },
+  ): void;
+
+  /**
+   * Themes
+   */
+
+  declare export var DefaultTheme: Theme & { +dark: false, ... };
+  declare export var DarkTheme: Theme & { +dark: true, ... };
+  declare export function useTheme(): Theme;
+  declare export var ThemeProvider: React$ComponentType<{|
+    +value: Theme,
+    +children: React$Node,
+  |}>;
+
+  /**
+   * Linking
+   */
+
+  declare export var Link: React$ComponentType<{
+    +to: string,
+    +action?: GenericNavigationAction,
+    +target?: string,
+    +children: React$Node,
+    ...
+  }>;
+
+  declare export function useLinking(
+    container: { +current: ?React$ElementRef<NavigationContainerType>, ... },
+    options: LinkingOptions,
+  ): {| +getInitialState: () => Promise<?PossiblyStaleNavigationState> |};
+
+  declare export function useLinkTo(): (path: string) => void;
+
+  declare export function useLinkProps<To: string>(props: {|
+    +to: To,
+    +action?: GenericNavigationAction,
+  |}): {|
+    +href: To,
+    +accessibilityRole: 'link',
+    +onPress: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export function useLinkBuilder(): (
+    name: string,
+    params?: ScreenParams,
+  ) => ?string;
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export var NavigationContainer: NavigationContainerType;
+
+  /**
+   * useBackButton
+   */
+
+  declare export function useBackButton(
+    container: { +current: ?React$ElementRef<NavigationContainerType>, ... },
+  ): void;
+
+}
diff --git a/definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.104.x-/stack_v5.x.x.js b/definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.104.x-v.200.x/stack_v5.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.104.x-/stack_v5.x.x.js
rename to definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.104.x-v.200.x/stack_v5.x.x.js
diff --git a/definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.201.x-/stack_v5.x.x.js b/definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.201.x-/stack_v5.x.x.js
new file mode 100644
index 0000000000..22d96b2d1d
--- /dev/null
+++ b/definitions/npm/@react-navigation/stack_v5.x.x/flow_v0.201.x-/stack_v5.x.x.js
@@ -0,0 +1,2195 @@
+declare module '@react-navigation/stack' {
+
+  //---------------------------------------------------------------------------
+  // SECTION 1: IDENTICAL TYPE DEFINITIONS
+  // This section is identical across all React Navigation libdefs and contains
+  // shared definitions. We wish we could make it DRY and import from a shared
+  // definition, but that isn't yet possible.
+  //---------------------------------------------------------------------------
+
+  /**
+   * We start with some definitions that we have copy-pasted from React Native
+   * source files.
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare interface Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+  declare type AnimationConfig = {
+    isInteraction?: boolean,
+    useNativeDriver: boolean,
+    onComplete?: ?EndCallback,
+    iterations?: number,
+    ...
+  };
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare interface AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare interface AnimatedValue {
+    constructor(value: number): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(callback: ValueListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(callback?: ?(value: number) => void): void;
+    resetAnimation(callback?: ?(value: number) => void): void;
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+    animate(animation: Animation, callback: ?EndCallback): void;
+    stopTracking(): void;
+    track(tracking: AnimatedTracking): void;
+  }
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/TimingAnimation.js
+  declare type TimingAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    easing?: (value: number) => number,
+    duration?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from
+  // react-native/Libraries/Animated/src/animations/SpringAnimation.js
+  declare type SpringAnimationConfigSingle = AnimationConfig & {
+    toValue: number | AnimatedValue,
+    overshootClamping?: boolean,
+    restDisplacementThreshold?: number,
+    restSpeedThreshold?: number,
+    velocity?: number,
+    bounciness?: number,
+    speed?: number,
+    tension?: number,
+    friction?: number,
+    stiffness?: number,
+    damping?: number,
+    mass?: number,
+    delay?: number,
+    ...
+  };
+
+  // Copied from react-native/Libraries/Types/CoreEventTypes.js
+  declare type SyntheticEvent<T> = $ReadOnly<{|
+    bubbles: ?boolean,
+    cancelable: ?boolean,
+    currentTarget: number,
+    defaultPrevented: ?boolean,
+    dispatchConfig: $ReadOnly<{|
+      registrationName: string,
+    |}>,
+    eventPhase: ?number,
+    preventDefault: () => void,
+    isDefaultPrevented: () => boolean,
+    stopPropagation: () => void,
+    isPropagationStopped: () => boolean,
+    isTrusted: ?boolean,
+    nativeEvent: T,
+    persist: () => void,
+    target: ?number,
+    timeStamp: number,
+    type: ?string,
+  |}>;
+  declare type Layout = $ReadOnly<{|
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  |}>;
+  declare type LayoutEvent = SyntheticEvent<
+    $ReadOnly<{|
+      layout: Layout,
+    |}>,
+  >;
+  declare type BlurEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type FocusEvent = SyntheticEvent<
+    $ReadOnly<{|
+      target: number,
+    |}>,
+  >;
+  declare type ResponderSyntheticEvent<T> = $ReadOnly<{|
+    ...SyntheticEvent<T>,
+    touchHistory: $ReadOnly<{|
+      indexOfSingleActiveTouch: number,
+      mostRecentTimeStamp: number,
+      numberActiveTouches: number,
+      touchBank: $ReadOnlyArray<
+        $ReadOnly<{|
+          touchActive: boolean,
+          startPageX: number,
+          startPageY: number,
+          startTimeStamp: number,
+          currentPageX: number,
+          currentPageY: number,
+          currentTimeStamp: number,
+          previousPageX: number,
+          previousPageY: number,
+          previousTimeStamp: number,
+        |}>,
+      >,
+    |}>,
+  |}>;
+  declare type PressEvent = ResponderSyntheticEvent<
+    $ReadOnly<{|
+      changedTouches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+      force: number,
+      identifier: number,
+      locationX: number,
+      locationY: number,
+      pageX: number,
+      pageY: number,
+      target: ?number,
+      timestamp: number,
+      touches: $ReadOnlyArray<$PropertyType<PressEvent, 'nativeEvent'>>,
+    |}>,
+  >;
+
+  // Vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+  declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+  declare type InterpolationConfigType = {
+    inputRange: Array<number>,
+    outputRange: Array<number> | Array<string>,
+    easing?: (input: number) => number,
+    extrapolate?: ExtrapolateType,
+    extrapolateLeft?: ExtrapolateType,
+    extrapolateRight?: ExtrapolateType,
+    ...
+  };
+  declare interface AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // Copied from react-native/Libraries/Components/View/ViewAccessibility.js
+  declare type AccessibilityRole =
+    | 'none'
+    | 'button'
+    | 'link'
+    | 'search'
+    | 'image'
+    | 'keyboardkey'
+    | 'text'
+    | 'adjustable'
+    | 'imagebutton'
+    | 'header'
+    | 'summary'
+    | 'alert'
+    | 'checkbox'
+    | 'combobox'
+    | 'menu'
+    | 'menubar'
+    | 'menuitem'
+    | 'progressbar'
+    | 'radio'
+    | 'radiogroup'
+    | 'scrollbar'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tablist'
+    | 'timer'
+    | 'toolbar';
+  declare type AccessibilityActionInfo = $ReadOnly<{
+    name: string,
+    label?: string,
+    ...
+  }>;
+  declare type AccessibilityActionEvent = SyntheticEvent<
+    $ReadOnly<{actionName: string, ...}>,
+  >;
+  declare type AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+  declare type AccessibilityValue = $ReadOnly<{|
+    min?: number,
+    max?: number,
+    now?: number,
+    text?: string,
+  |}>;
+
+  // Copied from
+  // react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js
+  declare type Stringish = string;
+  declare type EdgeInsetsProp = $ReadOnly<Partial<EdgeInsets>>;
+  declare type TouchableWithoutFeedbackProps = $ReadOnly<{|
+    accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+    accessibilityElementsHidden?: ?boolean,
+    accessibilityHint?: ?Stringish,
+    accessibilityIgnoresInvertColors?: ?boolean,
+    accessibilityLabel?: ?Stringish,
+    accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+    accessibilityRole?: ?AccessibilityRole,
+    accessibilityState?: ?AccessibilityState,
+    accessibilityValue?: ?AccessibilityValue,
+    accessibilityViewIsModal?: ?boolean,
+    accessible?: ?boolean,
+    children?: ?React$Node,
+    delayLongPress?: ?number,
+    delayPressIn?: ?number,
+    delayPressOut?: ?number,
+    disabled?: ?boolean,
+    focusable?: ?boolean,
+    hitSlop?: ?EdgeInsetsProp,
+    importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+    nativeID?: ?string,
+    onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+    onBlur?: ?(event: BlurEvent) => mixed,
+    onFocus?: ?(event: FocusEvent) => mixed,
+    onLayout?: ?(event: LayoutEvent) => mixed,
+    onLongPress?: ?(event: PressEvent) => mixed,
+    onPress?: ?(event: PressEvent) => mixed,
+    onPressIn?: ?(event: PressEvent) => mixed,
+    onPressOut?: ?(event: PressEvent) => mixed,
+    pressRetentionOffset?: ?EdgeInsetsProp,
+    rejectResponderTermination?: ?boolean,
+    testID?: ?string,
+    touchSoundDisabled?: ?boolean,
+  |}>;
+
+  // Copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = $ReadOnly<{
+    uri?: ?string,
+    bundle?: ?string,
+    method?: ?string,
+    headers?: ?Object,
+    body?: ?string,
+    cache?: ?('default' | 'reload' | 'force-cache' | 'only-if-cached'),
+    width?: ?number,
+    height?: ?number,
+    scale?: ?number,
+    ...
+  }>;
+
+  /**
+   * The following is copied from react-native-gesture-handler's libdef
+   */
+
+  declare type StateUndetermined = 0;
+  declare type StateFailed = 1;
+  declare type StateBegan = 2;
+  declare type StateCancelled = 3;
+  declare type StateActive = 4;
+  declare type StateEnd = 5;
+
+  declare type GestureHandlerState =
+    | StateUndetermined
+    | StateFailed
+    | StateBegan
+    | StateCancelled
+    | StateActive
+    | StateEnd;
+
+  declare type $SyntheticEvent<T: { ... }> = {
+    +nativeEvent: $ReadOnly<$Exact<T>>,
+    ...
+  };
+
+  declare type $Event<T: { ... }> = $SyntheticEvent<{
+    handlerTag: number,
+    numberOfPointers: number,
+    state: GestureHandlerState,
+    oldState: GestureHandlerState,
+    ...$Exact<T>,
+    ...
+  }>;
+
+  declare type $EventHandlers<ExtraProps: {...}> = {|
+    onGestureEvent?: ($Event<ExtraProps>) => mixed,
+    onHandlerStateChange?: ($Event<ExtraProps>) => mixed,
+    onBegan?: ($Event<ExtraProps>) => mixed,
+    onFailed?: ($Event<ExtraProps>) => mixed,
+    onCancelled?: ($Event<ExtraProps>) => mixed,
+    onActivated?: ($Event<ExtraProps>) => mixed,
+    onEnded?: ($Event<ExtraProps>) => mixed,
+  |};
+
+  declare type HitSlop =
+    | number
+    | {|
+        left?: number,
+        top?: number,
+        right?: number,
+        bottom?: number,
+        vertical?: number,
+        horizontal?: number,
+        width?: number,
+        height?: number,
+      |}
+    | {|
+        width: number,
+        left: number,
+      |}
+    | {|
+        width: number,
+        right: number,
+      |}
+    | {|
+        height: number,
+        top: number,
+      |}
+    | {|
+        height: number,
+        bottom: number,
+      |};
+
+  declare type $GestureHandlerProps<
+    AdditionalProps: {...},
+    ExtraEventsProps: {...}
+  > = $ReadOnly<{|
+    ...$Exact<AdditionalProps>,
+    ...$EventHandlers<ExtraEventsProps>,
+    id?: string,
+    enabled?: boolean,
+    waitFor?: React$Ref<any> | Array<React$Ref<any>>,
+    simultaneousHandlers?: React$Ref<any> | Array<React$Ref<any>>,
+    shouldCancelWhenOutside?: boolean,
+    minPointers?: number,
+    hitSlop?: HitSlop,
+    children?: React$Node,
+  |}>;
+
+  declare type PanGestureHandlerProps = $GestureHandlerProps<
+    {
+      activeOffsetY?: number | [number, number],
+      activeOffsetX?: number | [number, number],
+      failOffsetY?: number | [number, number],
+      failOffsetX?: number | [number, number],
+      minDist?: number,
+      minVelocity?: number,
+      minVelocityX?: number,
+      minVelocityY?: number,
+      minPointers?: number,
+      maxPointers?: number,
+      avgTouches?: boolean,
+      ...
+    },
+    {
+      x: number,
+      y: number,
+      absoluteX: number,
+      absoluteY: number,
+      translationX: number,
+      translationY: number,
+      velocityX: number,
+      velocityY: number,
+      ...
+    }
+  >;
+
+  /**
+   * MAGIC
+   */
+
+  declare type $If<Test: boolean, Then, Else = empty> = $Call<
+    ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+    Test,
+    Then,
+    Else,
+  >;
+  declare type $IsA<X, Y> = $Call<
+    (Y => true) & (mixed => false),
+    X,
+  >;
+  declare type $IsUndefined<X> = $IsA<X, void>;
+
+  declare type Partial<T> = $ReadOnly<$Rest<T, {...}>>;
+
+  /**
+   * Actions, state, etc.
+   */
+
+  declare export type ScreenParams = { +[key: string]: mixed, ... };
+
+  declare export type BackAction = {|
+    +type: 'GO_BACK',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type NavigateAction = {|
+    +type: 'NAVIGATE',
+    +payload:
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ResetAction = {|
+    +type: 'RESET',
+    +payload: StaleNavigationState,
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type SetParamsAction = {|
+    +type: 'SET_PARAMS',
+    +payload: {| +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CommonAction =
+    | BackAction
+    | NavigateAction
+    | ResetAction
+    | SetParamsAction;
+
+  declare type NavigateActionCreator = {|
+    (routeName: string, params?: ScreenParams): NavigateAction,
+    (
+      | {| +key: string, +params?: ScreenParams |}
+      | {| +name: string, +key?: string, +params?: ScreenParams |},
+    ): NavigateAction,
+  |};
+  declare export type CommonActionsType = {|
+    +navigate: NavigateActionCreator,
+    +goBack: () => BackAction,
+    +reset: (state: PossiblyStaleNavigationState) => ResetAction,
+    +setParams: (params: ScreenParams) => SetParamsAction,
+  |};
+
+  declare export type GenericNavigationAction = {|
+    +type: string,
+    +payload?: { +[key: string]: mixed, ... },
+    +source?: string,
+    +target?: string,
+  |};
+
+  declare export type LeafRoute<RouteName: string = string> = {|
+    +key: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StateRoute<RouteName: string = string> = {|
+    ...LeafRoute<RouteName>,
+    +state: NavigationState | StaleNavigationState,
+  |};
+  declare export type Route<RouteName: string = string> =
+    | LeafRoute<RouteName>
+    | StateRoute<RouteName>;
+
+  declare export type NavigationState = {|
+    +key: string,
+    +index: number,
+    +routeNames: $ReadOnlyArray<string>,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<Route<>>,
+    +type: string,
+    +stale: false,
+  |};
+
+  declare export type StaleLeafRoute<RouteName: string = string> = {|
+    +key?: string,
+    +name: RouteName,
+    +params?: ScreenParams,
+  |};
+  declare export type StaleStateRoute<RouteName: string = string> = {|
+    ...StaleLeafRoute<RouteName>,
+    +state: StaleNavigationState,
+  |};
+  declare export type StaleRoute<RouteName: string = string> =
+    | StaleLeafRoute<RouteName>
+    | StaleStateRoute<RouteName>;
+  declare export type StaleNavigationState = {|
+    // It's possible to pass React Nav a StaleNavigationState with an undefined
+    // index, but React Nav will always return one with the index set. This is
+    // the same as for the type property below, but in the case of index we tend
+    // to rely on it being set more...
+    +index: number,
+    +history?: $ReadOnlyArray<mixed>,
+    +routes: $ReadOnlyArray<StaleRoute<>>,
+    +type?: string,
+    +stale?: true,
+  |};
+
+  declare export type PossiblyStaleNavigationState =
+    | NavigationState
+    | StaleNavigationState;
+  declare export type PossiblyStaleRoute<RouteName: string = string> =
+    | Route<RouteName>
+    | StaleRoute<RouteName>;
+
+  /**
+   * Routers
+   */
+
+  declare type ActionCreators<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {
+    +[key: string]: (...args: any) => (Action | State => Action),
+    ...
+  };
+
+  declare export type DefaultRouterOptions = {
+    +initialRouteName?: string,
+    ...
+  };
+
+  declare export type RouterFactory<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    RouterOptions: DefaultRouterOptions,
+  > = (options: RouterOptions) => Router<State, Action>;
+
+  declare export type ParamListBase = { +[key: string]: ?ScreenParams, ... };
+
+  declare export type RouterConfigOptions = {|
+    +routeNames: $ReadOnlyArray<string>,
+    +routeParamList: ParamListBase,
+  |};
+
+  declare export type Router<
+    State: NavigationState,
+    Action: GenericNavigationAction,
+  > = {|
+    +type: $PropertyType<State, 'type'>,
+    +getInitialState: (options: RouterConfigOptions) => State,
+    +getRehydratedState: (
+      partialState: PossiblyStaleNavigationState,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteNamesChange: (
+      state: State,
+      options: RouterConfigOptions,
+    ) => State,
+    +getStateForRouteFocus: (state: State, key: string) => State,
+    +getStateForAction: (
+      state: State,
+      action: Action,
+      options: RouterConfigOptions,
+    ) => ?PossiblyStaleNavigationState;
+    +shouldActionChangeFocus: (action: GenericNavigationAction) => boolean,
+    +actionCreators?: ActionCreators<State, Action>,
+  |};
+
+  /**
+   * Stack actions and router
+   */
+
+  declare export type StackNavigationState = {|
+    ...NavigationState,
+    +type: 'stack',
+  |};
+
+  declare export type ReplaceAction = {|
+    +type: 'REPLACE',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PushAction = {|
+    +type: 'PUSH',
+    +payload: {| +name: string, +key?: ?string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopAction = {|
+    +type: 'POP',
+    +payload: {| +count: number |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type PopToTopAction = {|
+    +type: 'POP_TO_TOP',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type StackAction =
+    | CommonAction
+    | ReplaceAction
+    | PushAction
+    | PopAction
+    | PopToTopAction;
+
+  declare export type StackActionsType = {|
+    +replace: (routeName: string, params?: ScreenParams) => ReplaceAction,
+    +push: (routeName: string, params?: ScreenParams) => PushAction,
+    +pop: (count?: number) => PopAction,
+    +popToTop: () => PopToTopAction,
+  |};
+
+  declare export type StackRouterOptions = $Exact<DefaultRouterOptions>;
+
+  /**
+   * Tab actions and router
+   */
+
+  declare export type TabNavigationState = {|
+    ...NavigationState,
+    +type: 'tab',
+    +history: $ReadOnlyArray<{| type: 'route', key: string |}>,
+  |};
+
+  declare export type JumpToAction = {|
+    +type: 'JUMP_TO',
+    +payload: {| +name: string, +params?: ScreenParams |},
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type TabAction =
+    | CommonAction
+    | JumpToAction;
+
+  declare export type TabActionsType = {|
+    +jumpTo: string => JumpToAction,
+  |};
+
+  declare export type TabRouterOptions = {|
+    ...$Exact<DefaultRouterOptions>,
+    +backBehavior?: 'initialRoute' | 'order' | 'history' | 'none',
+  |};
+
+  /**
+   * Drawer actions and router
+   */
+
+  declare type DrawerHistoryEntry =
+    | {| +type: 'route', +key: string |}
+    | {| +type: 'drawer' |};
+  declare export type DrawerNavigationState = {|
+    ...NavigationState,
+    +type: 'drawer',
+    +history: $ReadOnlyArray<DrawerHistoryEntry>,
+  |};
+
+  declare export type OpenDrawerAction = {|
+    +type: 'OPEN_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type CloseDrawerAction = {|
+    +type: 'CLOSE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type ToggleDrawerAction = {|
+    +type: 'TOGGLE_DRAWER',
+    +source?: string,
+    +target?: string,
+  |};
+  declare export type DrawerAction =
+    | TabAction
+    | OpenDrawerAction
+    | CloseDrawerAction
+    | ToggleDrawerAction;
+
+  declare export type DrawerActionsType = {|
+    ...TabActionsType,
+    +openDrawer: () => OpenDrawerAction,
+    +closeDrawer: () => CloseDrawerAction,
+    +toggleDrawer: () => ToggleDrawerAction,
+  |};
+
+  declare export type DrawerRouterOptions = {|
+    ...TabRouterOptions,
+    +openByDefault?: boolean,
+  |};
+
+  /**
+   * Events
+   */
+
+  declare export type EventMapBase = {
+    +[name: string]: {|
+      +data?: mixed,
+      +canPreventDefault?: boolean,
+    |},
+    ...
+  };
+  declare type EventPreventDefaultProperties<Test: boolean> = $If<
+    Test,
+    {| +defaultPrevented: boolean, +preventDefault: () => void |},
+    {| |},
+  >;
+  declare type EventDataProperties<Data> = $If<
+    $IsUndefined<Data>,
+    {| |},
+    {| +data: Data |},
+  >;
+  declare type EventArg<
+    EventName: string,
+    CanPreventDefault: ?boolean = false,
+    Data = void,
+  > = {|
+    ...EventPreventDefaultProperties<CanPreventDefault>,
+    ...EventDataProperties<Data>,
+    +type: EventName,
+    +target?: string,
+  |};
+  declare type GlobalEventMap<State: PossiblyStaleNavigationState> = {|
+    +state: {| +data: {| +state: State |}, +canPreventDefault: false |},
+  |};
+  declare type EventMapCore<State: PossiblyStaleNavigationState> = {|
+    ...GlobalEventMap<State>,
+    +focus: {| +data: void, +canPreventDefault: false |},
+    +blur: {| +data: void, +canPreventDefault: false |},
+    +beforeRemove: {|
+      +data: {| +action: GenericNavigationAction |},
+      +canPreventDefault: true,
+    |},
+  |};
+  declare type EventListenerCallback<
+    EventName: string,
+    State: PossiblyStaleNavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = (e: EventArg<
+    EventName,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'canPreventDefault',
+    >,
+    $PropertyType<
+      $ElementType<
+        {| ...EventMap, ...EventMapCore<State> |},
+        EventName,
+      >,
+      'data',
+    >,
+  >) => mixed;
+
+  /**
+   * Navigation prop
+   */
+
+  declare export type SimpleNavigate<ParamList> =
+    <DestinationRouteName: $Keys<ParamList>>(
+      routeName: DestinationRouteName,
+      params: $ElementType<ParamList, DestinationRouteName>,
+    ) => void;
+
+  declare export type Navigate<ParamList> =
+    & SimpleNavigate<ParamList>
+    & <DestinationRouteName: $Keys<ParamList>>(
+        route:
+          | {|
+              +key: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |}
+          | {|
+              +name: DestinationRouteName,
+              +key?: string,
+              +params?: $ElementType<ParamList, DestinationRouteName>,
+            |},
+      ) => void;
+
+  declare type NavigationHelpers<
+    ParamList: ParamListBase,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    +navigate: Navigate<ParamList>,
+    +dispatch: (
+      action:
+        | GenericNavigationAction
+        | (State => GenericNavigationAction),
+    ) => void,
+    +reset: PossiblyStaleNavigationState => void,
+    +goBack: () => void,
+    +isFocused: () => boolean,
+    +canGoBack: () => boolean,
+    +dangerouslyGetParent: <Parent: NavigationProp<ParamListBase>>() => ?Parent,
+    +dangerouslyGetState: () => NavigationState,
+    +addListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => () => void,
+    +removeListener: <EventName: $Keys<
+      {| ...EventMap, ...EventMapCore<State> |},
+    >>(
+      name: EventName,
+      callback: EventListenerCallback<EventName, State, EventMap>,
+    ) => void,
+    ...
+  };
+
+  declare export type NavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: PossiblyStaleNavigationState = PossiblyStaleNavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {
+    ...$Exact<NavigationHelpers<
+      ParamList,
+      State,
+      EventMap,
+    >>,
+    +setOptions: (options: Partial<ScreenOptions>) => void,
+    +setParams: (
+      params: $If<
+        $IsUndefined<$ElementType<ParamList, RouteName>>,
+        empty,
+        Partial<$NonMaybeType<$ElementType<ParamList, RouteName>>>,
+      >,
+    ) => void,
+    ...
+  };
+
+  /**
+   * CreateNavigator
+   */
+
+  declare export type RouteProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+  > = {|
+    ...LeafRoute<RouteName>,
+    +params: $ElementType<ParamList, RouteName>,
+  |};
+
+  declare export type ScreenListeners<
+    State: NavigationState = NavigationState,
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = $ObjMapi<
+    {| [name: $Keys<EventMap>]: empty |},
+    <K: $Keys<EventMap>>(K, empty) => EventListenerCallback<K, State, EventMap>,
+  >;
+
+  declare type BaseScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = {|
+    +name: RouteName,
+    +options?:
+      | ScreenOptions
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenOptions,
+    +listeners?:
+      | ScreenListeners<State, EventMap>
+      | ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => ScreenListeners<State, EventMap>,
+    +initialParams?: Partial<$ElementType<ParamList, RouteName>>,
+  |};
+
+  declare export type ScreenProps<
+    ParamList: ParamListBase,
+    NavProp,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > =
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +component: React$ComponentType<{|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}>,
+      |}
+    | {|
+        ...BaseScreenProps<
+          ParamList,
+          NavProp,
+          RouteName,
+          State,
+          ScreenOptions,
+          EventMap,
+        >,
+        +children: ({|
+          route: RouteProp<ParamList, RouteName>,
+          navigation: NavProp,
+        |}) => React$Node,
+      |};
+
+  declare export type ScreenComponent<
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    State: NavigationState = NavigationState,
+    ScreenOptions: {...} = {...},
+    EventMap: EventMapBase = EventMapCore<State>,
+  > = <
+    RouteName: $Keys<ParamList>,
+    NavProp: NavigationProp<
+      GlobalParamList,
+      RouteName,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+  >(props: ScreenProps<
+    ParamList,
+    NavProp,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+  >) => React$Node;
+
+  declare type ScreenOptionsProp<ScreenOptions: {...}, NavProp> = {|
+    +screenOptions?:
+      | ScreenOptions
+      | ({| route: LeafRoute<>, navigation: NavProp |}) => ScreenOptions,
+  |};
+  declare export type ExtraNavigatorPropsBase = {
+    ...$Exact<DefaultRouterOptions>,
+    +children?: React$Node,
+    ...
+  };
+  declare export type NavigatorPropsBase<ScreenOptions: {...}, NavProp> = {
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    ...
+  };
+
+  declare export type CreateNavigator<
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  > = <
+    GlobalParamList: ParamListBase,
+    ParamList: ParamListBase,
+    NavProp: NavigationHelpers<
+      GlobalParamList,
+      State,
+      EventMap,
+    >,
+  >() => {|
+    +Screen: ScreenComponent<
+      GlobalParamList,
+      ParamList,
+      State,
+      ScreenOptions,
+      EventMap,
+    >,
+    +Navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorProps>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  |};
+
+  declare export type CreateNavigatorFactory = <
+    State: NavigationState,
+    ScreenOptions: {...},
+    EventMap: EventMapBase,
+    NavProp: NavigationHelpers<
+      ParamListBase,
+      State,
+      EventMap,
+    >,
+    ExtraNavigatorProps: ExtraNavigatorPropsBase,
+  >(
+    navigator: React$ComponentType<{|
+      ...$Exact<ExtraNavigatorPropsBase>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+    |}>,
+  ) => CreateNavigator<State, ScreenOptions, EventMap, ExtraNavigatorProps>;
+
+  /**
+   * useNavigationBuilder
+   */
+
+  declare export type Descriptor<
+    NavProp,
+    ScreenOptions: {...} = {...},
+  > = {|
+    +render: () => React$Node,
+    +options: $ReadOnly<ScreenOptions>,
+    +navigation: NavProp,
+  |};
+
+  declare export type UseNavigationBuilder = <
+    State: NavigationState,
+    Action: GenericNavigationAction,
+    ScreenOptions: {...},
+    RouterOptions: DefaultRouterOptions,
+    NavProp,
+  >(
+    routerFactory: RouterFactory<State, Action, RouterOptions>,
+    options: {|
+      ...$Exact<RouterOptions>,
+      ...ScreenOptionsProp<ScreenOptions, NavProp>,
+      +children?: React$Node,
+    |},
+  ) => {|
+    +state: State,
+    +descriptors: {| +[key: string]: Descriptor<NavProp, ScreenOptions> |},
+    +navigation: NavProp,
+  |};
+
+  /**
+   * EdgeInsets
+   */
+
+  declare type EdgeInsets = {|
+    +top: number,
+    +right: number,
+    +bottom: number,
+    +left: number,
+  |};
+
+  /**
+   * TransitionPreset
+   */
+
+  declare export type TransitionSpec =
+    | {|
+        animation: 'spring',
+        config: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |}
+    | {|
+        animation: 'timing',
+        config: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, ... },
+        >,
+      |};
+
+  declare export type StackCardInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +index: number,
+    +closing: AnimatedInterpolation,
+    +swiping: AnimatedInterpolation,
+    +inverted: AnimatedInterpolation,
+    +layouts: {|
+      +screen: {| +width: number, +height: number |},
+    |},
+    +insets: EdgeInsets,
+  |};
+  declare export type StackCardInterpolatedStyle = {|
+    containerStyle?: AnimatedViewStyleProp,
+    cardStyle?: AnimatedViewStyleProp,
+    overlayStyle?: AnimatedViewStyleProp,
+    shadowStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackCardStyleInterpolator = (
+    props: StackCardInterpolationProps,
+  ) => StackCardInterpolatedStyle;
+
+  declare export type StackHeaderInterpolationProps = {|
+    +current: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +next?: {|
+      +progress: AnimatedInterpolation,
+    |},
+    +layouts: {|
+      +header: {| +width: number, +height: number |},
+      +screen: {| +width: number, +height: number |},
+      +title?: {| +width: number, +height: number |},
+      +leftLabel?: {| +width: number, +height: number |},
+    |},
+  |};
+  declare export type StackHeaderInterpolatedStyle = {|
+    leftLabelStyle?: AnimatedViewStyleProp,
+    leftButtonStyle?: AnimatedViewStyleProp,
+    rightButtonStyle?: AnimatedViewStyleProp,
+    titleStyle?: AnimatedViewStyleProp,
+    backgroundStyle?: AnimatedViewStyleProp,
+  |};
+  declare export type StackHeaderStyleInterpolator = (
+    props: StackHeaderInterpolationProps,
+  ) => StackHeaderInterpolatedStyle;
+
+  declare type GestureDirection =
+    | 'horizontal'
+    | 'horizontal-inverted'
+    | 'vertical'
+    | 'vertical-inverted';
+
+  declare export type TransitionPreset = {|
+    +gestureDirection: GestureDirection,
+    +transitionSpec: {|
+      +open: TransitionSpec,
+      +close: TransitionSpec,
+    |},
+    +cardStyleInterpolator: StackCardStyleInterpolator,
+    +headerStyleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  /**
+   * Stack options
+   */
+
+  declare export type StackDescriptor = Descriptor<
+    StackNavigationProp<>,
+    StackOptions,
+  >;
+
+  declare type Scene<T> = {|
+    +route: T,
+    +descriptor: StackDescriptor,
+    +progress: {|
+      +current: AnimatedInterpolation,
+      +next?: AnimatedInterpolation,
+      +previous?: AnimatedInterpolation,
+    |},
+  |};
+
+  declare export type StackHeaderProps = {|
+    +mode: 'float' | 'screen',
+    +layout: {| +width: number, +height: number |},
+    +insets: EdgeInsets,
+    +scene: Scene<Route<>>,
+    +previous?: Scene<Route<>>,
+    +navigation: StackNavigationProp<ParamListBase>,
+    +styleInterpolator: StackHeaderStyleInterpolator,
+  |};
+
+  declare export type StackHeaderLeftButtonProps = Partial<{|
+    +onPress: (() => void),
+    +pressColorAndroid: string;
+    +backImage: (props: {| tintColor: string |}) => React$Node,
+    +tintColor: string,
+    +label: string,
+    +truncatedLabel: string,
+    +labelVisible: boolean,
+    +labelStyle: AnimatedTextStyleProp,
+    +allowFontScaling: boolean,
+    +onLabelLayout: LayoutEvent => void,
+    +screenLayout: {| +width: number, +height: number |},
+    +titleLayout: {| +width: number, +height: number |},
+    +canGoBack: boolean,
+  |}>;
+
+  declare type StackHeaderTitleInputBase = {
+    +onLayout: LayoutEvent => void,
+    +children: string,
+    +allowFontScaling: ?boolean,
+    +tintColor: ?string,
+    +style: ?AnimatedTextStyleProp,
+    ...
+  };
+
+  declare export type StackHeaderTitleInputProps =
+    $Exact<StackHeaderTitleInputBase>;
+
+  declare export type StackOptions = Partial<{|
+    +title: string,
+    +header: StackHeaderProps => React$Node,
+    +headerShown: boolean,
+    +cardShadowEnabled: boolean,
+    +cardOverlayEnabled: boolean,
+    +cardOverlay: {| style: ViewStyleProp |} => React$Node,
+    +cardStyle: ViewStyleProp,
+    +animationEnabled: boolean,
+    +animationTypeForReplace: 'push' | 'pop',
+    +gestureEnabled: boolean,
+    +gestureResponseDistance: {| vertical?: number, horizontal?: number |},
+    +gestureVelocityImpact: number,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    // Transition
+    ...TransitionPreset,
+    // Header
+    +headerTitle: string | (StackHeaderTitleInputProps => React$Node),
+    +headerTitleAlign: 'left' | 'center',
+    +headerTitleStyle: AnimatedTextStyleProp,
+    +headerTitleContainerStyle: ViewStyleProp,
+    +headerTintColor: string,
+    +headerTitleAllowFontScaling: boolean,
+    +headerBackAllowFontScaling: boolean,
+    +headerBackTitle: string | null,
+    +headerBackTitleStyle: TextStyleProp,
+    +headerBackTitleVisible: boolean,
+    +headerTruncatedBackTitle: string,
+    +headerLeft: StackHeaderLeftButtonProps => React$Node,
+    +headerLeftContainerStyle: ViewStyleProp,
+    +headerRight: {| tintColor?: string |} => React$Node,
+    +headerRightContainerStyle: ViewStyleProp,
+    +headerBackImage: $PropertyType<StackHeaderLeftButtonProps, 'backImage'>,
+    +headerPressColorAndroid: string,
+    +headerBackground: ({| style: ViewStyleProp |}) => React$Node,
+    +headerStyle: ViewStyleProp,
+    +headerTransparent: boolean,
+    +headerStatusBarHeight: number,
+  |}>;
+
+  /**
+   * Stack navigation prop
+   */
+
+  declare export type StackNavigationEventMap = {|
+    ...EventMapCore<StackNavigationState>,
+    +transitionStart: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +transitionEnd: {|
+      +data: {| +closing: boolean |},
+      +canPreventDefault: false,
+    |},
+    +gestureStart: {| +data: void, +canPreventDefault: false |},
+    +gestureEnd: {| +data: void, +canPreventDefault: false |},
+    +gestureCancel: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactStackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      StackNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +replace: SimpleNavigate<ParamList>,
+    +push: SimpleNavigate<ParamList>,
+    +pop: (count?: number) => void,
+    +popToTop: () => void,
+    ...
+  };
+
+  declare export type StackNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = StackOptions,
+    EventMap: EventMapBase = StackNavigationEventMap,
+  > = $Exact<InexactStackNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous stack exports
+   */
+
+  declare type StackNavigationConfig = {|
+    +mode?: 'card' | 'modal',
+    +headerMode?: 'float' | 'screen' | 'none',
+    +keyboardHandlingEnabled?: boolean,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraStackNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...StackRouterOptions,
+    ...StackNavigationConfig,
+  |};
+
+  declare export type StackNavigatorProps<
+    NavProp: InexactStackNavigationProp<> = StackNavigationProp<>,
+  > = {|
+    ...ExtraStackNavigatorProps,
+    ...ScreenOptionsProp<StackOptions, NavProp>,
+  |};
+
+  /**
+   * Bottom tab options
+   */
+
+  declare export type BottomTabBarButtonProps = {|
+    ...$Diff<
+      TouchableWithoutFeedbackProps,
+      {| onPress?: ?(event: PressEvent) => mixed |},
+    >,
+    +to?: string,
+    +children: React$Node,
+    +onPress?: (MouseEvent | PressEvent) => void,
+  |};
+
+  declare export type TabBarVisibilityAnimationConfig =
+    | {|
+        +animation: 'spring',
+        +config?: $Diff<
+          SpringAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |}
+    | {|
+        +animation: 'timing',
+        +config?: $Diff<
+          TimingAnimationConfigSingle,
+          { toValue: number | AnimatedValue, useNativeDriver: boolean, ... },
+        >,
+      |};
+
+  declare export type BottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| focused: boolean, color: string |}) => React$Node,
+    +tabBarIcon: ({|
+      focused: boolean,
+      color: string,
+      size: number,
+    |}) => React$Node,
+    +tabBarBadge: number | string,
+    +tabBarBadgeStyle: TextStyleProp,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+    +tabBarVisible: boolean,
+    +tabBarVisibilityAnimationConfig: Partial<{|
+      +show: TabBarVisibilityAnimationConfig,
+      +hide: TabBarVisibilityAnimationConfig,
+    |}>,
+    +tabBarButton: BottomTabBarButtonProps => React$Node,
+    +unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Bottom tab navigation prop
+   */
+
+  declare export type BottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare type InexactTabNavigationProp<
+    ParamList: ParamListBase,
+    RouteName: $Keys<ParamList>,
+    Options: {...},
+    EventMap: EventMapBase,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      TabNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    ...
+  };
+
+  declare export type InexactBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type BottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = BottomTabOptions,
+    EventMap: EventMapBase = BottomTabNavigationEventMap,
+  > = $Exact<InexactBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous bottom tab exports
+   */
+
+  declare export type BottomTabDescriptor = Descriptor<
+    BottomTabNavigationProp<>,
+    BottomTabOptions,
+  >;
+
+  declare export type BottomTabBarOptions = Partial<{|
+    +keyboardHidesTabBar: boolean,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveBackgroundColor: string,
+    +allowFontScaling: boolean,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +labelStyle: TextStyleProp,
+    +iconStyle: TextStyleProp,
+    +tabStyle: ViewStyleProp,
+    +labelPosition: 'beside-icon' | 'below-icon',
+    +adaptive: boolean,
+    +safeAreaInsets: Partial<EdgeInsets>,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type BottomTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: BottomTabNavigationProp<>,
+    +descriptors: {| +[key: string]: BottomTabDescriptor |},
+  |};
+
+  declare export type BottomTabBarProps = {|
+    ...BottomTabBarOptions,
+    ...BottomTabNavigationBuilderResult,
+  |}
+
+  declare type BottomTabNavigationConfig = {|
+    +lazy?: boolean,
+    +tabBar?: BottomTabBarProps => React$Node,
+    +tabBarOptions?: BottomTabBarOptions,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...BottomTabNavigationConfig,
+  |};
+
+  declare export type BottomTabNavigatorProps<
+    NavProp: InexactBottomTabNavigationProp<> = BottomTabNavigationProp<>,
+  > = {|
+    ...ExtraBottomTabNavigatorProps,
+    ...ScreenOptionsProp<BottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material bottom tab options
+   */
+
+  declare export type MaterialBottomTabOptions = Partial<{|
+    +title: string,
+    +tabBarColor: string,
+    +tabBarLabel: string,
+    +tabBarIcon:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarBadge: boolean | number | string,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material bottom tab navigation prop
+   */
+
+  declare export type MaterialBottomTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+  |};
+
+  declare export type InexactMaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialBottomTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialBottomTabOptions,
+    EventMap: EventMapBase = MaterialBottomTabNavigationEventMap,
+  > = $Exact<InexactMaterialBottomTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material bottom tab exports
+   */
+
+  declare export type PaperFont = {|
+    +fontFamily: string,
+    +fontWeight?:
+      | 'normal'
+      | 'bold'
+      | '100'
+      | '200'
+      | '300'
+      | '400'
+      | '500'
+      | '600'
+      | '700'
+      | '800'
+      | '900',
+  |};
+
+  declare export type PaperFonts = {|
+    +regular: PaperFont,
+    +medium: PaperFont,
+    +light: PaperFont,
+    +thin: PaperFont,
+  |};
+
+  declare export type PaperTheme = {|
+    +dark: boolean,
+    +mode?: 'adaptive' | 'exact',
+    +roundness: number,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +surface: string,
+      +accent: string,
+      +error: string,
+      +text: string,
+      +onSurface: string,
+      +onBackground: string,
+      +disabled: string,
+      +placeholder: string,
+      +backdrop: string,
+      +notification: string,
+    |},
+    +fonts: PaperFonts,
+    +animation: {|
+      +scale: number,
+    |},
+  |};
+
+  declare export type PaperRoute = {|
+    +key: string,
+    +title?: string,
+    +icon?: any,
+    +badge?: string | number | boolean,
+    +color?: string,
+    +accessibilityLabel?: string,
+    +testID?: string,
+  |};
+
+  declare export type PaperTouchableProps = {|
+    ...TouchableWithoutFeedbackProps,
+    +key: string,
+    +route: PaperRoute,
+    +children: React$Node,
+    +borderless?: boolean,
+    +centered?: boolean,
+    +rippleColor?: string,
+  |};
+
+  declare export type MaterialBottomTabNavigationConfig = {|
+    +shifting?: boolean,
+    +labeled?: boolean,
+    +renderTouchable?: PaperTouchableProps => React$Node,
+    +activeColor?: string,
+    +inactiveColor?: string,
+    +sceneAnimationEnabled?: boolean,
+    +keyboardHidesNavigationBar?: boolean,
+    +barStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +theme?: PaperTheme,
+  |};
+
+  declare export type ExtraMaterialBottomTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialBottomTabNavigationConfig,
+  |};
+
+  declare export type MaterialBottomTabNavigatorProps<
+    NavProp: InexactMaterialBottomTabNavigationProp<> =
+      MaterialBottomTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialBottomTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialBottomTabOptions, NavProp>,
+  |};
+
+  /**
+   * Material top tab options
+   */
+
+  declare export type MaterialTopTabOptions = Partial<{|
+    +title: string,
+    +tabBarLabel:
+      | string
+      | ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarIcon: ({| +focused: boolean, +color: string |}) => React$Node,
+    +tabBarAccessibilityLabel: string,
+    +tabBarTestID: string,
+  |}>;
+
+  /**
+   * Material top tab navigation prop
+   */
+
+  declare export type MaterialTopTabNavigationEventMap = {|
+    ...EventMapCore<TabNavigationState>,
+    +tabPress: {| +data: void, +canPreventDefault: true |},
+    +tabLongPress: {| +data: void, +canPreventDefault: false |},
+    +swipeStart: {| +data: void, +canPreventDefault: false |},
+    +swipeEnd: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactMaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = InexactTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >;
+
+  declare export type MaterialTopTabNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = MaterialTopTabOptions,
+    EventMap: EventMapBase = MaterialTopTabNavigationEventMap,
+  > = $Exact<InexactMaterialTopTabNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous material top tab exports
+   */
+
+  declare type MaterialTopTabPagerCommonProps = {|
+    +keyboardDismissMode: 'none' | 'on-drag' | 'auto',
+    +swipeEnabled: boolean,
+    +swipeVelocityImpact?: number,
+    +springVelocityScale?: number,
+    +springConfig: Partial<{|
+      +damping: number,
+      +mass: number,
+      +stiffness: number,
+      +restSpeedThreshold: number,
+      +restDisplacementThreshold: number,
+    |}>,
+    +timingConfig: Partial<{|
+      +duration: number,
+    |}>,
+  |};
+
+  declare export type MaterialTopTabPagerProps = {|
+    ...MaterialTopTabPagerCommonProps,
+    +onSwipeStart?: () => void,
+    +onSwipeEnd?: () => void,
+    +onIndexChange: (index: number) => void,
+    +navigationState: TabNavigationState,
+    +layout: {| +width: number, +height: number |},
+    +removeClippedSubviews: boolean,
+    +children: ({|
+      +addListener: (type: 'enter', listener: number => void) => void,
+      +removeListener: (type: 'enter', listener: number => void) => void,
+      +position: any, // Reanimated.Node<number>
+      +render: React$Node => React$Node,
+      +jumpTo: string => void,
+    |}) => React$Node,
+    +gestureHandlerProps: PanGestureHandlerProps,
+  |};
+
+  declare export type MaterialTopTabBarIndicatorProps = {|
+    +navigationState: TabNavigationState,
+    +width: string,
+    +style?: ViewStyleProp,
+    +getTabWidth: number => number,
+  |};
+
+  declare export type MaterialTopTabBarOptions = Partial<{|
+    +scrollEnabled: boolean,
+    +bounces: boolean,
+    +pressColor: string,
+    +pressOpacity: number,
+    +getAccessible: ({| +route: Route<> |}) => boolean,
+    +renderBadge: ({| +route: Route<> |}) => React$Node,
+    +renderIndicator: MaterialTopTabBarIndicatorProps => React$Node,
+    +tabStyle: ViewStyleProp,
+    +indicatorStyle: ViewStyleProp,
+    +indicatorContainerStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+    +activeTintColor: string,
+    +inactiveTintColor: string,
+    +iconStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+    +showLabel: boolean,
+    +showIcon: boolean,
+    +allowFontScaling: boolean,
+  |}>;
+
+  declare export type MaterialTopTabDescriptor = Descriptor<
+    MaterialBottomTabNavigationProp<>,
+    MaterialBottomTabOptions,
+  >;
+
+  declare type MaterialTopTabNavigationBuilderResult = {|
+    +state: TabNavigationState,
+    +navigation: MaterialTopTabNavigationProp<>,
+    +descriptors: {| +[key: string]: MaterialTopTabDescriptor |},
+  |};
+
+  declare export type MaterialTopTabBarProps = {|
+    ...MaterialTopTabBarOptions,
+    ...MaterialTopTabNavigationBuilderResult,
+    +layout: {| +width: number, +height: number |},
+    +position: any, // Reanimated.Node<number>
+    +jumpTo: string => void,
+  |};
+
+  declare export type MaterialTopTabNavigationConfig = {|
+    ...Partial<MaterialTopTabPagerCommonProps>,
+    +position?: any, // Reanimated.Value<number>
+    +tabBarPosition?: 'top' | 'bottom',
+    +initialLayout?: Partial<{| +width: number, +height: number |}>,
+    +lazy?: boolean,
+    +lazyPreloadDistance?: number,
+    +removeClippedSubviews?: boolean,
+    +sceneContainerStyle?: ViewStyleProp,
+    +style?: ViewStyleProp,
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +pager?: MaterialTopTabPagerProps => React$Node,
+    +lazyPlaceholder?: ({| +route: Route<> |}) => React$Node,
+    +tabBar?: MaterialTopTabBarProps => React$Node,
+    +tabBarOptions?: MaterialTopTabBarOptions,
+  |};
+
+  declare export type ExtraMaterialTopTabNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...TabRouterOptions,
+    ...MaterialTopTabNavigationConfig,
+  |};
+
+  declare export type MaterialTopTabNavigatorProps<
+    NavProp: InexactMaterialTopTabNavigationProp<> =
+      MaterialTopTabNavigationProp<>,
+  > = {|
+    ...ExtraMaterialTopTabNavigatorProps,
+    ...ScreenOptionsProp<MaterialTopTabOptions, NavProp>,
+  |};
+
+  /**
+   * Drawer options
+   */
+
+  declare export type DrawerOptions = Partial<{|
+    title: string,
+    drawerLabel:
+      | string
+      | ({| +color: string, +focused: boolean |}) => React$Node,
+    drawerIcon: ({|
+      +color: string,
+      +size: number,
+      +focused: boolean,
+    |}) => React$Node,
+    gestureEnabled: boolean,
+    swipeEnabled: boolean,
+    unmountOnBlur: boolean,
+  |}>;
+
+  /**
+   * Drawer navigation prop
+   */
+
+  declare export type DrawerNavigationEventMap = {|
+    ...EventMapCore<DrawerNavigationState>,
+    +drawerOpen: {| +data: void, +canPreventDefault: false |},
+    +drawerClose: {| +data: void, +canPreventDefault: false |},
+  |};
+
+  declare export type InexactDrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = {
+    ...$Exact<NavigationProp<
+      ParamList,
+      RouteName,
+      DrawerNavigationState,
+      Options,
+      EventMap,
+    >>,
+    +jumpTo: SimpleNavigate<ParamList>,
+    +openDrawer: () => void,
+    +closeDrawer: () => void,
+    +toggleDrawer: () => void,
+    ...
+  };
+
+  declare export type DrawerNavigationProp<
+    ParamList: ParamListBase = ParamListBase,
+    RouteName: $Keys<ParamList> = $Keys<ParamList>,
+    Options: {...} = DrawerOptions,
+    EventMap: EventMapBase = DrawerNavigationEventMap,
+  > = $Exact<InexactDrawerNavigationProp<
+    ParamList,
+    RouteName,
+    Options,
+    EventMap,
+  >>;
+
+  /**
+   * Miscellaneous drawer exports
+   */
+
+  declare export type DrawerDescriptor = Descriptor<
+    DrawerNavigationProp<>,
+    DrawerOptions,
+  >;
+
+  declare export type DrawerItemListBaseOptions = Partial<{|
+    +activeTintColor: string,
+    +activeBackgroundColor: string,
+    +inactiveTintColor: string,
+    +inactiveBackgroundColor: string,
+    +itemStyle: ViewStyleProp,
+    +labelStyle: TextStyleProp,
+  |}>;
+
+  declare export type DrawerContentOptions = Partial<{|
+    ...DrawerItemListBaseOptions,
+    +contentContainerStyle: ViewStyleProp,
+    +style: ViewStyleProp,
+  |}>;
+
+  declare type DrawerNavigationBuilderResult = {|
+    +state: DrawerNavigationState,
+    +navigation: DrawerNavigationProp<>,
+    +descriptors: {| +[key: string]: DrawerDescriptor |},
+  |};
+
+  declare export type DrawerContentProps = {|
+    ...DrawerContentOptions,
+    ...DrawerNavigationBuilderResult,
+    +progress: any, // Reanimated.Node<number>
+  |};
+
+  declare export type DrawerNavigationConfig = {|
+    +drawerPosition?: 'left' | 'right',
+    +drawerType?: 'front' | 'back' | 'slide' | 'permanent',
+    +edgeWidth?: number,
+    +hideStatusBar?: boolean,
+    +keyboardDismissMode?: 'on-drag' | 'none',
+    +minSwipeDistance?: number,
+    +overlayColor?: string,
+    +statusBarAnimation?: 'slide' | 'none' | 'fade',
+    +gestureHandlerProps?: PanGestureHandlerProps,
+    +lazy?: boolean,
+    +drawerContent?: DrawerContentProps => React$Node,
+    +drawerContentOptions?: DrawerContentOptions,
+    +sceneContainerStyle?: ViewStyleProp,
+    +drawerStyle?: ViewStyleProp,
+    +detachInactiveScreens?: boolean,
+  |};
+
+  declare export type ExtraDrawerNavigatorProps = {|
+    ...$Exact<ExtraNavigatorPropsBase>,
+    ...DrawerRouterOptions,
+    ...DrawerNavigationConfig,
+  |};
+
+  declare export type DrawerNavigatorProps<
+    NavProp: InexactDrawerNavigationProp<> = DrawerNavigationProp<>,
+  > = {|
+    ...ExtraDrawerNavigatorProps,
+    ...ScreenOptionsProp<DrawerOptions, NavProp>,
+  |};
+
+  /**
+   * BaseNavigationContainer
+   */
+
+  declare export type BaseNavigationContainerProps = {|
+    +children: React$Node,
+    +initialState?: PossiblyStaleNavigationState,
+    +onStateChange?: (state: ?PossiblyStaleNavigationState) => void,
+    +independent?: boolean,
+  |};
+
+  declare export type ContainerEventMap = {|
+    ...GlobalEventMap<PossiblyStaleNavigationState>,
+    +options: {|
+      +data: {| +options: { +[key: string]: mixed, ... } |},
+      +canPreventDefault: false,
+    |},
+    +__unsafe_action__: {|
+      +data: {|
+        +action: GenericNavigationAction,
+        +noop: boolean,
+      |},
+      +canPreventDefault: false,
+    |},
+  |};
+
+  declare export type BaseNavigationContainerInterface = {|
+    ...$Exact<NavigationHelpers<
+      ParamListBase,
+      PossiblyStaleNavigationState,
+      ContainerEventMap,
+    >>,
+    +setParams: (params: ScreenParams) => void,
+    +resetRoot: (state?: ?PossiblyStaleNavigationState) => void,
+    +getRootState: () => PossiblyStaleNavigationState,
+  |};
+
+  /**
+   * State utils
+   */
+
+  declare export type GetStateFromPath = (
+    path: string,
+    options?: LinkingConfig,
+  ) => PossiblyStaleNavigationState;
+
+  declare export type GetPathFromState = (
+    state?: ?PossiblyStaleNavigationState,
+    options?: LinkingConfig,
+  ) => string;
+
+  declare export type GetFocusedRouteNameFromRoute =
+    PossiblyStaleRoute<string> => ?string;
+
+  /**
+   * Linking
+   */
+
+  declare export type ScreenLinkingConfig = {|
+    +path?: string,
+    +exact?: boolean,
+    +parse?: {| +[param: string]: string => mixed |},
+    +stringify?: {| +[param: string]: mixed => string |},
+    +screens?: ScreenLinkingConfigMap,
+    +initialRouteName?: string,
+  |};
+
+  declare export type ScreenLinkingConfigMap = {|
+    +[routeName: string]: string | ScreenLinkingConfig,
+  |};
+
+  declare export type LinkingConfig = {|
+    +initialRouteName?: string,
+    +screens: ScreenLinkingConfigMap,
+  |};
+
+  declare export type LinkingOptions = {|
+    +enabled?: boolean,
+    +prefixes: $ReadOnlyArray<string>,
+    +config?: LinkingConfig,
+    +getStateFromPath?: GetStateFromPath,
+    +getPathFromState?: GetPathFromState,
+  |};
+
+  /**
+   * NavigationContainer
+   */
+
+  declare export type Theme = {|
+    +dark: boolean,
+    +colors: {|
+      +primary: string,
+      +background: string,
+      +card: string,
+      +text: string,
+      +border: string,
+    |},
+  |};
+
+  declare export type NavigationContainerType = React$AbstractComponent<
+    {|
+      ...BaseNavigationContainerProps,
+      +theme?: Theme,
+      +linking?: LinkingOptions,
+      +fallback?: React$Node,
+      +onReady?: () => mixed,
+    |},
+    BaseNavigationContainerInterface,
+  >;
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: EXPORTED MODULE
+  // This section defines the module exports and contains exported types that
+  // are not present in any other React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * StackView
+   */
+
+  declare export var StackView: React$ComponentType<{|
+    ...StackNavigationConfig,
+    +state: StackNavigationState,
+    +navigation: StackNavigationProp<>,
+    +descriptors: {| +[key: string]: StackDescriptor |},
+  |}>;
+
+  /**
+   * createStackNavigator
+   */
+
+  declare export var createStackNavigator: CreateNavigator<
+    StackNavigationState,
+    StackOptions,
+    StackNavigationEventMap,
+    ExtraStackNavigatorProps,
+  >;
+
+  /**
+   * Header components
+   */
+
+  declare export var Header: React$ComponentType<StackHeaderProps>;
+
+  declare export type StackHeaderTitleProps = Partial<StackHeaderTitleInputBase>;
+  declare export var HeaderTitle: React$ComponentType<StackHeaderTitleProps>;
+
+  declare export type HeaderBackButtonProps = Partial<{|
+    ...StackHeaderLeftButtonProps,
+    +disabled: boolean,
+    +accessibilityLabel: string,
+  |}>;
+  declare export var HeaderBackButton: React$ComponentType<
+    HeaderBackButtonProps,
+  >;
+
+  declare export type HeaderBackgroundProps = Partial<{
+    +children: React$Node,
+    +style: AnimatedViewStyleProp,
+    ...
+  }>;
+  declare export var HeaderBackground: React$ComponentType<
+    HeaderBackgroundProps,
+  >;
+
+  /**
+   * Style/animation options
+   */
+
+  declare export var CardStyleInterpolators: {|
+    +forHorizontalIOS: StackCardStyleInterpolator,
+    +forVerticalIOS: StackCardStyleInterpolator,
+    +forModalPresentationIOS: StackCardStyleInterpolator,
+    +forFadeFromBottomAndroid: StackCardStyleInterpolator,
+    +forRevealFromBottomAndroid: StackCardStyleInterpolator,
+    +forScaleFromCenterAndroid: StackCardStyleInterpolator,
+    +forNoAnimation: StackCardStyleInterpolator,
+  |};
+  declare export var HeaderStyleInterpolators: {|
+    +forUIKit: StackHeaderStyleInterpolator,
+    +forFade: StackHeaderStyleInterpolator,
+    +forSlideLeft: StackHeaderStyleInterpolator,
+    +forSlideRight: StackHeaderStyleInterpolator,
+    +forSlideUp: StackHeaderStyleInterpolator,
+    +forNoAnimation: StackHeaderStyleInterpolator,
+  |};
+  declare export var TransitionSpecs: {|
+    +TransitionIOSSpec: TransitionSpec,
+    +FadeInFromBottomAndroidSpec: TransitionSpec,
+    +FadeOutToBottomAndroidSpec: TransitionSpec,
+    +RevealFromBottomAndroidSpec: TransitionSpec,
+    +ScaleFromCenterAndroidSpec: TransitionSpec,
+  |};
+  declare export var TransitionPresets: {|
+    +SlideFromRightIOS: TransitionPreset,
+    +ModalSlideFromBottomIOS: TransitionPreset,
+    +ModalPresentationIOS: TransitionPreset,
+    +FadeFromBottomAndroid: TransitionPreset,
+    +RevealFromBottomAndroid: TransitionPreset,
+    +ScaleFromCenterAndroid: TransitionPreset,
+    +DefaultTransition: TransitionPreset,
+    +ModalTransition: TransitionPreset,
+  |};
+
+  /**
+   * Image assets
+   */
+
+  declare export var Assets: $ReadOnlyArray<ImageURISource>;
+
+  /**
+   * CardAnimation accessors
+   */
+
+  declare export var CardAnimationContext: React$Context<
+    ?StackCardInterpolationProps,
+  >;
+  declare export function useCardAnimation(): StackCardInterpolationProps
+
+  /**
+   * HeaderHeight accessors
+   */
+
+  declare export var HeaderHeightContext: React$Context<?number>;
+  declare export function useHeaderHeight(): number;
+
+  /**
+   * GestureHandler accessors
+   */
+
+  declare type GestureHandlerRef = React$Ref<
+    React$ComponentType<PanGestureHandlerProps>,
+  >;
+  declare export var GestureHandlerRefContext: React$Context<
+    ?GestureHandlerRef,
+  >;
+  declare export function useGestureHandlerRef(): GestureHandlerRef;
+
+}
diff --git a/definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.104.x-/addon-a11y_v3.x.x.js b/definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.104.x-v.200.x/addon-a11y_v3.x.x.js
similarity index 100%
rename from definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.104.x-/addon-a11y_v3.x.x.js
rename to definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.104.x-v.200.x/addon-a11y_v3.x.x.js
diff --git a/definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.201.x-/addon-a11y_v3.x.x.js b/definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.201.x-/addon-a11y_v3.x.x.js
new file mode 100644
index 0000000000..32e97b3e7a
--- /dev/null
+++ b/definitions/npm/@storybook/addon-a11y_v3.x.x/flow_v0.201.x-/addon-a11y_v3.x.x.js
@@ -0,0 +1,54 @@
+declare module '@storybook/addon-a11y' {
+  declare type Context = {
+    kind: string,
+    story: string,
+    ...
+  };
+  declare type Renderable = React$Element<any>;
+  declare type RenderFunction = () => Renderable | Array<Renderable>;
+
+  declare type StoryDecorator = (
+    story: RenderFunction,
+    context: Context
+  ) => Renderable | null;
+
+  declare type AxeCheck = {
+    id: string,
+    evaluate: (options: mixed) => void,
+    after?: () => void,
+    options?: mixed,
+    enabled?: boolean,
+    ...
+  };
+
+  declare type AxeOptions = {
+    branding?: {
+      brand?: string,
+      application?: string,
+      ...
+    },
+    reporter?: 'v1' | 'v2',
+    checks?: Array<AxeCheck>,
+    rules?: Array<{
+      id: string,
+      selector?: string,
+      excludeHidden?: boolean,
+      enabled?: boolean,
+      pageLevel?: boolean,
+      any?: Array<AxeCheck>,
+      all?: Array<AxeCheck>,
+      none?: Array<AxeCheck>,
+      tags?: Array<string>,
+      matches?: string,
+      ...
+    }>,
+    disableOtherRules?: boolean,
+    ...
+  };
+
+  declare module.exports: {
+    checkA11y: StoryDecorator,
+    configureA11y: (options?: AxeOptions) => void,
+    ...
+  };
+}
diff --git a/definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.104.x-/addon-knobs_v3.x.x.js b/definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.104.x-v.200.x/addon-knobs_v3.x.x.js
similarity index 100%
rename from definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.104.x-/addon-knobs_v3.x.x.js
rename to definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.104.x-v.200.x/addon-knobs_v3.x.x.js
diff --git a/definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.201.x-/addon-knobs_v3.x.x.js b/definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.201.x-/addon-knobs_v3.x.x.js
new file mode 100644
index 0000000000..11f73ed4a5
--- /dev/null
+++ b/definitions/npm/@storybook/addon-knobs_v3.x.x/flow_v0.201.x-/addon-knobs_v3.x.x.js
@@ -0,0 +1,31 @@
+declare module "@storybook/addon-knobs/react" {
+  declare type Context = {
+    kind: string,
+    story: string,
+    ...
+  };
+  declare type Renderable = React$Element<any>;
+  declare type RenderFunction = () => Renderable | Array<Renderable>;
+  declare type GroupId = string;
+
+  declare function array<T>(string, (Array<T> | { [string]: T, ... }), ?string, ?GroupId): Array<T>;
+  declare function boolean(string, boolean, ?GroupId): boolean;
+  declare function button(string, ((?{...}) => void), ?GroupId): void;
+  declare function color(string, string, ?GroupId): string;
+  declare function date(string, Date, ?GroupId): number;
+  declare function number(string, number, ?{
+    range?: boolean,
+    min?: number,
+    max?: number,
+    step?: number,
+    ...
+  }, ?GroupId): number;
+  declare function object(string, any, ?GroupId): any;
+  declare function select<T>(string, Array<T> | { [T]: string, ... }, T, ?GroupId): T;
+  declare function selectV2<T>(string, Array<T> | { [string]: T, ... }, T, ?GroupId): T;
+  declare function text(string, string, ?GroupId): string;
+  declare function withKnobs(
+    story: RenderFunction,
+    context: Context
+  ): Renderable | null;
+}
diff --git a/definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-/react_v10.x.x.js b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-v.200.x/react_v10.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-/react_v10.x.x.js
rename to definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-v.200.x/react_v10.x.x.js
diff --git a/definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-/test_react_v10.x.x.js b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-v.200.x/test_react_v10.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-/test_react_v10.x.x.js
rename to definitions/npm/@testing-library/react_v10.x.x/flow_v0.104.x-v.200.x/test_react_v10.x.x.js
diff --git a/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/react_v10.x.x.js b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/react_v10.x.x.js
new file mode 100644
index 0000000000..7afc86f728
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/react_v10.x.x.js
@@ -0,0 +1,448 @@
+declare module '@testing-library/react' {
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type WaitForElementOptions = {|
+    container?: HTMLElement,
+    timeout?: number,
+    mutationObserverOptions?: MutationObserverInit,
+  |};
+
+  declare type TextMatch =
+    | string
+    | RegExp
+    | ((content: string, element: HTMLElement) => boolean);
+
+  declare type TextMatchOptions = {
+    exact?: boolean,
+    trim?: boolean,
+    collapseWhitespace?: boolean,
+    normalizer?: (text: string) => string,
+    ...
+  };
+
+  declare type SelectorMatchOptions = {
+    selector?: string,
+    ...
+  } & TextMatchOptions;
+
+  declare type QueryByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type FindAllByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement[]>;
+
+  declare type GetByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => HTMLElement;
+
+  declare type FindByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement>;
+
+  declare type QueryByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type FindAllByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement[]>;
+
+  declare type GetByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => HTMLElement;
+
+  declare type FindByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement>;
+
+  declare type ByRoleOptions = {
+    /**
+     * If true includes elements in the query set that are usually excluded from
+     * the accessibility tree. `role="none"` or `role="presentation"` are included
+     * in either case.
+     * @default false
+     */
+    hidden?: boolean,
+    /**
+     * Includes every role used in the `role` attribute
+     * For example *ByRole('progressbar', {queryFallbacks: true})` will find <div role="meter progresbar">`.
+     */
+    queryFallbacks?: boolean,
+    /**
+     * Only considers  elements with the specified accessible name.
+     */
+    name?:
+      | string
+      | RegExp
+      | ((accessibleName: string, element: Element) => boolean),
+    ...
+  } & TextMatchOptions;
+
+  declare type AllByRole = (
+    role: TextMatch,
+    options?: ByRoleOptions
+  ) => HTMLElement[];
+
+  declare type GetByRole = (
+    role: TextMatch,
+    options?: ByRoleOptions
+  ) => HTMLElement;
+
+  declare type QueryByRole = (
+    role: TextMatch,
+    options?: ByRoleOptions
+  ) => HTMLElement | null;
+
+  declare type FindByRole = (
+    role: TextMatch,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement>;
+
+  declare type FindAllByRole = (
+    role: any,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForElementOptions
+  ) => Promise<HTMLElement[]>;
+
+  declare type GetsAndQueries = {|
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+    findByLabelText: FindByText,
+    findAllByLabelText: FindAllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+    findByPlaceholderText: FindByBoundAttribute,
+    findAllByPlaceholderText: FindAllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+    findByText: FindByText,
+    findAllByText: FindAllByText,
+
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+    findByAltText: FindByBoundAttribute,
+    findAllByAltText: FindAllByBoundAttribute,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+    findByTitle: FindByBoundAttribute,
+    findAllByTitle: FindAllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+    findByDisplayValue: FindByBoundAttribute,
+    findAllByDisplayValue: FindAllByBoundAttribute,
+
+    getByRole: GetByRole,
+    getAllByRole: AllByRole,
+    queryByRole: QueryByRole,
+    queryAllByRole: AllByRole,
+    findByRole: FindByRole,
+    findAllByRole: FindAllByRole,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+    findByTestId: FindByBoundAttribute,
+    findAllByTestId: FindAllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: HTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type Screen<Queries = GetsAndQueries> = {
+    ...Queries,
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number
+    ) => void,
+    ...
+  };
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLElement,
+    unmount: () => boolean,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number
+    ) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptionsWithoutCustomQueries = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export type RenderOptionsWithCustomQueries<
+    CustomQueries: { ... }
+  > = {|
+    queries: CustomQueries,
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: RenderOptionsWithoutCustomQueries
+  ): RenderResult<>;
+  declare export function render<
+    CustomQueries: { [string]: (...args: Array<any>) => any, ... }
+  >(
+    ui: React$Element<any>,
+    options: RenderOptionsWithCustomQueries<CustomQueries>
+  ): RenderResult<CustomQueries>;
+
+  declare export var act: ReactDOMTestUtilsAct;
+  declare export function cleanup(): Promise<void>;
+
+  declare export function waitFor<T>(
+    callback: () => T,
+    options?: {|
+      container?: HTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function waitForElementToBeRemoved<T>(
+    callback: (() => T) | T,
+    options?: {|
+      container?: HTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  /* Deprecated */
+  declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    }
+  ): Promise<void>;
+
+  /* Deprecated */
+  declare export function waitForDomChange<T>(options?: {
+    container?: HTMLElement,
+    timeout?: number,
+    mutationObserverOptions?: MutationObserverInit,
+    ...
+  }): Promise<T>;
+
+  /* Deprecated */
+  declare export function waitForElement<T>(
+    callback?: () => T,
+    options?: {
+      container?: HTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    }
+  ): Promise<T>;
+
+  declare export function within(
+    element: HTMLElement,
+    queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+  ): GetsAndQueries;
+
+  declare export var fireEvent: {|
+    (element: HTMLElement, event: Event): void,
+
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+  |};
+  // dom-testing-library re-declares
+  declare export function queryByTestId(
+    container: HTMLElement,
+    id: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByTestId(
+    container: HTMLElement,
+    id: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+  declare export function getAllByTestId(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): Array<HTMLElement>;
+  declare export function queryByText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: { selector?: string, ... } & TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByPlaceholderText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByPlaceholderText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByLabelText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByLabelText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: { selector?: string, ... } & TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByAltText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByAltText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+  declare export function getNodeText(node: HTMLElement): string;
+  declare export var screen: Screen<>;
+}
diff --git a/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/test_react_v10.x.x.js b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/test_react_v10.x.x.js
new file mode 100644
index 0000000000..1cb2c721e7
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v10.x.x/flow_v0.201.x-/test_react_v10.x.x.js
@@ -0,0 +1,1319 @@
+// @flow
+
+import React from 'react';
+import {
+  act,
+  render,
+  fireEvent,
+  cleanup,
+  waitFor,
+  waitForDomChange,
+  waitForElement,
+  waitForElementToBeRemoved,
+  within,
+  screen,
+  getNodeText,
+  getAllByTestId,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: resolve => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(() => {}, () => {});
+  });
+});
+
+describe('waitFor', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitFor(1);
+    // $FlowExpectedError[incompatible-call]
+    waitFor(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitFor(() => {});
+    waitFor(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForDomChange', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange('1');
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForDomChange({ container: document.createElement('div') });
+    waitForDomChange({ timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async n => {
+    const usernameElement = await waitForElement(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('waitForElementToBeRemoved', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElementToBeRemoved(() => {}, 1);
+  });
+
+  it('should pass on correct inputs (callback)', () => {
+    waitForElementToBeRemoved(() => document.createElement('div'));
+    waitForElementToBeRemoved(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should pass on correct inputs (node)', () => {
+    waitForElementToBeRemoved(document.createElement('div'));
+    waitForElementToBeRemoved(document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async n => {
+    const usernameElement = await waitForElementToBeRemoved(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByAltText('1');
+    const b: Array<HTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByAltText('1');
+    const b: Array<HTMLElement> = queryAllByAltText('2');
+  });
+
+  it('findByAltText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByAltText('1');
+    const b: Promise<HTMLElement> = findByAltText('1');
+  });
+
+  it('findAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByAltText('1');
+    const b: Promise<Array<HTMLElement>> = findAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: HTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByDisplayValue('1');
+    const b: Array<HTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByDisplayValue('1');
+    const b: ?HTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByDisplayValue('1');
+    const b: Array<HTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('findByDisplayValue should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByDisplayValue('1');
+    const b: Promise<HTMLElement> = findByDisplayValue('1');
+  });
+
+  it('findAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByDisplayValue('1');
+    const b: Promise<Array<HTMLElement>> = findAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByLabelText('1');
+    const b: Array<HTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByLabelText('1');
+    const b: Array<HTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('findByLabelText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByLabelText('1');
+    const b: Promise<HTMLElement> = findByLabelText('1');
+  });
+
+  it('findAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByLabelText('1');
+    const b: Promise<Array<HTMLElement>> = findAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('findByPlaceholderText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByPlaceholderText('1');
+    const b: Promise<HTMLElement> = findByPlaceholderText('1');
+  });
+
+  it('findAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByPlaceholderText('1');
+    const b: Promise<Array<HTMLElement>> = findAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: string = getByRole('1');
+    const b: HTMLElement = getByRole('1');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByRole('1');
+    const b: Array<HTMLElement> = getAllByRole('2');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByRole('1');
+    const b: ?HTMLElement = queryByRole('2');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByRole('1');
+    const b: Array<HTMLElement> = queryAllByRole('2');
+  });
+
+  it('findByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByRole('1');
+    const b: Promise<HTMLElement> = findByRole('1');
+  });
+
+  it('findAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByRole('1');
+    const b: Promise<Array<HTMLElement>> = findAllByRole('2');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTestId('1');
+    const b: Array<HTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTestId('1');
+    const b: Array<HTMLElement> = queryAllByTestId('2');
+  });
+
+  it('findByTestId should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByTestId('1');
+    const b: Promise<HTMLElement> = findByTestId('1');
+  });
+
+  it('findAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findAllByTestId('1');
+    const b: Promise<Array<HTMLElement>> = findAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByText('1');
+    const b: Array<HTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByText('1');
+    const b: Array<HTMLElement> = queryAllByText('2');
+  });
+
+  it('findByText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByText('1');
+    const b: Promise<HTMLElement> = findByText('1');
+  });
+
+  it('findAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<HTMLElement> = findAllByText('1');
+    const b: Promise<Array<HTMLElement>> = findAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: HTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTitle('1');
+    const b: Array<HTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTitle('1');
+    const b: ?HTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTitle('1');
+    const b: Array<HTMLElement> = queryAllByTitle('2');
+  });
+
+  it('findByTitle should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findByTitle('1');
+    const b: Promise<HTMLElement> = findByTitle('1');
+  });
+
+  it('findAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = findAllByTitle('1');
+    const b: Promise<Array<HTMLElement>> = findAllByTitle('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have findByAltText', async () => {
+    await within(container).findByAltText('1');
+  });
+
+  it('should have findAllByAltText', async () => {
+    await within(container).findAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have findByLabelText', async () => {
+    await within(container).findByLabelText('1');
+  });
+
+  it('should have findAllByLabelText', async () => {
+    await within(container).findAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have findByPlaceholderText', async () => {
+    await within(container).findByPlaceholderText('1');
+  });
+
+  it('should have findAllByPlaceholderText', async () => {
+    await within(container).findAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('1');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('1');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('1');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('1');
+  });
+
+  it('should have findByRole', async () => {
+    await within(container).findByRole('1');
+  });
+
+  it('should have findAllByRole', async () => {
+    await within(container).findAllByRole('1');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have findByTestId', async () => {
+    await within(container).findByTestId('1');
+  });
+
+  it('should have findAllByTestId', async () => {
+    await within(container).findAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have findByText', async () => {
+    await within(container).findByText('1');
+  });
+
+  it('should have findAllByText', async () => {
+    await within(container).findAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have findByTitle', async () => {
+    await within(container).findByTitle('1');
+  });
+
+  it('should have findAllByTitle', async () => {
+    await within(container).findAllByTitle('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+});
+
+describe('screen', () => {
+  it('should have all the queries available', () => {
+    // $FlowExpectedError[prop-missing]
+    const { notAQuery } = screen;
+    const {
+      debug,
+      getByAltText,
+      getAllByAltText,
+      queryByAltText,
+      queryAllByAltText,
+      findByAltText,
+      findAllByAltText,
+      getByDisplayValue,
+      getAllByDisplayValue,
+      queryByDisplayValue,
+      queryAllByDisplayValue,
+      findByDisplayValue,
+      findAllByDisplayValue,
+      getByLabelText,
+      getAllByLabelText,
+      queryByLabelText,
+      queryAllByLabelText,
+      findByLabelText,
+      findAllByLabelText,
+      getByPlaceholderText,
+      getAllByPlaceholderText,
+      queryByPlaceholderText,
+      queryAllByPlaceholderText,
+      findByPlaceholderText,
+      findAllByPlaceholderText,
+      getByRole,
+      getAllByRole,
+      queryByRole,
+      queryAllByRole,
+      findByRole,
+      findAllByRole,
+      getByTestId,
+      getAllByTestId,
+      queryByTestId,
+      queryAllByTestId,
+      findByTestId,
+      findAllByTestId,
+      getByText,
+      getAllByText,
+      queryByText,
+      queryAllByText,
+      findByText,
+      findAllByText,
+      getByTitle,
+      getAllByTitle,
+      queryByTitle,
+      queryAllByTitle,
+      findByTitle,
+      findAllByTitle,
+    } = screen;
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('getNodeText', () => {
+  class Component extends React.Component<{ ... }> {};
+  const { container } = render(<Component />);
+
+  it('should return string', () => {
+    const a: string = getNodeText(container);
+  });
+});
+
+describe('getAllByTestId', () => {
+  class Component extends React.Component<{ ... }> {};
+  const { container } = render(<Component />);
+
+  it('should return array of html elements', () => {
+    const a: Array<HTMLElement> = getAllByTestId(container, 'test');
+  });
+
+  it('optionally takes options', () => {
+    getAllByTestId(container, 'test', { ...null });
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept text match arguments', () => {
+    getByRole('1');
+    getByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByRole(/1/);
+    getByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByRole('1');
+  });
+
+  it('queryByRole should accept text match arguments', () => {
+    queryByRole('1');
+    queryByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole(/1/);
+    queryByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByRole('1');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTitle('1');
+  });
+});
+
+describe('render() parameters', () => {
+  class Component extends React.Component<{ ... }> {}
+
+  it('allows supplying parameters to render()', () => {
+    class CustomWrapper extends React.Component<{ ... }> {}
+    const element = document.createElement('div');
+    render(<Component />, {
+      baseElement: element,
+      container: element,
+      hydrate: true,
+      wrapper: CustomWrapper,
+    });
+  });
+
+  it('allows overriding render() with custom queries', () => {
+    type CustomReturnType = 123456;
+    declare var customValue: CustomReturnType;
+    const customQueries = {
+      getByOverride: (param1: string) => customValue,
+    };
+    const result = render<{|
+      getByOverride: (string) => CustomReturnType,
+    |}>(<Component />, { queries: customQueries });
+    const a: CustomReturnType = result.getByOverride('something');
+    // $FlowExpectedError[incompatible-call] bad type for getByOverride parameter
+    result.getByOverride(1234);
+    // $FlowExpectedError[incompatible-call] missing getByOverride parameter
+    result.getByOverride();
+    // $FlowExpectedError[prop-missing] default queries are not available when using custom queries
+    result.getByTestId('indifferent');
+  });
+});
diff --git a/definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-/react_v11.x.x.js b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-v.200.x/react_v11.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-/react_v11.x.x.js
rename to definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-v.200.x/react_v11.x.x.js
diff --git a/definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-/test_react_v11.x.x.js b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-v.200.x/test_react_v11.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-/test_react_v11.x.x.js
rename to definitions/npm/@testing-library/react_v11.x.x/flow_v0.104.x-v.200.x/test_react_v11.x.x.js
diff --git a/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/react_v11.x.x.js b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/react_v11.x.x.js
new file mode 100644
index 0000000000..49fec27ec7
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/react_v11.x.x.js
@@ -0,0 +1,681 @@
+/**
+ * A local copy from:
+ * https://github.com/A11yance/aria-query/blob/2e6a3011a0d8987655f3a14853934fe3df38a8d8/flow/aria.js
+ */
+ declare module '@@aria-query' {
+  declare export type ARIAAbstractRole =
+    | 'command'
+    | 'composite'
+    | 'input'
+    | 'landmark'
+    | 'range'
+    | 'roletype'
+    | 'section'
+    | 'sectionhead'
+    | 'select'
+    | 'structure'
+    | 'widget'
+    | 'window';
+
+  declare export type ARIAWidgetRole =
+    | 'button'
+    | 'checkbox'
+    | 'gridcell'
+    | 'link'
+    | 'menuitem'
+    | 'menuitemcheckbox'
+    | 'menuitemradio'
+    | 'option'
+    | 'progressbar'
+    | 'radio'
+    | 'scrollbar'
+    | 'searchbox'
+    | 'slider'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tabpanel'
+    | 'textbox'
+    | 'treeitem';
+
+  declare export type ARIACompositeWidgetRole =
+    | 'combobox'
+    | 'grid'
+    | 'listbox'
+    | 'menu'
+    | 'menubar'
+    | 'radiogroup'
+    | 'tablist'
+    | 'tree'
+    | 'treegrid';
+
+  declare export type ARIADocumentStructureRole =
+    | 'application'
+    | 'article'
+    | 'blockquote'
+    | 'caption'
+    | 'cell'
+    | 'columnheader'
+    | 'definition'
+    | 'deletion'
+    | 'directory'
+    | 'document'
+    | 'emphasis'
+    | 'feed'
+    | 'figure'
+    | 'generic'
+    | 'group'
+    | 'heading'
+    | 'img'
+    | 'insertion'
+    | 'list'
+    | 'listitem'
+    | 'math'
+    | 'meter'
+    | 'none'
+    | 'note'
+    | 'paragraph'
+    | 'presentation'
+    | 'row'
+    | 'rowgroup'
+    | 'rowheader'
+    | 'separator'
+    | 'strong'
+    | 'subscript'
+    | 'superscript'
+    | 'table'
+    | 'term'
+    | 'time'
+    | 'toolbar'
+    | 'tooltip';
+
+  declare export type ARIALandmarkRole =
+    | 'banner'
+    | 'complementary'
+    | 'contentinfo'
+    | 'form'
+    | 'main'
+    | 'navigation'
+    | 'region'
+    | 'search';
+
+  declare export type ARIALiveRegionRole =
+    | 'alert'
+    | 'log'
+    | 'marquee'
+    | 'status'
+    | 'timer';
+
+  declare export type ARIAWindowRole = 'alertdialog' | 'dialog';
+
+  declare export type ARIAUncategorizedRole = 'code';
+
+  declare export type ARIADPubRole =
+    | 'doc-abstract'
+    | 'doc-acknowledgments'
+    | 'doc-afterword'
+    | 'doc-appendix'
+    | 'doc-backlink'
+    | 'doc-biblioentry'
+    | 'doc-bibliography'
+    | 'doc-biblioref'
+    | 'doc-chapter'
+    | 'doc-colophon'
+    | 'doc-conclusion'
+    | 'doc-cover'
+    | 'doc-credit'
+    | 'doc-credits'
+    | 'doc-dedication'
+    | 'doc-endnote'
+    | 'doc-endnotes'
+    | 'doc-epigraph'
+    | 'doc-epilogue'
+    | 'doc-errata'
+    | 'doc-example'
+    | 'doc-footnote'
+    | 'doc-foreword'
+    | 'doc-glossary'
+    | 'doc-glossref'
+    | 'doc-index'
+    | 'doc-introduction'
+    | 'doc-noteref'
+    | 'doc-notice'
+    | 'doc-pagebreak'
+    | 'doc-pagelist'
+    | 'doc-part'
+    | 'doc-preface'
+    | 'doc-prologue'
+    | 'doc-pullquote'
+    | 'doc-qna'
+    | 'doc-subtitle'
+    | 'doc-tip'
+    | 'doc-toc';
+
+  declare export type ARIARole =
+    | ARIAWidgetRole
+    | ARIACompositeWidgetRole
+    | ARIADocumentStructureRole
+    | ARIALandmarkRole
+    | ARIALiveRegionRole
+    | ARIAWindowRole
+    | ARIAUncategorizedRole;
+}
+
+declare module '@testing-library/react' {
+  import type { ARIARole } from '@@aria-query';
+
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type WaitForOptions = {|
+    container?: HTMLElement,
+    timeout?: number,
+    interval?: number,
+    onTimeout?: (error: Error) => Error,
+    mutationObserverOptions?: MutationObserverInit,
+  |};
+
+  declare type MatcherFunction = (
+    content: string,
+    element: ?Element
+  ) => boolean;
+
+  declare type Matcher = MatcherFunction | RegExp | string | number;
+
+  declare type ByRoleMatcher = ARIARole | MatcherFunction;
+
+  declare type NormalizerFn = (text: string) => string;
+
+  declare type MatcherOptions = {|
+    exact?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    trim?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    collapseWhitespace?: boolean,
+    normalizer?: NormalizerFn,
+    /** suppress suggestions for a specific query */
+    suggest?: boolean,
+  |};
+
+  declare type ByRoleOptions = {|
+    ...MatcherOptions,
+    /**
+     * If true includes elements in the query set that are usually excluded from
+     * the accessibility tree. `role="none"` or `role="presentation"` are included
+     * in either case.
+     */
+    hidden?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * selected in the accessibility tree, i.e., `aria-selected="true"`
+     */
+    selected?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * checked in the accessibility tree, i.e., `aria-checked="true"`
+     */
+    checked?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * pressed in the accessibility tree, i.e., `aria-pressed="true"`
+     */
+    pressed?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * expanded in the accessibility tree, i.e., `aria-expanded="true"`
+     */
+    expanded?: boolean,
+    /**
+     * Includes elements with the `"heading"` role matching the indicated level,
+     * either by the semantic HTML heading elements `<h1>-<h6>` or matching
+     * the `aria-level` attribute.
+     */
+    level?: number,
+    /**
+     * Includes every role used in the `role` attribute
+     * For example *ByRole('progressbar', {queryFallbacks: true})` will find <div role="meter progressbar">`.
+     */
+    queryFallbacks?: boolean,
+    /**
+     * Only considers  elements with the specified accessible name.
+     */
+    name?:
+      | string
+      | RegExp
+      | ((accessibleName: string, element: Element) => boolean),
+  |};
+
+  declare type SelectorMatcherOptions = {|
+    ...MatcherOptions,
+    selector?: string,
+  |};
+
+  // These two types must be updated kept in sync
+  declare export type UnionHTMLElement =
+    | HTMLElement
+    | HTMLInputElement
+    | HTMLAnchorElement
+    | HTMLButtonElement
+    | HTMLSelectElement;
+
+  declare export type IntersectionHTMLElement =
+    & HTMLElement
+    & HTMLInputElement
+    & HTMLAnchorElement
+    & HTMLButtonElement
+    & HTMLSelectElement;
+  // End mixed html types
+
+  declare type QueryByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => ?IntersectionHTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type QueryByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => ?IntersectionHTMLElement;
+
+  declare type AllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type AllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement[];
+
+  declare type GetByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement;
+
+  declare type QueryByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement | null;
+
+  declare type FindByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type FindAllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetsAndQueries = {|
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+    findByLabelText: FindByText,
+    findAllByLabelText: FindAllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+    findByPlaceholderText: FindByBoundAttribute,
+    findAllByPlaceholderText: FindAllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+    findByText: FindByText,
+    findAllByText: FindAllByText,
+
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+    findByAltText: FindByBoundAttribute,
+    findAllByAltText: FindAllByBoundAttribute,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+    findByTitle: FindByBoundAttribute,
+    findAllByTitle: FindAllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+    findByDisplayValue: FindByBoundAttribute,
+    findAllByDisplayValue: FindAllByBoundAttribute,
+
+    getByRole: GetByRole,
+    getAllByRole: AllByRole,
+    queryByRole: QueryByRole,
+    queryAllByRole: AllByRole,
+    findByRole: FindByRole,
+    findAllByRole: FindAllByRole,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+    findByTestId: FindByBoundAttribute,
+    findAllByTestId: FindAllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: UnionHTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type Screen<Queries = GetsAndQueries> = {
+    ...Queries,
+    /**
+     * Convenience function for `pretty-dom` which also allows an array
+     * of elements
+     */
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number,
+      options?: { ... } // @TODO pretty format OptionsReceived
+    ) => void,
+    /**
+     * Convenience function for `Testing Playground` which logs URL that
+     * can be opened in a browser
+     */
+    logTestingPlaygroundURL: (element?: Element | Document) => void,
+    ...
+  };
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLElement,
+    unmount: () => boolean,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number
+    ) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptionsWithoutCustomQueries = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export type RenderOptionsWithCustomQueries<
+    CustomQueries: { ... }
+  > = {|
+    queries: CustomQueries,
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: RenderOptionsWithoutCustomQueries
+  ): RenderResult<>;
+  declare export function render<
+    CustomQueries: { [string]: (...args: Array<any>) => any, ... }
+  >(
+    ui: React$Element<any>,
+    options: RenderOptionsWithCustomQueries<CustomQueries>
+  ): RenderResult<CustomQueries>;
+
+  declare export var act: ReactDOMTestUtilsAct;
+  declare export function cleanup(): void;
+
+  declare export function waitFor<T>(
+    callback: () => T | Promise<T>,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function waitForElementToBeRemoved<T>(
+    callback: (() => T) | T,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  /**
+   * @deprecated `wait` has been deprecated and replaced by `waitFor` instead.
+   * In most cases you should be able to find/replace `wait` with `waitFor`.
+   * Learn more: https://testing-library.com/docs/dom-testing-library/api-async#waitfor.
+   */
+   declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    }
+  ): Promise<void>;
+
+  /**
+   * @deprecated `waitForDomChange` has been deprecated.
+   * Use `waitFor` instead: https://testing-library.com/docs/dom-testing-library/api-async#waitfor.
+   */
+  declare export function waitForDomChange<T>(options?: {
+    container?: UnionHTMLElement,
+    timeout?: number,
+    mutationObserverOptions?: MutationObserverInit,
+    ...
+  }): Promise<T>;
+
+  /**
+   * @deprecated `waitForElement` has been deprecated.
+   * Use a `find*` query (preferred: https://testing-library.com/docs/dom-testing-library/api-queries#findby)
+   * or use `waitFor` instead: https://testing-library.com/docs/dom-testing-library/api-async#waitfor
+   */
+  declare export function waitForElement<T>(
+    callback?: () => T,
+    options?: {
+      container?: UnionHTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    }
+  ): Promise<T>;
+
+  declare export function within(
+    element: UnionHTMLElement,
+    queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+  ): GetsAndQueries;
+
+  declare export var fireEvent: {|
+    (element: UnionHTMLElement, event: Event): void,
+
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+  |};
+  // dom-testing-library re-declares
+  declare export function queryByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function getNodeText(node: UnionHTMLElement): string;
+  declare export var screen: Screen<>;
+}
diff --git a/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/test_react_v11.x.x.js b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/test_react_v11.x.x.js
new file mode 100644
index 0000000000..d785817fbd
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v11.x.x/flow_v0.201.x-/test_react_v11.x.x.js
@@ -0,0 +1,1308 @@
+// @flow
+
+import * as React from 'react';
+import {
+  act,
+  render,
+  fireEvent,
+  cleanup,
+  waitFor,
+  waitForDomChange,
+  waitForElement,
+  waitForElementToBeRemoved,
+  within,
+  screen,
+  getNodeText,
+  type IntersectionHTMLElement,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: (resolve) => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(
+      () => {},
+      () => {}
+    );
+  });
+});
+
+describe('waitFor', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitFor(1);
+    // $FlowExpectedError[incompatible-call]
+    waitFor(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitFor(() => {});
+    waitFor(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForDomChange', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange('1');
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForDomChange({ container: document.createElement('div') });
+    waitForDomChange({ timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async (n) => {
+    const usernameElement = await waitForElement(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('waitForElementToBeRemoved', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElementToBeRemoved(() => {}, 1);
+  });
+
+  it('should pass on correct inputs (callback)', () => {
+    waitForElementToBeRemoved(() => document.createElement('div'));
+    waitForElementToBeRemoved(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should pass on correct inputs (node)', () => {
+    waitForElementToBeRemoved(document.createElement('div'));
+    waitForElementToBeRemoved(document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async (n) => {
+    const usernameElement = await waitForElementToBeRemoved(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByAltText('1');
+    const b: ?IntersectionHTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByAltText('2');
+  });
+
+  it('findByAltText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByAltText('1');
+    const b: Promise<IntersectionHTMLElement> = findByAltText('1');
+  });
+
+  it('findAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByAltText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByDisplayValue('1');
+    const b: ?IntersectionHTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('findByDisplayValue should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByDisplayValue('1');
+    const b: Promise<IntersectionHTMLElement> = findByDisplayValue('1');
+  });
+
+  it('findAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByDisplayValue('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByLabelText('1');
+    const b: ?IntersectionHTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('findByLabelText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByLabelText('1');
+    const b: Promise<IntersectionHTMLElement> = findByLabelText('1');
+  });
+
+  it('findAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByLabelText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByPlaceholderText('1');
+    const b: ?IntersectionHTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('findByPlaceholderText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByPlaceholderText('1');
+    const b: Promise<IntersectionHTMLElement> = findByPlaceholderText('1');
+  });
+
+  it('findAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByPlaceholderText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: string = getByRole('button');
+    const b: IntersectionHTMLElement = getByRole('button');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByRole('button');
+    const b: ?IntersectionHTMLElement = queryByRole('button');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('findByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByRole('button');
+    const b: Promise<IntersectionHTMLElement> = findByRole('button');
+  });
+
+  it('findAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByRole('button');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByRole('button');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTestId('1');
+  });
+
+  it('getByTestId returns a mixed HTML type', () => {
+    const a = getByTestId('1');
+    a.value;
+    a.disabled;
+    a.href;
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTestId('1');
+    const b: ?IntersectionHTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTestId('2');
+  });
+
+  it('findByTestId should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTestId('1');
+    const b: Promise<IntersectionHTMLElement> = findByTestId('1');
+  });
+
+  it('findAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTestId('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByText('1');
+    const b: ?IntersectionHTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByText('2');
+  });
+
+  it('findByText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByText('1');
+    const b: Promise<IntersectionHTMLElement> = findByText('1');
+  });
+
+  it('findAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTitle('1');
+    const b: ?IntersectionHTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTitle('2');
+  });
+
+  it('findByTitle should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTitle('1');
+    const b: Promise<IntersectionHTMLElement> = findByTitle('1');
+  });
+
+  it('findAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTitle('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTitle('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have findByAltText', async () => {
+    await within(container).findByAltText('1');
+  });
+
+  it('should have findAllByAltText', async () => {
+    await within(container).findAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have findByLabelText', async () => {
+    await within(container).findByLabelText('1');
+  });
+
+  it('should have findAllByLabelText', async () => {
+    await within(container).findAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have findByPlaceholderText', async () => {
+    await within(container).findByPlaceholderText('1');
+  });
+
+  it('should have findAllByPlaceholderText', async () => {
+    await within(container).findAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('button');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('button');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('button');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('button');
+  });
+
+  it('should have findByRole', async () => {
+    await within(container).findByRole('button');
+  });
+
+  it('should have findAllByRole', async () => {
+    await within(container).findAllByRole('button');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have findByTestId', async () => {
+    await within(container).findByTestId('1');
+  });
+
+  it('should have findAllByTestId', async () => {
+    await within(container).findAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have findByText', async () => {
+    await within(container).findByText('1');
+  });
+
+  it('should have findAllByText', async () => {
+    await within(container).findAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have findByTitle', async () => {
+    await within(container).findByTitle('1');
+  });
+
+  it('should have findAllByTitle', async () => {
+    await within(container).findAllByTitle('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+});
+
+describe('screen', () => {
+  it('should have all the queries available', () => {
+    // $FlowExpectedError[prop-missing]
+    const { notAQuery } = screen;
+    const {
+      debug,
+      getByAltText,
+      getAllByAltText,
+      queryByAltText,
+      queryAllByAltText,
+      findByAltText,
+      findAllByAltText,
+      getByDisplayValue,
+      getAllByDisplayValue,
+      queryByDisplayValue,
+      queryAllByDisplayValue,
+      findByDisplayValue,
+      findAllByDisplayValue,
+      getByLabelText,
+      getAllByLabelText,
+      queryByLabelText,
+      queryAllByLabelText,
+      findByLabelText,
+      findAllByLabelText,
+      getByPlaceholderText,
+      getAllByPlaceholderText,
+      queryByPlaceholderText,
+      queryAllByPlaceholderText,
+      findByPlaceholderText,
+      findAllByPlaceholderText,
+      getByRole,
+      getAllByRole,
+      queryByRole,
+      queryAllByRole,
+      findByRole,
+      findAllByRole,
+      getByTestId,
+      getAllByTestId,
+      queryByTestId,
+      queryAllByTestId,
+      findByTestId,
+      findAllByTestId,
+      getByText,
+      getAllByText,
+      queryByText,
+      queryAllByText,
+      findByText,
+      findAllByText,
+      getByTitle,
+      getAllByTitle,
+      queryByTitle,
+      queryAllByTitle,
+      findByTitle,
+      findAllByTitle,
+    } = screen;
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('getNodeText', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should return string', () => {
+    const a: string = getNodeText(container);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept by role arguments', () => {
+    getByRole('button');
+    getByRole('button', { hidden: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('getAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should accept by role arguments', () => {
+    queryByRole('button');
+    queryByRole('button', { hidden: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('queryAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTitle('1');
+  });
+});
+
+describe('render() parameters', () => {
+  class Component extends React.Component<{ ... }> {}
+
+  it('allows supplying parameters to render()', () => {
+    class CustomWrapper extends React.Component<{ ... }> {}
+    const element = document.createElement('div');
+    render(<Component />, {
+      baseElement: element,
+      container: element,
+      hydrate: true,
+      wrapper: CustomWrapper,
+    });
+  });
+
+  it('allows overriding render() with custom queries', () => {
+    type CustomReturnType = 123456;
+    declare var customValue: CustomReturnType;
+    const customQueries = {
+      getByOverride: (param1: string) => customValue,
+    };
+    const result = render<{|
+      getByOverride: (string) => CustomReturnType,
+    |}>(<Component />, { queries: customQueries });
+    const a: CustomReturnType = result.getByOverride('something');
+    // $FlowExpectedError[incompatible-call] bad type for getByOverride parameter
+    result.getByOverride(1234);
+    // $FlowExpectedError[incompatible-call] missing getByOverride parameter
+    result.getByOverride();
+    // $FlowExpectedError[prop-missing] default queries are not available when using custom queries
+    result.getByTestId('indifferent');
+  });
+});
diff --git a/definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-/react_v12.x.x.js b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-v.200.x/react_v12.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-/react_v12.x.x.js
rename to definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-v.200.x/react_v12.x.x.js
diff --git a/definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-/test_react_v12.x.x.js b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-v.200.x/test_react_v12.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-/test_react_v12.x.x.js
rename to definitions/npm/@testing-library/react_v12.x.x/flow_v0.104.x-v.200.x/test_react_v12.x.x.js
diff --git a/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/react_v12.x.x.js b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/react_v12.x.x.js
new file mode 100644
index 0000000000..8529594869
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/react_v12.x.x.js
@@ -0,0 +1,646 @@
+/**
+ * A local copy from:
+ * https://github.com/A11yance/aria-query/blob/2e6a3011a0d8987655f3a14853934fe3df38a8d8/flow/aria.js
+ */
+ declare module '@@aria-query' {
+  declare export type ARIAAbstractRole =
+    | 'command'
+    | 'composite'
+    | 'input'
+    | 'landmark'
+    | 'range'
+    | 'roletype'
+    | 'section'
+    | 'sectionhead'
+    | 'select'
+    | 'structure'
+    | 'widget'
+    | 'window';
+
+  declare export type ARIAWidgetRole =
+    | 'button'
+    | 'checkbox'
+    | 'gridcell'
+    | 'link'
+    | 'menuitem'
+    | 'menuitemcheckbox'
+    | 'menuitemradio'
+    | 'option'
+    | 'progressbar'
+    | 'radio'
+    | 'scrollbar'
+    | 'searchbox'
+    | 'slider'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tabpanel'
+    | 'textbox'
+    | 'treeitem';
+
+  declare export type ARIACompositeWidgetRole =
+    | 'combobox'
+    | 'grid'
+    | 'listbox'
+    | 'menu'
+    | 'menubar'
+    | 'radiogroup'
+    | 'tablist'
+    | 'tree'
+    | 'treegrid';
+
+  declare export type ARIADocumentStructureRole =
+    | 'application'
+    | 'article'
+    | 'blockquote'
+    | 'caption'
+    | 'cell'
+    | 'columnheader'
+    | 'definition'
+    | 'deletion'
+    | 'directory'
+    | 'document'
+    | 'emphasis'
+    | 'feed'
+    | 'figure'
+    | 'generic'
+    | 'group'
+    | 'heading'
+    | 'img'
+    | 'insertion'
+    | 'list'
+    | 'listitem'
+    | 'math'
+    | 'meter'
+    | 'none'
+    | 'note'
+    | 'paragraph'
+    | 'presentation'
+    | 'row'
+    | 'rowgroup'
+    | 'rowheader'
+    | 'separator'
+    | 'strong'
+    | 'subscript'
+    | 'superscript'
+    | 'table'
+    | 'term'
+    | 'time'
+    | 'toolbar'
+    | 'tooltip';
+
+  declare export type ARIALandmarkRole =
+    | 'banner'
+    | 'complementary'
+    | 'contentinfo'
+    | 'form'
+    | 'main'
+    | 'navigation'
+    | 'region'
+    | 'search';
+
+  declare export type ARIALiveRegionRole =
+    | 'alert'
+    | 'log'
+    | 'marquee'
+    | 'status'
+    | 'timer';
+
+  declare export type ARIAWindowRole = 'alertdialog' | 'dialog';
+
+  declare export type ARIAUncategorizedRole = 'code';
+
+  declare export type ARIADPubRole =
+    | 'doc-abstract'
+    | 'doc-acknowledgments'
+    | 'doc-afterword'
+    | 'doc-appendix'
+    | 'doc-backlink'
+    | 'doc-biblioentry'
+    | 'doc-bibliography'
+    | 'doc-biblioref'
+    | 'doc-chapter'
+    | 'doc-colophon'
+    | 'doc-conclusion'
+    | 'doc-cover'
+    | 'doc-credit'
+    | 'doc-credits'
+    | 'doc-dedication'
+    | 'doc-endnote'
+    | 'doc-endnotes'
+    | 'doc-epigraph'
+    | 'doc-epilogue'
+    | 'doc-errata'
+    | 'doc-example'
+    | 'doc-footnote'
+    | 'doc-foreword'
+    | 'doc-glossary'
+    | 'doc-glossref'
+    | 'doc-index'
+    | 'doc-introduction'
+    | 'doc-noteref'
+    | 'doc-notice'
+    | 'doc-pagebreak'
+    | 'doc-pagelist'
+    | 'doc-part'
+    | 'doc-preface'
+    | 'doc-prologue'
+    | 'doc-pullquote'
+    | 'doc-qna'
+    | 'doc-subtitle'
+    | 'doc-tip'
+    | 'doc-toc';
+
+  declare export type ARIARole =
+    | ARIAWidgetRole
+    | ARIACompositeWidgetRole
+    | ARIADocumentStructureRole
+    | ARIALandmarkRole
+    | ARIALiveRegionRole
+    | ARIAWindowRole
+    | ARIAUncategorizedRole;
+}
+
+declare module '@testing-library/react' {
+  import type { ARIARole } from '@@aria-query';
+
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type WaitForOptions = {|
+    container?: HTMLElement,
+    timeout?: number,
+    interval?: number,
+    onTimeout?: (error: Error) => Error,
+    mutationObserverOptions?: MutationObserverInit,
+  |};
+
+  declare type MatcherFunction = (
+    content: string,
+    element: HTMLElement
+  ) => boolean;
+
+  declare type Matcher = MatcherFunction | RegExp | string | number;
+
+  declare type ByRoleMatcher = ARIARole | MatcherFunction;
+
+  declare type NormalizerFn = (text: string) => string;
+
+  declare type MatcherOptions = {|
+    exact?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    trim?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    collapseWhitespace?: boolean,
+    normalizer?: NormalizerFn,
+    /** suppress suggestions for a specific query */
+    suggest?: boolean,
+  |};
+
+  declare type ByRoleOptions = {|
+    ...MatcherOptions,
+    /**
+     * If true includes elements in the query set that are usually excluded from
+     * the accessibility tree. `role="none"` or `role="presentation"` are included
+     * in either case.
+     */
+    hidden?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * selected in the accessibility tree, i.e., `aria-selected="true"`
+     */
+    selected?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * checked in the accessibility tree, i.e., `aria-checked="true"`
+     */
+    checked?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * pressed in the accessibility tree, i.e., `aria-pressed="true"`
+     */
+    pressed?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * expanded in the accessibility tree, i.e., `aria-expanded="true"`
+     */
+    expanded?: boolean,
+    /**
+     * Includes elements with the `"heading"` role matching the indicated level,
+     * either by the semantic HTML heading elements `<h1>-<h6>` or matching
+     * the `aria-level` attribute.
+     */
+    level?: number,
+    /**
+     * Includes every role used in the `role` attribute
+     * For example *ByRole('progressbar', {queryFallbacks: true})` will find <div role="meter progressbar">`.
+     */
+    queryFallbacks?: boolean,
+    /**
+     * Only considers  elements with the specified accessible name.
+     */
+    name?:
+      | string
+      | RegExp
+      | ((accessibleName: string, element: Element) => boolean),
+  |};
+
+  declare type SelectorMatcherOptions = {|
+    ...MatcherOptions,
+    selector?: string,
+    ignore?: string | boolean
+  |};
+
+  // These two types must be updated kept in sync
+  declare export type UnionHTMLElement =
+    | HTMLElement
+    | HTMLInputElement
+    | HTMLAnchorElement
+    | HTMLButtonElement
+    | HTMLLabelElement
+    | HTMLSelectElement;
+
+  declare export type IntersectionHTMLElement =
+    & HTMLElement
+    & HTMLInputElement
+    & HTMLAnchorElement
+    & HTMLButtonElement
+    & HTMLLabelElement
+    & HTMLSelectElement;
+  // End mixed html types
+
+  declare type MaybeIntersectionHTMLElement = null | IntersectionHTMLElement;
+
+  declare type QueryByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => MaybeIntersectionHTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type QueryByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => MaybeIntersectionHTMLElement;
+
+  declare type AllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type AllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement[];
+
+  declare type GetByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement;
+
+  declare type QueryByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement | null;
+
+  declare type FindByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type FindAllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetsAndQueries = {|
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+    findByLabelText: FindByText,
+    findAllByLabelText: FindAllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+    findByPlaceholderText: FindByBoundAttribute,
+    findAllByPlaceholderText: FindAllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+    findByText: FindByText,
+    findAllByText: FindAllByText,
+
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+    findByAltText: FindByBoundAttribute,
+    findAllByAltText: FindAllByBoundAttribute,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+    findByTitle: FindByBoundAttribute,
+    findAllByTitle: FindAllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+    findByDisplayValue: FindByBoundAttribute,
+    findAllByDisplayValue: FindAllByBoundAttribute,
+
+    getByRole: GetByRole,
+    getAllByRole: AllByRole,
+    queryByRole: QueryByRole,
+    queryAllByRole: AllByRole,
+    findByRole: FindByRole,
+    findAllByRole: FindAllByRole,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+    findByTestId: FindByBoundAttribute,
+    findAllByTestId: FindAllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: UnionHTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type Screen<Queries = GetsAndQueries> = {
+    ...Queries,
+    /**
+     * Convenience function for `pretty-dom` which also allows an array
+     * of elements
+     */
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number,
+      options?: { ... } // @TODO pretty format OptionsReceived
+    ) => void,
+    /**
+     * Convenience function for `Testing Playground` which logs URL that
+     * can be opened in a browser
+     */
+    logTestingPlaygroundURL: (element?: Element | Document) => void,
+    ...
+  };
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLElement,
+    unmount: () => boolean,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number
+    ) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptionsWithoutCustomQueries = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export type RenderOptionsWithCustomQueries<
+    CustomQueries: { ... }
+  > = {|
+    queries: CustomQueries,
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: RenderOptionsWithoutCustomQueries
+  ): RenderResult<>;
+  declare export function render<
+    CustomQueries: { [string]: (...args: Array<any>) => any, ... }
+  >(
+    ui: React$Element<any>,
+    options: RenderOptionsWithCustomQueries<CustomQueries>
+  ): RenderResult<CustomQueries>;
+
+  declare export var act: ReactDOMTestUtilsAct;
+  declare export function cleanup(): void;
+
+  declare export function waitFor<T>(
+    callback: () => T | Promise<T>,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function waitForElementToBeRemoved<T>(
+    callback: (() => T) | T,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function within(
+    element: UnionHTMLElement,
+    queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+  ): GetsAndQueries;
+
+  declare export var fireEvent: {|
+    (element: UnionHTMLElement, event: Event): void,
+
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+  |};
+  // dom-testing-library re-declares
+  declare export function queryByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): MaybeIntersectionHTMLElement;
+  declare export function getByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): MaybeIntersectionHTMLElement;
+  declare export function getByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): MaybeIntersectionHTMLElement;
+  declare export function getByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): MaybeIntersectionHTMLElement;
+  declare export function getByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): MaybeIntersectionHTMLElement;
+  declare export function getByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function getNodeText(node: UnionHTMLElement): string;
+  declare export var screen: Screen<>;
+}
diff --git a/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/test_react_v12.x.x.js b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/test_react_v12.x.x.js
new file mode 100644
index 0000000000..92c07e522e
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v12.x.x/flow_v0.201.x-/test_react_v12.x.x.js
@@ -0,0 +1,1275 @@
+// @flow
+
+import * as React from 'react';
+import {
+  act,
+  render,
+  fireEvent,
+  cleanup,
+  waitFor,
+  waitForElementToBeRemoved,
+  within,
+  screen,
+  getNodeText,
+  type IntersectionHTMLElement,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+declare type MaybeIntersectionHTMLElement = null | IntersectionHTMLElement;
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: (resolve) => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(
+      () => {},
+      () => {}
+    );
+  });
+});
+
+describe('waitFor', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitFor(1);
+    // $FlowExpectedError[incompatible-call]
+    waitFor(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitFor(() => {});
+    waitFor(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForElementToBeRemoved', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElementToBeRemoved(() => {}, 1);
+  });
+
+  it('should pass on correct inputs (callback)', () => {
+    waitForElementToBeRemoved(() => document.createElement('div'));
+    waitForElementToBeRemoved(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should pass on correct inputs (node)', () => {
+    waitForElementToBeRemoved(document.createElement('div'));
+    waitForElementToBeRemoved(document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async (n) => {
+    const usernameElement = await waitForElementToBeRemoved(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('matcher function should receive HTMLElement type elements', () => {
+    const a: IntersectionHTMLElement = getByText(
+      (_, node) => node.style.height === '100px'
+    );
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByAltText('1');
+    const b: MaybeIntersectionHTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByAltText('2');
+  });
+
+  it('findByAltText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByAltText('1');
+    const b: Promise<IntersectionHTMLElement> = findByAltText('1');
+  });
+
+  it('findAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByAltText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByDisplayValue('1');
+    const b: MaybeIntersectionHTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('findByDisplayValue should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByDisplayValue('1');
+    const b: Promise<IntersectionHTMLElement> = findByDisplayValue('1');
+  });
+
+  it('findAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByDisplayValue('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByLabelText('1');
+    const b: MaybeIntersectionHTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('findByLabelText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByLabelText('1');
+    const b: Promise<IntersectionHTMLElement> = findByLabelText('1');
+  });
+
+  it('findAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByLabelText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByPlaceholderText('1');
+    const b: MaybeIntersectionHTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('findByPlaceholderText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByPlaceholderText('1');
+    const b: Promise<IntersectionHTMLElement> = findByPlaceholderText('1');
+  });
+
+  it('findAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByPlaceholderText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: string = getByRole('button');
+    const b: IntersectionHTMLElement = getByRole('button');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByRole('button');
+    const b: MaybeIntersectionHTMLElement = queryByRole('button');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('findByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByRole('button');
+    const b: Promise<IntersectionHTMLElement> = findByRole('button');
+  });
+
+  it('findAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByRole('button');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByRole('button');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTestId('1');
+  });
+
+  it('getByTestId returns a mixed HTML type', () => {
+    const a = getByTestId('1');
+    a.value;
+    a.disabled;
+    a.href;
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTestId('1');
+    const b: MaybeIntersectionHTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTestId('2');
+  });
+
+  it('findByTestId should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTestId('1');
+    const b: Promise<IntersectionHTMLElement> = findByTestId('1');
+  });
+
+  it('findAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTestId('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByText('1');
+    const b: MaybeIntersectionHTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByText('2');
+  });
+
+  it('findByText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByText('1');
+    const b: Promise<IntersectionHTMLElement> = findByText('1');
+  });
+
+  it('findAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTitle('1');
+    const b: MaybeIntersectionHTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTitle('2');
+  });
+
+  it('findByTitle should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTitle('1');
+    const b: Promise<IntersectionHTMLElement> = findByTitle('1');
+  });
+
+  it('findAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTitle('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTitle('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have findByAltText', async () => {
+    await within(container).findByAltText('1');
+  });
+
+  it('should have findAllByAltText', async () => {
+    await within(container).findAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have findByLabelText', async () => {
+    await within(container).findByLabelText('1');
+  });
+
+  it('should have findAllByLabelText', async () => {
+    await within(container).findAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have findByPlaceholderText', async () => {
+    await within(container).findByPlaceholderText('1');
+  });
+
+  it('should have findAllByPlaceholderText', async () => {
+    await within(container).findAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('button');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('button');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('button');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('button');
+  });
+
+  it('should have findByRole', async () => {
+    await within(container).findByRole('button');
+  });
+
+  it('should have findAllByRole', async () => {
+    await within(container).findAllByRole('button');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have findByTestId', async () => {
+    await within(container).findByTestId('1');
+  });
+
+  it('should have findAllByTestId', async () => {
+    await within(container).findAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have findByText', async () => {
+    await within(container).findByText('1');
+  });
+
+  it('should have findAllByText', async () => {
+    await within(container).findAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have findByTitle', async () => {
+    await within(container).findByTitle('1');
+  });
+
+  it('should have findAllByTitle', async () => {
+    await within(container).findAllByTitle('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+});
+
+describe('screen', () => {
+  it('should have all the queries available', () => {
+    // $FlowExpectedError[prop-missing]
+    const { notAQuery } = screen;
+    const {
+      debug,
+      getByAltText,
+      getAllByAltText,
+      queryByAltText,
+      queryAllByAltText,
+      findByAltText,
+      findAllByAltText,
+      getByDisplayValue,
+      getAllByDisplayValue,
+      queryByDisplayValue,
+      queryAllByDisplayValue,
+      findByDisplayValue,
+      findAllByDisplayValue,
+      getByLabelText,
+      getAllByLabelText,
+      queryByLabelText,
+      queryAllByLabelText,
+      findByLabelText,
+      findAllByLabelText,
+      getByPlaceholderText,
+      getAllByPlaceholderText,
+      queryByPlaceholderText,
+      queryAllByPlaceholderText,
+      findByPlaceholderText,
+      findAllByPlaceholderText,
+      getByRole,
+      getAllByRole,
+      queryByRole,
+      queryAllByRole,
+      findByRole,
+      findAllByRole,
+      getByTestId,
+      getAllByTestId,
+      queryByTestId,
+      queryAllByTestId,
+      findByTestId,
+      findAllByTestId,
+      getByText,
+      getAllByText,
+      queryByText,
+      queryAllByText,
+      findByText,
+      findAllByText,
+      getByTitle,
+      getAllByTitle,
+      queryByTitle,
+      queryAllByTitle,
+      findByTitle,
+      findAllByTitle,
+    } = screen;
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('getNodeText', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should return string', () => {
+    const a: string = getNodeText(container);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept by role arguments', () => {
+    getByRole('button');
+    getByRole('button', { hidden: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('getAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should accept by role arguments', () => {
+    queryByRole('button');
+    queryByRole('button', { hidden: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('queryAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTitle('1');
+  });
+});
+
+describe('render() parameters', () => {
+  class Component extends React.Component<{ ... }> {}
+
+  it('allows supplying parameters to render()', () => {
+    class CustomWrapper extends React.Component<{ ... }> {}
+    const element = document.createElement('div');
+    render(<Component />, {
+      baseElement: element,
+      container: element,
+      hydrate: true,
+      wrapper: CustomWrapper,
+    });
+  });
+
+  it('allows overriding render() with custom queries', () => {
+    type CustomReturnType = 123456;
+    declare var customValue: CustomReturnType;
+    const customQueries = {
+      getByOverride: (param1: string) => customValue,
+    };
+    const result = render<{|
+      getByOverride: (string) => CustomReturnType,
+    |}>(<Component />, { queries: customQueries });
+    const a: CustomReturnType = result.getByOverride('something');
+    // $FlowExpectedError[incompatible-call] bad type for getByOverride parameter
+    result.getByOverride(1234);
+    // $FlowExpectedError[incompatible-call] missing getByOverride parameter
+    result.getByOverride();
+    // $FlowExpectedError[prop-missing] default queries are not available when using custom queries
+    result.getByTestId('indifferent');
+  });
+});
diff --git a/definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-/react_v13.x.x.js b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-v.200.x/react_v13.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-/react_v13.x.x.js
rename to definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-v.200.x/react_v13.x.x.js
diff --git a/definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-/test_react_v13.x.x.js b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-v.200.x/test_react_v13.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-/test_react_v13.x.x.js
rename to definitions/npm/@testing-library/react_v13.x.x/flow_v0.104.x-v.200.x/test_react_v13.x.x.js
diff --git a/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/react_v13.x.x.js b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/react_v13.x.x.js
new file mode 100644
index 0000000000..c7c1ec8f25
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/react_v13.x.x.js
@@ -0,0 +1,644 @@
+/**
+ * A local copy from:
+ * https://github.com/A11yance/aria-query/blob/2e6a3011a0d8987655f3a14853934fe3df38a8d8/flow/aria.js
+ */
+ declare module '@@aria-query' {
+  declare export type ARIAAbstractRole =
+    | 'command'
+    | 'composite'
+    | 'input'
+    | 'landmark'
+    | 'range'
+    | 'roletype'
+    | 'section'
+    | 'sectionhead'
+    | 'select'
+    | 'structure'
+    | 'widget'
+    | 'window';
+
+  declare export type ARIAWidgetRole =
+    | 'button'
+    | 'checkbox'
+    | 'gridcell'
+    | 'link'
+    | 'menuitem'
+    | 'menuitemcheckbox'
+    | 'menuitemradio'
+    | 'option'
+    | 'progressbar'
+    | 'radio'
+    | 'scrollbar'
+    | 'searchbox'
+    | 'slider'
+    | 'spinbutton'
+    | 'switch'
+    | 'tab'
+    | 'tabpanel'
+    | 'textbox'
+    | 'treeitem';
+
+  declare export type ARIACompositeWidgetRole =
+    | 'combobox'
+    | 'grid'
+    | 'listbox'
+    | 'menu'
+    | 'menubar'
+    | 'radiogroup'
+    | 'tablist'
+    | 'tree'
+    | 'treegrid';
+
+  declare export type ARIADocumentStructureRole =
+    | 'application'
+    | 'article'
+    | 'blockquote'
+    | 'caption'
+    | 'cell'
+    | 'columnheader'
+    | 'definition'
+    | 'deletion'
+    | 'directory'
+    | 'document'
+    | 'emphasis'
+    | 'feed'
+    | 'figure'
+    | 'generic'
+    | 'group'
+    | 'heading'
+    | 'img'
+    | 'insertion'
+    | 'list'
+    | 'listitem'
+    | 'math'
+    | 'meter'
+    | 'none'
+    | 'note'
+    | 'paragraph'
+    | 'presentation'
+    | 'row'
+    | 'rowgroup'
+    | 'rowheader'
+    | 'separator'
+    | 'strong'
+    | 'subscript'
+    | 'superscript'
+    | 'table'
+    | 'term'
+    | 'time'
+    | 'toolbar'
+    | 'tooltip';
+
+  declare export type ARIALandmarkRole =
+    | 'banner'
+    | 'complementary'
+    | 'contentinfo'
+    | 'form'
+    | 'main'
+    | 'navigation'
+    | 'region'
+    | 'search';
+
+  declare export type ARIALiveRegionRole =
+    | 'alert'
+    | 'log'
+    | 'marquee'
+    | 'status'
+    | 'timer';
+
+  declare export type ARIAWindowRole = 'alertdialog' | 'dialog';
+
+  declare export type ARIAUncategorizedRole = 'code';
+
+  declare export type ARIADPubRole =
+    | 'doc-abstract'
+    | 'doc-acknowledgments'
+    | 'doc-afterword'
+    | 'doc-appendix'
+    | 'doc-backlink'
+    | 'doc-biblioentry'
+    | 'doc-bibliography'
+    | 'doc-biblioref'
+    | 'doc-chapter'
+    | 'doc-colophon'
+    | 'doc-conclusion'
+    | 'doc-cover'
+    | 'doc-credit'
+    | 'doc-credits'
+    | 'doc-dedication'
+    | 'doc-endnote'
+    | 'doc-endnotes'
+    | 'doc-epigraph'
+    | 'doc-epilogue'
+    | 'doc-errata'
+    | 'doc-example'
+    | 'doc-footnote'
+    | 'doc-foreword'
+    | 'doc-glossary'
+    | 'doc-glossref'
+    | 'doc-index'
+    | 'doc-introduction'
+    | 'doc-noteref'
+    | 'doc-notice'
+    | 'doc-pagebreak'
+    | 'doc-pagelist'
+    | 'doc-part'
+    | 'doc-preface'
+    | 'doc-prologue'
+    | 'doc-pullquote'
+    | 'doc-qna'
+    | 'doc-subtitle'
+    | 'doc-tip'
+    | 'doc-toc';
+
+  declare export type ARIARole =
+    | ARIAWidgetRole
+    | ARIACompositeWidgetRole
+    | ARIADocumentStructureRole
+    | ARIALandmarkRole
+    | ARIALiveRegionRole
+    | ARIAWindowRole
+    | ARIAUncategorizedRole;
+}
+
+declare module '@testing-library/react' {
+  import type { ARIARole } from '@@aria-query';
+
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type WaitForOptions = {|
+    container?: HTMLElement,
+    timeout?: number,
+    interval?: number,
+    onTimeout?: (error: Error) => Error,
+    mutationObserverOptions?: MutationObserverInit,
+  |};
+
+  declare type MatcherFunction = (
+    content: string,
+    element: ?Element
+  ) => boolean;
+
+  declare type Matcher = MatcherFunction | RegExp | string | number;
+
+  declare type ByRoleMatcher = ARIARole | MatcherFunction;
+
+  declare type NormalizerFn = (text: string) => string;
+
+  declare type MatcherOptions = {|
+    exact?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    trim?: boolean,
+    /** Use normalizer with getDefaultNormalizer instead */
+    collapseWhitespace?: boolean,
+    normalizer?: NormalizerFn,
+    /** suppress suggestions for a specific query */
+    suggest?: boolean,
+  |};
+
+  declare type ByRoleOptions = {|
+    ...MatcherOptions,
+    /**
+     * If true includes elements in the query set that are usually excluded from
+     * the accessibility tree. `role="none"` or `role="presentation"` are included
+     * in either case.
+     */
+    hidden?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * selected in the accessibility tree, i.e., `aria-selected="true"`
+     */
+    selected?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * checked in the accessibility tree, i.e., `aria-checked="true"`
+     */
+    checked?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * pressed in the accessibility tree, i.e., `aria-pressed="true"`
+     */
+    pressed?: boolean,
+    /**
+     * If true only includes elements in the query set that are marked as
+     * expanded in the accessibility tree, i.e., `aria-expanded="true"`
+     */
+    expanded?: boolean,
+    /**
+     * Includes elements with the `"heading"` role matching the indicated level,
+     * either by the semantic HTML heading elements `<h1>-<h6>` or matching
+     * the `aria-level` attribute.
+     */
+    level?: number,
+    /**
+     * Includes every role used in the `role` attribute
+     * For example *ByRole('progressbar', {queryFallbacks: true})` will find <div role="meter progressbar">`.
+     */
+    queryFallbacks?: boolean,
+    /**
+     * Only considers  elements with the specified accessible name.
+     */
+    name?:
+      | string
+      | RegExp
+      | ((accessibleName: string, element: Element) => boolean),
+  |};
+
+  declare type SelectorMatcherOptions = {|
+    ...MatcherOptions,
+    selector?: string,
+    ignore?: string | boolean
+  |};
+
+  // These two types must be updated kept in sync
+  declare export type UnionHTMLElement =
+    | HTMLElement
+    | HTMLInputElement
+    | HTMLAnchorElement
+    | HTMLButtonElement
+    | HTMLLabelElement
+    | HTMLSelectElement;
+
+  declare export type IntersectionHTMLElement =
+    & HTMLElement
+    & HTMLInputElement
+    & HTMLAnchorElement
+    & HTMLButtonElement
+    & HTMLLabelElement
+    & HTMLSelectElement;
+  // End mixed html types
+
+  declare type QueryByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => ?IntersectionHTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByBoundAttribute = (
+    text: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type QueryByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => ?IntersectionHTMLElement;
+
+  declare type AllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => Array<IntersectionHTMLElement>;
+
+  declare type FindAllByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions
+  ) => IntersectionHTMLElement;
+
+  declare type FindByText = (
+    text: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type AllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement[];
+
+  declare type GetByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement;
+
+  declare type QueryByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions
+  ) => IntersectionHTMLElement | null;
+
+  declare type FindByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement>;
+
+  declare type FindAllByRole = (
+    role: ByRoleMatcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForOptions
+  ) => Promise<IntersectionHTMLElement[]>;
+
+  declare type GetsAndQueries = {|
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+    findByLabelText: FindByText,
+    findAllByLabelText: FindAllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+    findByPlaceholderText: FindByBoundAttribute,
+    findAllByPlaceholderText: FindAllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+    findByText: FindByText,
+    findAllByText: FindAllByText,
+
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+    findByAltText: FindByBoundAttribute,
+    findAllByAltText: FindAllByBoundAttribute,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+    findByTitle: FindByBoundAttribute,
+    findAllByTitle: FindAllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+    findByDisplayValue: FindByBoundAttribute,
+    findAllByDisplayValue: FindAllByBoundAttribute,
+
+    getByRole: GetByRole,
+    getAllByRole: AllByRole,
+    queryByRole: QueryByRole,
+    queryAllByRole: AllByRole,
+    findByRole: FindByRole,
+    findAllByRole: FindAllByRole,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+    findByTestId: FindByBoundAttribute,
+    findAllByTestId: FindAllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: UnionHTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type Screen<Queries = GetsAndQueries> = {
+    ...Queries,
+    /**
+     * Convenience function for `pretty-dom` which also allows an array
+     * of elements
+     */
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number,
+      options?: { ... } // @TODO pretty format OptionsReceived
+    ) => void,
+    /**
+     * Convenience function for `Testing Playground` which logs URL that
+     * can be opened in a browser
+     */
+    logTestingPlaygroundURL: (element?: Element | Document) => void,
+    ...
+  };
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLElement,
+    unmount: () => boolean,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (
+      baseElement?:
+        | HTMLElement
+        | DocumentFragment
+        | Array<HTMLElement | DocumentFragment>,
+      maxLength?: number
+    ) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptionsWithoutCustomQueries = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export type RenderOptionsWithCustomQueries<
+    CustomQueries: { ... }
+  > = {|
+    queries: CustomQueries,
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: RenderOptionsWithoutCustomQueries
+  ): RenderResult<>;
+  declare export function render<
+    CustomQueries: { [string]: (...args: Array<any>) => any, ... }
+  >(
+    ui: React$Element<any>,
+    options: RenderOptionsWithCustomQueries<CustomQueries>
+  ): RenderResult<CustomQueries>;
+
+  declare export var act: ReactDOMTestUtilsAct;
+  declare export function cleanup(): void;
+
+  declare export function waitFor<T>(
+    callback: () => T | Promise<T>,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function waitForElementToBeRemoved<T>(
+    callback: (() => T) | T,
+    options?: {|
+      container?: UnionHTMLElement,
+      timeout?: number,
+      interval?: number,
+      mutationObserverOptions?: MutationObserverInit,
+    |}
+  ): Promise<T>;
+
+  declare export function within(
+    element: UnionHTMLElement,
+    queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+  ): GetsAndQueries;
+
+  declare export var fireEvent: {|
+    (element: UnionHTMLElement, event: Event): void,
+
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+  |};
+  // dom-testing-library re-declares
+  declare export function queryByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByTestId(
+    container: UnionHTMLElement,
+    id: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByPlaceholderText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByLabelText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: { selector?: string, ... } & MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function queryByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): ?IntersectionHTMLElement;
+  declare export function getByAltText(
+    container: UnionHTMLElement,
+    text: Matcher,
+    options?: MatcherOptions
+  ): IntersectionHTMLElement;
+  declare export function getNodeText(node: UnionHTMLElement): string;
+  declare export var screen: Screen<>;
+}
diff --git a/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/test_react_v13.x.x.js b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/test_react_v13.x.x.js
new file mode 100644
index 0000000000..b55501628c
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v13.x.x/flow_v0.201.x-/test_react_v13.x.x.js
@@ -0,0 +1,1267 @@
+// @flow
+
+import * as React from 'react';
+import {
+  act,
+  render,
+  fireEvent,
+  cleanup,
+  waitFor,
+  waitForElementToBeRemoved,
+  within,
+  screen,
+  getNodeText,
+  type IntersectionHTMLElement,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: (resolve) => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(
+      () => {},
+      () => {}
+    );
+  });
+});
+
+describe('waitFor', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitFor(1);
+    // $FlowExpectedError[incompatible-call]
+    waitFor(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitFor(() => {});
+    waitFor(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForElementToBeRemoved', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElementToBeRemoved(() => {}, 1);
+  });
+
+  it('should pass on correct inputs (callback)', () => {
+    waitForElementToBeRemoved(() => document.createElement('div'));
+    waitForElementToBeRemoved(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should pass on correct inputs (node)', () => {
+    waitForElementToBeRemoved(document.createElement('div'));
+    waitForElementToBeRemoved(document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async (n) => {
+    const usernameElement = await waitForElementToBeRemoved(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByAltText('1');
+    const b: ?IntersectionHTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByAltText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByAltText('2');
+  });
+
+  it('findByAltText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByAltText('1');
+    const b: Promise<IntersectionHTMLElement> = findByAltText('1');
+  });
+
+  it('findAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByAltText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByDisplayValue('1');
+    const b: ?IntersectionHTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByDisplayValue('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('findByDisplayValue should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByDisplayValue('1');
+    const b: Promise<IntersectionHTMLElement> = findByDisplayValue('1');
+  });
+
+  it('findAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByDisplayValue('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByLabelText('1');
+    const b: ?IntersectionHTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByLabelText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('findByLabelText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByLabelText('1');
+    const b: Promise<IntersectionHTMLElement> = findByLabelText('1');
+  });
+
+  it('findAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByLabelText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByPlaceholderText('1');
+    const b: ?IntersectionHTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('findByPlaceholderText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByPlaceholderText('1');
+    const b: Promise<IntersectionHTMLElement> = findByPlaceholderText('1');
+  });
+
+  it('findAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByPlaceholderText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: string = getByRole('button');
+    const b: IntersectionHTMLElement = getByRole('button');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByRole('button');
+    const b: ?IntersectionHTMLElement = queryByRole('button');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByRole('button');
+    const b: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('findByRole should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByRole('button');
+    const b: Promise<IntersectionHTMLElement> = findByRole('button');
+  });
+
+  it('findAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByRole('button');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByRole('button');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTestId('1');
+  });
+
+  it('getByTestId returns a mixed HTML type', () => {
+    const a = getByTestId('1');
+    a.value;
+    a.disabled;
+    a.href;
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTestId('1');
+    const b: ?IntersectionHTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTestId('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTestId('2');
+  });
+
+  it('findByTestId should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTestId('1');
+    const b: Promise<IntersectionHTMLElement> = findByTestId('1');
+  });
+
+  it('findAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTestId('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByText('1');
+    const b: Array<IntersectionHTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByText('1');
+    const b: ?IntersectionHTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByText('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByText('2');
+  });
+
+  it('findByText should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByText('1');
+    const b: Promise<IntersectionHTMLElement> = findByText('1');
+  });
+
+  it('findAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const a: Promise<IntersectionHTMLElement> = findAllByText('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: IntersectionHTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = getAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryByTitle('1');
+    const b: ?IntersectionHTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = queryAllByTitle('1');
+    const b: Array<IntersectionHTMLElement> = queryAllByTitle('2');
+  });
+
+  it('findByTitle should return HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findByTitle('1');
+    const b: Promise<IntersectionHTMLElement> = findByTitle('1');
+  });
+
+  it('findAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: IntersectionHTMLElement = findAllByTitle('1');
+    const b: Promise<Array<IntersectionHTMLElement>> = findAllByTitle('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have findByAltText', async () => {
+    await within(container).findByAltText('1');
+  });
+
+  it('should have findAllByAltText', async () => {
+    await within(container).findAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have findByLabelText', async () => {
+    await within(container).findByLabelText('1');
+  });
+
+  it('should have findAllByLabelText', async () => {
+    await within(container).findAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have findByPlaceholderText', async () => {
+    await within(container).findByPlaceholderText('1');
+  });
+
+  it('should have findAllByPlaceholderText', async () => {
+    await within(container).findAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('button');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('button');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('button');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('button');
+  });
+
+  it('should have findByRole', async () => {
+    await within(container).findByRole('button');
+  });
+
+  it('should have findAllByRole', async () => {
+    await within(container).findAllByRole('button');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have findByTestId', async () => {
+    await within(container).findByTestId('1');
+  });
+
+  it('should have findAllByTestId', async () => {
+    await within(container).findAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have findByText', async () => {
+    await within(container).findByText('1');
+  });
+
+  it('should have findAllByText', async () => {
+    await within(container).findAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have findByTitle', async () => {
+    await within(container).findByTitle('1');
+  });
+
+  it('should have findAllByTitle', async () => {
+    await within(container).findAllByTitle('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have findByDisplayValue', async () => {
+    await within(container).findByDisplayValue('1');
+  });
+
+  it('should have findAllByDisplayValue', async () => {
+    await within(container).findAllByDisplayValue('1');
+  });
+});
+
+describe('screen', () => {
+  it('should have all the queries available', () => {
+    // $FlowExpectedError[prop-missing]
+    const { notAQuery } = screen;
+    const {
+      debug,
+      getByAltText,
+      getAllByAltText,
+      queryByAltText,
+      queryAllByAltText,
+      findByAltText,
+      findAllByAltText,
+      getByDisplayValue,
+      getAllByDisplayValue,
+      queryByDisplayValue,
+      queryAllByDisplayValue,
+      findByDisplayValue,
+      findAllByDisplayValue,
+      getByLabelText,
+      getAllByLabelText,
+      queryByLabelText,
+      queryAllByLabelText,
+      findByLabelText,
+      findAllByLabelText,
+      getByPlaceholderText,
+      getAllByPlaceholderText,
+      queryByPlaceholderText,
+      queryAllByPlaceholderText,
+      findByPlaceholderText,
+      findAllByPlaceholderText,
+      getByRole,
+      getAllByRole,
+      queryByRole,
+      queryAllByRole,
+      findByRole,
+      findAllByRole,
+      getByTestId,
+      getAllByTestId,
+      queryByTestId,
+      queryAllByTestId,
+      findByTestId,
+      findAllByTestId,
+      getByText,
+      getAllByText,
+      queryByText,
+      queryAllByText,
+      findByText,
+      findAllByText,
+      getByTitle,
+      getAllByTitle,
+      queryByTitle,
+      queryAllByTitle,
+      findByTitle,
+      findAllByTitle,
+    } = screen;
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('getNodeText', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should return string', () => {
+    const a: string = getNodeText(container);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    findByAltText,
+    findAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    findByDisplayValue,
+    findAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    findByLabelText,
+    findAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    findByPlaceholderText,
+    findAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    findByRole,
+    findAllByRole,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    findByTestId,
+    findAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    findByText,
+    findAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    findByTitle,
+    findAllByTitle,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept by role arguments', () => {
+    getByRole('button');
+    getByRole('button', { hidden: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('getAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByRole('button');
+  });
+
+  it('queryByRole should accept by role arguments', () => {
+    queryByRole('button');
+    queryByRole('button', { hidden: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      hidden: true,
+    });
+  });
+
+  it('queryAllByRole should accept by role arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByRole('button');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<IntersectionHTMLElement> = queryAllByTitle('1');
+  });
+});
+
+describe('render() parameters', () => {
+  class Component extends React.Component<{ ... }> {}
+
+  it('allows supplying parameters to render()', () => {
+    class CustomWrapper extends React.Component<{ ... }> {}
+    const element = document.createElement('div');
+    render(<Component />, {
+      baseElement: element,
+      container: element,
+      hydrate: true,
+      wrapper: CustomWrapper,
+    });
+  });
+
+  it('allows overriding render() with custom queries', () => {
+    type CustomReturnType = 123456;
+    declare var customValue: CustomReturnType;
+    const customQueries = {
+      getByOverride: (param1: string) => customValue,
+    };
+    const result = render<{|
+      getByOverride: (string) => CustomReturnType,
+    |}>(<Component />, { queries: customQueries });
+    const a: CustomReturnType = result.getByOverride('something');
+    // $FlowExpectedError[incompatible-call] bad type for getByOverride parameter
+    result.getByOverride(1234);
+    // $FlowExpectedError[incompatible-call] missing getByOverride parameter
+    result.getByOverride();
+    // $FlowExpectedError[prop-missing] default queries are not available when using custom queries
+    result.getByTestId('indifferent');
+  });
+});
diff --git a/definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-/react_v8.x.x.js b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-v.200.x/react_v8.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-/react_v8.x.x.js
rename to definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-v.200.x/react_v8.x.x.js
diff --git a/definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-/test_react_v8.x.x.js b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-v.200.x/test_react_v8.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-/test_react_v8.x.x.js
rename to definitions/npm/@testing-library/react_v8.x.x/flow_v0.104.x-v.200.x/test_react_v8.x.x.js
diff --git a/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/react_v8.x.x.js b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/react_v8.x.x.js
new file mode 100644
index 0000000000..a25080063e
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/react_v8.x.x.js
@@ -0,0 +1,293 @@
+declare module '@testing-library/react' {
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type TextMatch =
+    | string
+    | RegExp
+    | ((content: string, element: HTMLElement) => boolean);
+
+  declare type TextMatchOptions = {
+    exact?: boolean,
+    trim?: boolean,
+    collapseWhitespace?: boolean,
+    ...
+  };
+
+  declare type SelectorMatchOptions = {
+    selector?: string,
+    ...
+  } & TextMatchOptions;
+
+  declare type GetByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetsAndQueries = {|
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+
+    getByRole: GetByBoundAttribute,
+    getAllByRole: AllByBoundAttribute,
+    queryByRole: QueryByBoundAttribute,
+    queryAllByRole: AllByBoundAttribute,
+
+    getBySelectText: GetByBoundAttribute,
+    getAllBySelectText: AllByBoundAttribute,
+    queryBySelectText: QueryByBoundAttribute,
+    queryAllBySelectText: AllByBoundAttribute,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+
+    getByValue: GetByBoundAttribute,
+    getAllByValue: AllByBoundAttribute,
+    queryByValue: QueryByBoundAttribute,
+    queryAllByValue: AllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: HTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLDivElement,
+    unmount: () => void,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (baseElement?: HTMLElement) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptions = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    queries?: any,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare module.exports: {
+    render(ui: React$Element<any>, options?: RenderOptions): RenderResult<>,
+
+    act: ReactDOMTestUtilsAct,
+    cleanup: () => void,
+    wait: (
+      callback?: () => void,
+      options?: {
+        timeout?: number,
+        interval?: number,
+        ...
+      }
+    ) => Promise<void>,
+    waitForDomChange: <T>(options?: {
+      container?: HTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    }) => Promise<T>,
+    waitForElement: <T>(
+      callback?: () => T,
+      options?: {
+        container?: HTMLElement,
+        timeout?: number,
+        mutationObserverOptions?: MutationObserverInit,
+        ...
+      }
+    ) => Promise<T>,
+    within: (
+      element: HTMLElement,
+      queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+    ) => GetsAndQueries,
+    fireEvent: {|
+      (element: HTMLElement, event: Event): void,
+
+      copy: FireEvent<Event$Init>,
+      cut: FireEvent<Event$Init>,
+      paste: FireEvent<Event$Init>,
+      compositionEnd: FireEvent<Event$Init>,
+      compositionStart: FireEvent<Event$Init>,
+      compositionUpdate: FireEvent<Event$Init>,
+      keyDown: FireEvent<Event$Init>,
+      keyPress: FireEvent<Event$Init>,
+      keyUp: FireEvent<Event$Init>,
+      focus: FireEvent<Event$Init>,
+      blur: FireEvent<Event$Init>,
+      change: FireEvent<Event$Init>,
+      input: FireEvent<Event$Init>,
+      invalid: FireEvent<Event$Init>,
+      submit: FireEvent<Event$Init>,
+      click: FireEvent<MouseEvent$MouseEventInit>,
+      contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+      dblClick: FireEvent<MouseEvent$MouseEventInit>,
+      doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+      drag: FireEvent<MouseEvent$MouseEventInit>,
+      dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+      dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+      dragExit: FireEvent<MouseEvent$MouseEventInit>,
+      dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+      dragOver: FireEvent<MouseEvent$MouseEventInit>,
+      dragStart: FireEvent<MouseEvent$MouseEventInit>,
+      drop: FireEvent<MouseEvent$MouseEventInit>,
+      mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+      mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+      mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+      mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+      mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+      mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+      mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+      select: FireEvent<Event$Init>,
+      touchCancel: FireEvent<Event$Init>,
+      touchEnd: FireEvent<Event$Init>,
+      touchMove: FireEvent<Event$Init>,
+      touchStart: FireEvent<Event$Init>,
+      scroll: FireEvent<Event$Init>,
+      wheel: FireEvent<MouseEvent$MouseEventInit>,
+      abort: FireEvent<Event$Init>,
+      canPlay: FireEvent<Event$Init>,
+      canPlayThrough: FireEvent<Event$Init>,
+      durationChange: FireEvent<Event$Init>,
+      emptied: FireEvent<Event$Init>,
+      encrypted: FireEvent<Event$Init>,
+      ended: FireEvent<Event$Init>,
+      loadedData: FireEvent<Event$Init>,
+      loadedMetadata: FireEvent<Event$Init>,
+      loadStart: FireEvent<Event$Init>,
+      pause: FireEvent<Event$Init>,
+      play: FireEvent<Event$Init>,
+      playing: FireEvent<Event$Init>,
+      progress: FireEvent<Event$Init>,
+      rateChange: FireEvent<Event$Init>,
+      seeked: FireEvent<Event$Init>,
+      seeking: FireEvent<Event$Init>,
+      stalled: FireEvent<Event$Init>,
+      suspend: FireEvent<Event$Init>,
+      timeUpdate: FireEvent<Event$Init>,
+      volumeChange: FireEvent<Event$Init>,
+      waiting: FireEvent<Event$Init>,
+      load: FireEvent<Event$Init>,
+      error: FireEvent<Event$Init>,
+      animationStart: FireEvent<Event$Init>,
+      animationEnd: FireEvent<Event$Init>,
+      animationIteration: FireEvent<Event$Init>,
+      transitionEnd: FireEvent<Event$Init>,
+    |},
+    // dom-testing-library re-exports
+    queryByTestId: (
+      container: HTMLElement,
+      id: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByTestId: (
+      container: HTMLElement,
+      id: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    queryByText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: { selector?: string, ... } & TextMatchOptions
+    ) => HTMLElement,
+    queryByPlaceholderText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByPlaceholderText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    queryByLabelText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByLabelText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: { selector?: string, ... } & TextMatchOptions
+    ) => HTMLElement,
+    queryByAltText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByAltText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    ...
+  };
+}
diff --git a/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/test_react_v8.x.x.js b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/test_react_v8.x.x.js
new file mode 100644
index 0000000000..b2d8845e35
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v8.x.x/flow_v0.201.x-/test_react_v8.x.x.js
@@ -0,0 +1,1121 @@
+// @flow
+
+import React from 'react';
+import {
+  act,
+  render,
+  wait,
+  fireEvent,
+  cleanup,
+  waitForDomChange,
+  waitForElement,
+  within,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: resolve => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(() => {}, () => {});
+  });
+});
+
+describe('wait', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    wait(1);
+    // $FlowExpectedError[incompatible-call]
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForDomChange', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange('1');
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForDomChange({ container: document.createElement('div') });
+    waitForDomChange({ timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async n => {
+    const usernameElement = await waitForElement(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByAltText('1');
+    const b: Array<HTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByAltText('1');
+    const b: Array<HTMLElement> = queryAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: HTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByDisplayValue('1');
+    const b: Array<HTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByDisplayValue('1');
+    const b: ?HTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByDisplayValue('1');
+    const b: Array<HTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByLabelText('1');
+    const b: Array<HTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByLabelText('1');
+    const b: Array<HTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    const a: HTMLElement = getByRole('1');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByRole('1');
+    const b: Array<HTMLElement> = getAllByRole('2');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByRole('1');
+    const b: ?HTMLElement = queryByRole('2');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByRole('1');
+    const b: Array<HTMLElement> = queryAllByRole('2');
+  });
+
+  it('getBySelectText should return HTML element', () => {
+    const a: HTMLElement = getBySelectText('1');
+  });
+
+  it('getAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllBySelectText('1');
+    const b: Array<HTMLElement> = getAllBySelectText('2');
+  });
+
+  it('queryBySelectText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryBySelectText('1');
+    const b: ?HTMLElement = queryBySelectText('2');
+  });
+
+  it('queryAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllBySelectText('1');
+    const b: Array<HTMLElement> = queryAllBySelectText('2');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTestId('1');
+    const b: Array<HTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTestId('1');
+    const b: Array<HTMLElement> = queryAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByText('1');
+    const b: Array<HTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByText('1');
+    const b: Array<HTMLElement> = queryAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: HTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTitle('1');
+    const b: Array<HTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTitle('1');
+    const b: ?HTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTitle('1');
+    const b: Array<HTMLElement> = queryAllByTitle('2');
+  });
+
+  it('getByValue should return HTML element', () => {
+    const a: HTMLElement = getByValue('1');
+  });
+
+  it('getAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByValue('1');
+    const b: Array<HTMLElement> = getAllByValue('2');
+  });
+
+  it('queryByValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByValue('1');
+    const b: ?HTMLElement = queryByValue('2');
+  });
+
+  it('queryAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByValue('1');
+    const b: Array<HTMLElement> = queryAllByValue('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('1');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('1');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('1');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('1');
+  });
+
+  it('should have getBySelectText', () => {
+    within(container).getBySelectText('1');
+  });
+
+  it('should have getAllBySelectText', () => {
+    within(container).getAllBySelectText('1');
+  });
+
+  it('should have queryBySelectText', () => {
+    within(container).queryBySelectText('1');
+  });
+
+  it('should have queryAllBySelectText', () => {
+    within(container).queryAllBySelectText('1');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have getByValue', () => {
+    within(container).getByValue('1');
+  });
+
+  it('should have getAllByValue', () => {
+    within(container).getAllByValue('1');
+  });
+
+  it('should have queryByValue', () => {
+    within(container).queryByValue('1');
+  });
+
+  it('should have queryAllByValue', () => {
+    within(container).queryAllByValue('1');
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept text match arguments', () => {
+    getByRole('1');
+    getByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByRole(/1/);
+    getByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByRole('1');
+  });
+
+  it('queryByRole should accept text match arguments', () => {
+    queryByRole('1');
+    queryByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole(/1/);
+    queryByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByRole('1');
+  });
+
+  it('getBySelectText should accept text match arguments', () => {
+    getBySelectText('1');
+    getBySelectText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText(/1/);
+    getBySelectText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText((content: string, element) => true);
+    getBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllBySelectText('1');
+  });
+
+  it('queryBySelectText should accept text match arguments', () => {
+    queryBySelectText('1');
+    queryBySelectText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText(/1/);
+    queryBySelectText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText((content: string, element) => true);
+    queryBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllBySelectText('1');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTitle('1');
+  });
+
+  it('getByValue should accept text match arguments', () => {
+    getByValue('1');
+    getByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByValue(/1/);
+    getByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByValue((content: string, element) => true);
+    getByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByValue('1');
+  });
+
+  it('queryByValue should accept text match arguments', () => {
+    queryByValue('1');
+    queryByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue(/1/);
+    queryByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue((content: string, element) => true);
+    queryByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByValue('1');
+  });
+});
diff --git a/definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-/react_v9.x.x.js b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-v.200.x/react_v9.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-/react_v9.x.x.js
rename to definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-v.200.x/react_v9.x.x.js
diff --git a/definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-/test_react_v9.x.x.js b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-v.200.x/test_react_v9.x.x.js
similarity index 100%
rename from definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-/test_react_v9.x.x.js
rename to definitions/npm/@testing-library/react_v9.x.x/flow_v0.104.x-v.200.x/test_react_v9.x.x.js
diff --git a/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/react_v9.x.x.js b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/react_v9.x.x.js
new file mode 100644
index 0000000000..249f0398f2
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/react_v9.x.x.js
@@ -0,0 +1,308 @@
+declare module '@testing-library/react' {
+  // This type comes from react-dom_v17.x.x.js
+  declare interface ReactDOMTestUtilsThenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed;
+  }
+
+  // This type comes from react-dom_v17.x.x.js
+  declare type ReactDOMTestUtilsAct = (
+    callback: () => void | ReactDOMTestUtilsThenable
+  ) => ReactDOMTestUtilsThenable;
+
+  declare type TextMatch =
+    | string
+    | RegExp
+    | ((content: string, element: HTMLElement) => boolean);
+
+  declare type TextMatchOptions = {
+    exact?: boolean,
+    trim?: boolean,
+    collapseWhitespace?: boolean,
+    ...
+  };
+
+  declare type SelectorMatchOptions = {
+    selector?: string,
+    ...
+  } & TextMatchOptions;
+
+  declare type GetByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetsAndQueries = {|
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+
+    getByRole: GetByBoundAttribute,
+    getAllByRole: AllByBoundAttribute,
+    queryByRole: QueryByBoundAttribute,
+    queryAllByRole: AllByBoundAttribute,
+
+    getBySelectText: GetByBoundAttribute,
+    getAllBySelectText: AllByBoundAttribute,
+    queryBySelectText: QueryByBoundAttribute,
+    queryAllBySelectText: AllByBoundAttribute,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+
+    getByValue: GetByBoundAttribute,
+    getAllByValue: AllByBoundAttribute,
+    queryByValue: QueryByBoundAttribute,
+    queryAllByValue: AllByBoundAttribute,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: HTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare type RenderResult<Queries = GetsAndQueries> = {
+    ...Queries,
+    container: HTMLDivElement,
+    unmount: () => void,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (baseElement?: HTMLElement) => void,
+    rerender: (ui: React$Element<any>) => void,
+    ...
+  };
+
+  declare export type RenderOptionsWithoutCustomQueries = {|
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export type RenderOptionsWithCustomQueries<
+    CustomQueries: { ... }
+  > = {|
+    queries: CustomQueries,
+    container?: HTMLElement,
+    baseElement?: HTMLElement,
+    hydrate?: boolean,
+    wrapper?: React$ComponentType<any>,
+  |};
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: RenderOptionsWithoutCustomQueries
+  ): RenderResult<>;
+  declare export function render<
+    CustomQueries: { [string]: (...args: Array<any>) => any, ... }
+  >(
+    ui: React$Element<any>,
+    options: RenderOptionsWithCustomQueries<CustomQueries>
+  ): RenderResult<CustomQueries>;
+
+  declare export var act: ReactDOMTestUtilsAct;
+  declare export function cleanup(): void;
+  declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    }
+  ): Promise<void>;
+  declare export function waitForDomChange<T>(options?: {
+    container?: HTMLElement,
+    timeout?: number,
+    mutationObserverOptions?: MutationObserverInit,
+    ...
+  }): Promise<T>;
+  declare export function waitForElement<T>(
+    callback?: () => T,
+    options?: {
+      container?: HTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    }
+  ): Promise<T>;
+  declare export function within(
+    element: HTMLElement,
+    queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+  ): GetsAndQueries;
+  declare export var fireEvent: {|
+    (element: HTMLElement, event: Event): void,
+
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+  |};
+  // dom-testing-library re-exports
+  declare export function queryByTestId(
+    container: HTMLElement,
+    id: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByTestId(
+    container: HTMLElement,
+    id: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: { selector?: string, ... } & TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByPlaceholderText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByPlaceholderText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByLabelText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByLabelText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: { selector?: string, ... } & TextMatchOptions
+  ): HTMLElement;
+  declare export function queryByAltText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): ?HTMLElement;
+  declare export function getByAltText(
+    container: HTMLElement,
+    text: TextMatch,
+    options?: TextMatchOptions
+  ): HTMLElement;
+}
diff --git a/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/test_react_v9.x.x.js b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/test_react_v9.x.x.js
new file mode 100644
index 0000000000..a5c48a5d7f
--- /dev/null
+++ b/definitions/npm/@testing-library/react_v9.x.x/flow_v0.201.x-/test_react_v9.x.x.js
@@ -0,0 +1,1154 @@
+// @flow
+
+import React from 'react';
+import {
+  act,
+  render,
+  wait,
+  fireEvent,
+  cleanup,
+  waitForDomChange,
+  waitForElement,
+  within,
+} from '@testing-library/react';
+import { describe, it } from 'flow-typed-test';
+
+describe('act', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    act(1);
+    // $FlowExpectedError[extra-arg]
+    act(() => {}, 1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    act(() => {});
+    act(() => Promise.resolve());
+    act(() => ({
+      then: resolve => {},
+    }));
+  });
+
+  it('should fail on incorrect usage of result', () => {
+    // $FlowExpectedError[incompatible-type]
+    act(() => {}) + 1;
+    // $FlowExpectedError[prop-missing]
+    act(() => {}).doesNotExist();
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(1);
+    // $FlowExpectedError[incompatible-call]
+    act(() => {}).then(() => {}, 1);
+  });
+
+  it('should pass on correct usage of result', () => {
+    act(() => {}).then(() => {});
+    act(() => {}).then(() => {}, () => {});
+  });
+});
+
+describe('wait', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    wait(1);
+    // $FlowExpectedError[incompatible-call]
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForDomChange', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange('1');
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForDomChange({ container: document.createElement('div') });
+    waitForDomChange({ timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async n => {
+    const usernameElement = await waitForElement(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  });
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByAltText('1');
+    const b: Array<HTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByAltText('1');
+    const b: Array<HTMLElement> = queryAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: HTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByDisplayValue('1');
+    const b: Array<HTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByDisplayValue('1');
+    const b: ?HTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByDisplayValue('1');
+    const b: Array<HTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByLabelText('1');
+    const b: Array<HTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByLabelText('1');
+    const b: Array<HTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    const a: HTMLElement = getByRole('1');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByRole('1');
+    const b: Array<HTMLElement> = getAllByRole('2');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByRole('1');
+    const b: ?HTMLElement = queryByRole('2');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByRole('1');
+    const b: Array<HTMLElement> = queryAllByRole('2');
+  });
+
+  it('getBySelectText should return HTML element', () => {
+    const a: HTMLElement = getBySelectText('1');
+  });
+
+  it('getAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllBySelectText('1');
+    const b: Array<HTMLElement> = getAllBySelectText('2');
+  });
+
+  it('queryBySelectText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryBySelectText('1');
+    const b: ?HTMLElement = queryBySelectText('2');
+  });
+
+  it('queryAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllBySelectText('1');
+    const b: Array<HTMLElement> = queryAllBySelectText('2');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTestId('1');
+    const b: Array<HTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTestId('1');
+    const b: Array<HTMLElement> = queryAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByText('1');
+    const b: Array<HTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByText('1');
+    const b: Array<HTMLElement> = queryAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: HTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTitle('1');
+    const b: Array<HTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTitle('1');
+    const b: ?HTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTitle('1');
+    const b: Array<HTMLElement> = queryAllByTitle('2');
+  });
+
+  it('getByValue should return HTML element', () => {
+    const a: HTMLElement = getByValue('1');
+  });
+
+  it('getAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByValue('1');
+    const b: Array<HTMLElement> = getAllByValue('2');
+  });
+
+  it('queryByValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByValue('1');
+    const b: ?HTMLElement = queryByValue('2');
+  });
+
+  it('queryAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByValue('1');
+    const b: Array<HTMLElement> = queryAllByValue('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{ ... }> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('1');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('1');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('1');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('1');
+  });
+
+  it('should have getBySelectText', () => {
+    within(container).getBySelectText('1');
+  });
+
+  it('should have getAllBySelectText', () => {
+    within(container).getAllBySelectText('1');
+  });
+
+  it('should have queryBySelectText', () => {
+    within(container).queryBySelectText('1');
+  });
+
+  it('should have queryAllBySelectText', () => {
+    within(container).queryAllBySelectText('1');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have getByValue', () => {
+    within(container).getByValue('1');
+  });
+
+  it('should have getAllByValue', () => {
+    within(container).getAllByValue('1');
+  });
+
+  it('should have queryByValue', () => {
+    within(container).queryByValue('1');
+  });
+
+  it('should have queryAllByValue', () => {
+    within(container).queryAllByValue('1');
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{ ... }> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept text match arguments', () => {
+    getByRole('1');
+    getByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByRole(/1/);
+    getByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByRole('1');
+  });
+
+  it('queryByRole should accept text match arguments', () => {
+    queryByRole('1');
+    queryByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole(/1/);
+    queryByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByRole('1');
+  });
+
+  it('getBySelectText should accept text match arguments', () => {
+    getBySelectText('1');
+    getBySelectText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText(/1/);
+    getBySelectText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText((content: string, element) => true);
+    getBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllBySelectText('1');
+  });
+
+  it('queryBySelectText should accept text match arguments', () => {
+    queryBySelectText('1');
+    queryBySelectText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText(/1/);
+    queryBySelectText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText((content: string, element) => true);
+    queryBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllBySelectText('1');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTitle('1');
+  });
+
+  it('getByValue should accept text match arguments', () => {
+    getByValue('1');
+    getByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByValue(/1/);
+    getByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByValue((content: string, element) => true);
+    getByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByValue('1');
+  });
+
+  it('queryByValue should accept text match arguments', () => {
+    queryByValue('1');
+    queryByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue(/1/);
+    queryByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue((content: string, element) => true);
+    queryByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByValue('1');
+  });
+});
+
+describe('render() parameters', () => {
+  class Component extends React.Component<{ ... }> {}
+
+  it('allows supplying parameters to render()', () => {
+    class CustomWrapper extends React.Component<{ ... }> {}
+    const element = document.createElement('div');
+    render(<Component />, {
+      baseElement: element,
+      container: element,
+      hydrate: true,
+      wrapper: CustomWrapper,
+    });
+  });
+
+  it('allows overriding render() with custom queries', () => {
+    type CustomReturnType = 123456;
+    declare var customValue: CustomReturnType;
+    const customQueries = {
+      getByOverride: (param1: string) => customValue,
+    };
+    const result = render<{|
+      getByOverride: (string) => CustomReturnType,
+    |}>(<Component />, { queries: customQueries });
+    const a: CustomReturnType = result.getByOverride('something');
+    // $FlowExpectedError[incompatible-call] bad type for getByOverride parameter
+    result.getByOverride(1234);
+    // $FlowExpectedError[incompatible-call] missing getByOverride parameter
+    result.getByOverride();
+    // $FlowExpectedError[prop-missing] default queries are not available when using custom queries
+    result.getByTestId('indifferent');
+  });
+});
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/angular_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/angular_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/angular_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/angular_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_component_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_component_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_component_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_component_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_interval_log_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_interval_log_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_interval_log_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_interval_log_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_scope_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_scope_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_scope_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_scope_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_stateProvider_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_stateProvider_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_stateProvider_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_stateProvider_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_timeout_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_timeout_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_timeout_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_timeout_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_angular_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_angular_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_utility_functions_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_utility_functions_v1.5.x.js
similarity index 100%
rename from definitions/npm/angular_v1.5.x/flow_v0.104.x-/test_utility_functions_v1.5.x.js
rename to definitions/npm/angular_v1.5.x/flow_v0.104.x-v.200.x/test_utility_functions_v1.5.x.js
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/angular_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/angular_v1.5.x.js
new file mode 100644
index 0000000000..7ee701b2cf
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/angular_v1.5.x.js
@@ -0,0 +1,302 @@
+/**
+ * Credit to @faceleg for some of the typedefs seen here:
+ * https://github.com/solnet-aquarium/flow-interfaces-angular/blob/master/interfaces/angular.js
+ */
+
+declare module angular {
+  // NOTE: if you don't use named scope bindings, remove string type in the end
+  // for stricter types
+  declare type ScopeBindings = "<" | "=" | "&" | "<?" | "=?" | "&?" | string;
+  declare type Scope = { [key: string]: ScopeBindings, ... };
+  declare type ControllerFunction = (...a: Array<any>) => void;
+
+  // I'm not sure how represent this properly: Angular DI declarations are a
+  // list of strings with a single function at the end. The function can vary,
+  // so it is a type param.
+  //
+  // NOTE: if you use compile step to mangle array, replace below with
+  // declare type $npm$angular$DependencyInjection<T> = T
+  declare type $npm$angular$DependencyInjection<T> = Array<string | T>;
+
+  // Extending Array<Element> allows us to do the `jq[0]` expression and friends
+  // to get the actual underlying Element.
+  // TODO: This is supposed to be interchangeable with JQuery. Can we possibly
+  // check to see if JQuery's types are already defined?
+  declare interface JqliteElement extends Array<Element> {
+    remove: () => JqliteElement;
+    contents: () => JqliteElement;
+    injector: Function;
+  }
+
+  declare type AngularLinkFunction = (
+    scope: $Scope<any>,
+    element: JqliteElement,
+    attrs: mixed,
+    controller: mixed
+  ) => void;
+
+  declare type AngularCompileLink = {
+    post?: AngularLinkFunction,
+    pre?: AngularLinkFunction,
+    ...
+  };
+
+  // TODO: Attrs and controller should be properly typed.
+  declare function CompileFunction(
+    element: JqliteElement,
+    attrs: mixed,
+    controller: ControllerFunction
+  ): AngularLinkFunction;
+
+  // TODO: Expand to cover the whole matrix of AECM, in any order. Probably
+  // should write something to handle it.
+  declare type DirectiveRestrict = "A" | "E" | "AE" | "EA";
+  declare type Directive = {|
+    restrict?: DirectiveRestrict,
+    template?: string,
+    templateUrl?: string,
+    scope?: Scope,
+    controller?: ControllerFunction,
+    link?: AngularLinkFunction,
+    controllerAs?: string,
+    bindToController?: boolean,
+    // TODO: flesh out this definition
+    compile?: (...a: any) => AngularCompileLink
+  |};
+
+  declare type DirectiveDeclaration = (
+    name: string,
+    di: $npm$angular$DependencyInjection<(...a: Array<any>) => Directive>
+  ) => AngularModule;
+
+  declare type Component = {|
+    bindings?: Scope,
+    template?: string,
+    templateUrl?: string,
+    controllerAs?: string,
+    controller?: $npm$angular$DependencyInjection<
+      Class<any> | ControllerFunction
+    >,
+    transclude?: boolean
+  |};
+
+  declare type ComponentDeclaration = (
+    name: string,
+    component: Component
+  ) => AngularModule;
+
+  declare type ControllerDeclaration = (
+    name: string,
+    di: $npm$angular$DependencyInjection<ControllerFunction>
+  ) => AngularModule;
+
+  declare type ConfigDeclaration = (
+    di: $npm$angular$DependencyInjection<(...a: Array<any>) => void>
+  ) => AngularModule;
+
+  declare type FactoryDeclaration = (
+    name: string,
+    di: $npm$angular$DependencyInjection<(...a: Array<any>) => {...}>
+  ) => AngularModule;
+
+  declare type FilterDeclaration = (
+    name: string,
+    di: $npm$angular$DependencyInjection<(...a: Array<any>) => (: any => any)>
+  ) => AngularModule;
+
+  declare type ServiceDeclaration = (
+    name: string,
+    di: $npm$angular$DependencyInjection<(...a: Array<any>) => (: any => any) | {...}>
+  ) => AngularModule;
+
+  declare type RunDeclaration = (
+    fn: $npm$angular$DependencyInjection<(...a: Array<any>) => void>
+  ) => AngularModule;
+
+  declare type ValueDeclaration = (name: string, value: mixed) => AngularModule;
+
+  declare type ConstantDeclaration = (
+    name: string,
+    value: mixed
+  ) => AngularModule;
+
+  declare type AngularModule = {|
+    controller: ControllerDeclaration,
+    component: ComponentDeclaration,
+    directive: DirectiveDeclaration,
+    run: RunDeclaration,
+    config: ConfigDeclaration,
+    factory: FactoryDeclaration,
+    filter: FilterDeclaration,
+    service: ServiceDeclaration,
+    value: ValueDeclaration,
+    constant: ConstantDeclaration,
+    name: string
+  |};
+
+  declare type Dependency = AngularModule | string;
+
+  declare function module(
+    name: string,
+    deps?: ?Array<Dependency>
+  ): AngularModule;
+
+  declare function element(html: string | Element | Document): JqliteElement;
+  declare function copy<T>(object: T): T;
+  declare function extend<A, B>(a: A, b: B): A & B;
+  declare function extend<A, B, C>(a: A, b: B, c: C): A & B & C;
+  declare function extend<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
+  declare function extend<A, B, C, D, E>(
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    e: E
+  ): A & B & C & D & E;
+
+  declare function forEach<T>(
+    obj: {...},
+    iterator: (value: T, key: string) => void
+  ): void;
+  declare function forEach<T>(
+    obj: Array<T>,
+    iterator: (value: T, key: number) => void
+  ): void;
+  declare function fromJson(json: string): {...} | Array<any> | string | number;
+  declare function toJson(
+    obj: {...} | Array<any> | string | Date | number | boolean,
+    pretty?: boolean | number
+  ): string;
+  declare function isDefined(val: any): boolean;
+  declare function isArray(value: Array<any>): true;
+  declare function isArray(value: any): false;
+  declare function noop(): void;
+  declare type AngularQ = { when: <T>(value: T) => AngularPromise<T>, ... };
+
+  declare type AngularPromise<T> = {
+    then: <U>(a: (resolve: U) => T) => AngularPromise<any>,
+    catch: <U>(a: (e: Error) => U) => AngularPromise<any>,
+    finally: <U>(a: (result: U | typeof Error) => T) => AngularPromise<any>,
+    ...
+  };
+
+  //****************************************************************************
+  // Angular testing tools
+  //****************************************************************************
+
+  declare type AngularMock = {
+    inject: (...a: Array<any>) => (: any => any),
+    module: (...a: Array<string | (: (...args: Array<any>) => any) | {...}>) => () => void,
+    ...
+  };
+  declare var mock: AngularMock;
+
+  declare type StateProviderParams = {
+    url?: string,
+    abstract?: boolean,
+    params?: {...},
+    views?: {...},
+    data?: {...},
+    templateUrl?: string,
+    template?: string,
+    controller?: string | ControllerFunction,
+    resolve?: {...},
+    ...
+  };
+
+  declare type $StateProvider = { state: (name: string, conf: StateProviderParams) => $StateProvider, ... };
+
+  //----------------------------------------------------------------------------
+  // Service specific stuff
+  //----------------------------------------------------------------------------
+
+  declare type AngularHttpService = { post: AngularHttpPost<any>, ... };
+
+  declare type AngularHttpPost<T> = (
+    url: string,
+    data: mixed
+  ) => AngularPromise<T>;
+
+  declare type AngularResourceResult<T> = { $promise: AngularPromise<T>, ... };
+
+  declare type AngularResource = { get: <T>(options?: {...}, callback?: Function) => AngularResourceResult<T>, ... };
+
+  declare function AngularResourceFactory(
+    url: string,
+    defaultParams?: {...},
+    actions?: {...},
+    options?: {...}
+  ): AngularResource;
+
+  declare function AngularCompileService(a: JqliteElement): JqliteElement;
+
+  declare type WatchExpression<T> = string | ((scope: $Scope<T>) => any);
+  declare type EvalExpression = string | (() => void);
+  declare type ApplyExpression = string | (() => void);
+  declare type Listener<T> = (
+    newValue: any,
+    oldValue: any,
+    $scope: $Scope<T>
+  ) => any;
+
+  declare type _Watch1<T> = (
+    expression: WatchExpression<T>,
+    listener: Listener<T>,
+    objectEquality?: boolean
+  ) => () => void;
+  declare type _Watch2<T> = (
+    listener: Listener<T>,
+    objectEquality?: boolean
+  ) => () => void;
+
+  declare type $Scope<T: {...}> = {|
+    $new(isolate: boolean, parent: $Scope<T>): $Scope<T>,
+    $watch: _Watch1<T> & _Watch2<T>,
+    $watchGroup(
+      expressions: Array<WatchExpression<T>>,
+      listener: Listener<T>
+    ): () => void,
+    $watchCollection(
+      expression: WatchExpression<T>,
+      listener: Listener<T>
+    ): () => void,
+    $digest(): void,
+    $destroy(): void,
+    $eval(expression: EvalExpression, locals?: {...}): void,
+    $evalAsync(expression: EvalExpression, locals?: {...}): void,
+    $apply(expression?: ApplyExpression): void,
+    $applyAsync(expression?: ApplyExpression): void,
+    $on(name: string, listener: (event: any, ...Array<any>) => void): () => void,
+    $emit(name: string, ...Array<any>): void,
+    $broadcast(name: string, ...Array<any>): void,
+
+    $$postDigest(cb: () => void): void,
+
+    $id: string,
+    $parent: $Scope<any>,
+    $root: $Scope<any>
+  |} & T;
+
+  declare type $Timeout = (
+    fn?: any => any,
+    delay?: number,
+    invokeApply?: boolean,
+    additionalParams?: any
+  ) => AngularPromise<any>;
+
+  declare type $Log = {|
+    log(a: any): void,
+    info(a: any): void,
+    warn(a: any): void,
+    error(a: any): void,
+    debug(a: any): void,
+  |};
+
+  declare type $Interval = (
+    fn: any => any,
+    delay: number,
+    count?: number,
+    invokeApply?: boolean,
+    ...pass: any
+  ) => AngularPromise<any>;
+}
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_component_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_component_v1.5.x.js
new file mode 100644
index 0000000000..bca576a86f
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_component_v1.5.x.js
@@ -0,0 +1,87 @@
+// @flow
+import angular from "angular";
+
+//all bells and whistles
+angular.module("foo", []).component("foo", {
+  bindings: {
+    prop: "<"
+  },
+  template: "<div></div>",
+  controllerAs: "ctrl",
+  controller: ["foo", "bar", () => {}],
+  transclude: false
+});
+
+//bindings can have strings
+angular.module("foo", []).component("foo", {
+  bindings: {
+    prop: "<"
+  }
+});
+
+//$FlowExpectedError bindings cant have any other types
+angular.module("foo", []).component("foo", {
+  bindings: {
+    prop: 123
+  }
+});
+
+// template is string
+angular.module("foo", []).component("foo", {
+  template: "<div></div>"
+});
+
+//$FlowExpectedError template does snot accept other types
+angular.module("foo", []).component("foo", {
+  template: 123
+});
+
+//controllerAs is string
+angular.module("foo", []).component("foo", {
+  controllerAs: "ctrl"
+});
+
+//$FlowExpectedError controllerAs does snot accept other types
+angular.module("foo", []).component("foo", {
+  controllerAs: 123
+});
+
+// transclude is boolean
+angular.module("foo", []).component("foo", {
+  transclude: true
+});
+
+//$FlowExpectedError transclude does snot accept other types
+angular.module("foo", []).component("foo", {
+  transclude: 123
+});
+
+// templateUrl is string
+angular.module("foo", []).component("foo", {
+  templateUrl: "path/to/template.html"
+});
+
+//$FlowExpectedError template doe snot accept other types
+angular.module("foo", []).component("foo", {
+  templateUrl: 123
+});
+
+//controller accpets class
+angular.module("foo", []).component("foo", {
+  controller: ["foo", "bar", class Ctrl {}]
+});
+
+//controller accpets controller function
+angular.module("foo", []).component("foo", {
+  controller: ["foo", "bar", () => {}]
+});
+
+//$FlowExpectedError does not accept object as controller
+angular.module("foo", []).component("foo", {
+  controller: ["foo", "bar", {}]
+});
+
+//$FlowExpectedError does not accept arbitrary properties
+angular.module("foo", []).component("foo", {
+  random: "prop"
+});
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_interval_log_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_interval_log_v1.5.x.js
new file mode 100644
index 0000000000..8c518e6ef7
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_interval_log_v1.5.x.js
@@ -0,0 +1,215 @@
+// @flow
+import type { $Interval, $Log, AngularPromise } from 'angular';
+import { describe, it } from 'flow-typed-test';
+
+describe('angular $Interval', () => {
+  it('can be called', () => {
+    it('with two args: fn, delay', () => {
+      function testInterval($interval: $Interval) {
+        $interval(() => {}, 0);
+      }
+    });
+
+    it('with third argument as number', () => {
+      function testInterval($interval: $Interval) {
+        $interval(() => {}, 0, 1);
+      }
+    });
+
+    it('with fourth argument as boolean', () => {
+      function testInterval($interval: $Interval) {
+        $interval(() => {}, 0, 1, true);
+      }
+    });
+
+    it('with additional arguments to be passed to the function', () => {
+      function testInterval($interval: $Interval) {
+        $interval((a, b, c) => {}, 0, 1, false, 'a', 'b', 'c');
+      }
+    });
+  });
+
+  it('cannot be called', () => {
+    it('with something other than a number in the third argument', () => {
+      function testInterval($interval: $Interval) {
+        //$FlowExpectedError
+        $interval(() => {}, 0, true);
+      }
+    });
+
+    it('with something other than a boolean in the fourth argument', () => {
+      function testInterval($interval: $Interval) {
+        //$FlowExpectedError
+        $interval(() => {}, 0, 1, 2);
+      }
+    });
+
+    it('with less than two arguments', () => {
+      function testInterval($interval: $Interval) {
+        //$FlowExpectedError
+        $interval(() => {});
+        //$FlowExpectedError
+        $interval();
+      }
+    });
+
+    it('with something other than [function, number] in first two arguments', () => {
+      function testInterval($interval: $Interval) {
+        //$FlowExpectedError
+        $interval(123, 1);
+        //$FlowExpectedError
+        $interval(123, () => {});
+        //$FlowExpectedError
+        $interval(() => {}, 'string');
+      }
+    });
+  });
+
+  it('returns back the angular promise', () => {
+    function testInterval($interval: $Interval) {
+      ($interval(() => {}, 0): AngularPromise<any>);
+    }
+  });
+});
+
+describe('angular $Log', () => {
+  describe('log', () => {
+    it('can be passed an argument of any type or none at all', () => {
+      function testLog($log: $Log) {
+        $log.log('anything');
+        $log.log(1);
+        $log.log(() => {});
+        $log.log(null);
+        $log.log({ a: 1 });
+        $log.log(['a', 1, 3, { a: 10 }]);
+        $log.log(Symbol('test'));
+        $log.log();
+      }
+    });
+
+    it('cannot pass more than one argument', () => {
+      function testLog($log: $Log) {
+        //$FlowExpectedError
+        $log.log(1, 'x');
+      }
+    });
+
+    it('returns back nothing', () => {
+      function testLog($log: $Log) {
+        ($log.log(1): void);
+      }
+    });
+  });
+
+  describe('info', () => {
+    it('can be passed an argument of any type or none at all', () => {
+      function testLog($log: $Log) {
+        $log.info('anything');
+        $log.info(1);
+        $log.info(() => {});
+        $log.info(null);
+        $log.info({ a: 1 });
+        $log.info(['a', 1, 3, { a: 10 }]);
+        $log.info(Symbol('test'));
+        $log.info();
+      }
+    });
+
+    it('cannot pass more than one argument', () => {
+      function testLog($log: $Log) {
+        //$FlowExpectedError
+        $log.info(1, 'x');
+      }
+    });
+
+    it('returns back nothing', () => {
+      function testLog($log: $Log) {
+        ($log.info(1): void);
+      }
+    });
+  });
+
+  describe('warn', () => {
+    it('can be passed an argument of any type or none at all', () => {
+      function testLog($log: $Log) {
+        $log.warn('anything');
+        $log.warn(1);
+        $log.warn(() => {});
+        $log.warn(null);
+        $log.warn({ a: 1 });
+        $log.warn(['a', 1, 3, { a: 10 }]);
+        $log.warn(Symbol('test'));
+        $log.warn();
+      }
+    });
+
+    it('cannot pass more than one argument', () => {
+      function testLog($log: $Log) {
+        //$FlowExpectedError
+        $log.warn(1, 'x');
+      }
+    });
+
+    it('returns back nothing', () => {
+      function testLog($log: $Log) {
+        ($log.warn(1): void);
+      }
+    });
+  });
+
+  describe('error', () => {
+    it('can be passed an argument of any type or none at all', () => {
+      function testLog($log: $Log) {
+        $log.error('anything');
+        $log.error(1);
+        $log.error(() => {});
+        $log.error(null);
+        $log.error({ a: 1 });
+        $log.error(['a', 1, 3, { a: 10 }]);
+        $log.error(Symbol('test'));
+        $log.error();
+      }
+    });
+
+    it('cannot pass more than one argument', () => {
+      function testLog($log: $Log) {
+        //$FlowExpectedError
+        $log.error(1, 'x');
+      }
+    });
+
+    it('returns back nothing', () => {
+      function testLog($log: $Log) {
+        ($log.error(1): void);
+      }
+    });
+  });
+
+  describe('debug', () => {
+    it('can be passed an argument of any type or none at all', () => {
+      function testLog($log: $Log) {
+        $log.debug('anything');
+        $log.debug(1);
+        $log.debug(() => {});
+        $log.debug(null);
+        $log.debug({ a: 1 });
+        $log.debug(['a', 1, 3, { a: 10 }]);
+        $log.debug(Symbol('test'));
+        $log.debug();
+      }
+    });
+
+    it('cannot pass more than one argument', () => {
+      function testLog($log: $Log) {
+        //$FlowExpectedError
+        $log.debug(1, 'x');
+      }
+    });
+
+    it('returns back nothing', () => {
+      function testLog($log: $Log) {
+        ($log.debug(1): void);
+      }
+    });
+  });
+});
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_scope_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_scope_v1.5.x.js
new file mode 100644
index 0000000000..9676dd40f0
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_scope_v1.5.x.js
@@ -0,0 +1,237 @@
+// @flow
+import type { $Scope } from "angular";
+
+function testScope$new($scope: $Scope<{ myVar: boolean, ... }>) {
+  //$FlowExpectedError first argument needs to be boolean
+  $scope.$new(123, $scope);
+  //$FlowExpectedError second argument needs to be scope
+  $scope.$new(true, {});
+
+  const newScope = $scope.$new(true, $scope);
+  (newScope.myVar: boolean);
+}
+
+function testScope$watch($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$watch("my.prop", () => {});
+  //$FlowExpectedError does not accept other than watch funcion or string as first argument
+  $scope.$watch(123, () => {});
+  // is ok with callback as first argument
+  $scope.$watch(() => {}, () => {});
+  // watcher function gets current scope
+  $scope.$watch(
+    scope => {
+      (scope.myVar: boolean);
+    },
+    () => {}
+  );
+  // watch callback gets current scope as third param
+  $scope.$watch("prop", (var1, var2, scope) => {
+    (scope.myVar: boolean);
+  });
+
+  // watch accepts object equality boolean as last param
+  $scope.$watch("prop", () => {}, true);
+
+  //$FlowExpectedError watch does not accept other types as third param
+  $scope.$watch("prop", () => {}, "");
+
+  //watch accepts listener callback also as first argument
+  $scope.$watch((var1, var2, scope) => {
+    (scope.myVar: boolean);
+  });
+
+  // takes object equality as second argument
+  $scope.$watch(() => {}, true);
+  //$FlowExpectedError watch does not accept other types as second param
+  $scope.$watch(() => {}, "");
+}
+
+function testScope$watchGroup($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes array strings as first argument
+  $scope.$watchGroup(["first", "second"], () => {});
+  // takes array of watch functions as first argument
+  $scope.$watchGroup(
+    [
+      scope => {
+        (scope.myVar: boolean);
+      }
+    ],
+    () => {}
+  );
+  //$FlowExpectedError does not take anything else as array arguments
+  $scope.$watchGroup([123], () => {});
+
+  //listener gets current scope
+  $scope.$watchGroup(["prop"], (var1, var2, scope) => {
+    (scope.myVar: boolean);
+  });
+  //$FlowExpectedError listener fails when trying to access scope as wrong type
+  $scope.$watchGroup(["prop"], (var1, var2, scope: boolean) => scope);
+
+  //returns function
+  const ret = $scope.$watchGroup(["first"], () => {});
+  ret();
+
+  //$FlowExpectedError returned function does not take arguments
+  const ret2 = $scope.$watchGroup(["first"], () => {});
+  ret2(123);
+}
+
+function testScope$watchCollection($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$watchCollection("prop", () => {});
+  // takes watch function as first argument
+  $scope.$watchCollection(
+    scope => {
+      (scope.myVar: boolean);
+    },
+    () => {}
+  );
+  //$FlowExpectedError does not take any other type
+  $scope.$watchCollection(123, () => {});
+
+  //listener gets current scope
+  $scope.$watchCollection("prop", (var1, var2, scope) => {
+    (scope.myVar: boolean);
+  });
+  //$FlowExpectedError listener fails when trying to access scope as wrong type
+  $scope.$watchCollection("prop", (var1, var2, scope: boolean) => scope);
+
+  //returns function
+  const ret = $scope.$watchCollection("first", () => {});
+  ret();
+
+  //$FlowExpectedError returned function does not take arguments
+  const ret2 = $scope.$watchCollection("first", () => {});
+  ret2(123);
+}
+
+function testScope$Digest($scope: $Scope<{ myVar: boolean, ... }>) {
+  // is callable
+  $scope.$digest();
+  //$FlowExpectedError does not take arguments
+  $scope.$digest(123);
+}
+
+function testScope$Destroy($scope: $Scope<{ myVar: boolean, ... }>) {
+  // is callable
+  $scope.$digest();
+  //$FlowExpectedError does not take arguments
+  $scope.$digest(123);
+}
+
+function testScope$Eval($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$eval("str");
+  // takes function as first argument
+  $scope.$eval(() => {});
+  //$FlowExpectedError function does not get arguments
+  $scope.$eval((arg: number) => {});
+  // takes optional object as second argument
+  $scope.$eval(() => {}, {});
+  //$FlowExpectedError does not take other types as second argument
+  $scope.$eval(() => {}, 123);
+}
+
+function testScope$EvalAsync($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$evalAsync("str");
+  // takes function as first argument
+  $scope.$evalAsync(() => {});
+  //$FlowExpectedError function does not get arguments
+  $scope.$evalAsync((arg: number) => {});
+  // takes optional object as second argument
+  $scope.$eval(() => {}, {});
+  //$FlowExpectedError does not take other types as second argument
+  $scope.$evalAsync(() => {}, 123);
+}
+
+function testScope$apply($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$apply("str");
+  // takes function as first argument
+  $scope.$apply(() => {});
+  //$FlowExpectedError function does not get arguments
+  $scope.$apply((arg: number) => {});
+}
+
+function testScope$applyAsync($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$applyAsync("str");
+  // takes function as first argument
+  $scope.$applyAsync(() => {});
+  //$FlowExpectedError function does not get arguments
+  $scope.$applyAsync((arg: number) => {});
+}
+
+function testScope$on($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$on("str", () => {});
+  //$FlowExpectedError does not take other types as first argument
+  $scope.$on(123, () => {});
+  // callback takes arbitrary amount of args
+  $scope.$on("str", (a, b, c, d, e) => {});
+  //$FlowExpectedError does not take other types as second argument
+  $scope.$on("str", "str");
+  //returns deregistration callback
+  const cb = $scope.$on("str", () => {});
+  cb();
+  //$FlowExpectedError callback deos not take arguments
+  const cb2 = $scope.$on("str", () => {});
+  cb2(123);
+}
+
+function testScope$emit($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$emit("str", () => {});
+  //$FlowExpectedError does not take other types as first argument
+  $scope.$emit(123, () => {});
+  // takes arbitrary second argument
+  $scope.$emit("str", 123);
+  $scope.$emit("str", "abc");
+  // takes arbitrary amount of arguments
+  $scope.$emit("str", 123, 321, 123);
+  $scope.$emit("str", "abc", "abc", "abc", "abc");
+}
+
+function testScope$broadcast($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes string as first argument
+  $scope.$broadcast("str", () => {});
+  //$FlowExpectedError does not take other types as first argument
+  $scope.$broadcast(123, () => {});
+  // takes arbitrary second argument
+  $scope.$broadcast("str", 123);
+  $scope.$broadcast("str", "abc");
+  // takes arbitrary amount of arguments
+  $scope.$broadcast("str", 123, 321, 123);
+  $scope.$broadcast("str", "abc", "abc", "abc", "abc");
+}
+
+function testScope$$postDigest($scope: $Scope<{ myVar: boolean, ... }>) {
+  // takes callback
+  $scope.$$postDigest(() => {});
+  //$FlowExpectedError does not take other types
+  $scope.$$postDigest(123);
+  //$FlowExpectedError does not take more arguments
+  $scope.$$postDigest(() => {}, 123);
+}
+
+function testScope$id($scope: $Scope<{ myVar: boolean, ... }>) {
+  // is string
+  ($scope.$id: string);
+}
+
+function testScope$parent($scope: $Scope<{ myVar: boolean, ... }>) {
+  // is scope
+  ($scope.$parent: $Scope<any>);
+}
+
+function testScope$root($scope: $Scope<{ myVar: boolean, ... }>) {
+  // is scope
+  ($scope.$root: $Scope<any>);
+}
+
+function testScopeExtraProps($scope: $Scope<{ myVar: boolean, ... }>) {
+  $scope.myVar;
+}
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_stateProvider_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_stateProvider_v1.5.x.js
new file mode 100644
index 0000000000..a066257064
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_stateProvider_v1.5.x.js
@@ -0,0 +1,8 @@
+// @flow
+import type { $StateProvider, AngularPromise } from "angular";
+
+function testStateProvider($stateProvider: $StateProvider) {
+  ($stateProvider.state("name", {
+    url: "http://www.example.com"
+  }): $StateProvider);
+}
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_timeout_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_timeout_v1.5.x.js
new file mode 100644
index 0000000000..7474846835
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_timeout_v1.5.x.js
@@ -0,0 +1,68 @@
+// @flow
+import type { $Timeout, AngularPromise } from 'angular';
+import { describe, it } from 'flow-typed-test';
+
+describe('angular $Timeout', () => {
+  it('can be called', () => {
+    it('without arguments', () => {
+      function testTimeout($timeout: $Timeout) {
+        $timeout();
+      }
+    });
+
+    it('with first argument as a function', () => {
+      function testTimeout($timeout: $Timeout) {
+        $timeout(() => {});
+      }
+    });
+
+    it('with second argument as number', () => {
+      function testTimeout($timeout: $Timeout) {
+        $timeout(() => {}, 123);
+      }
+    });
+
+    it('with third argument as boolean', () => {
+      function testTimeout($timeout: $Timeout) {
+        $timeout(() => {}, 123, true);
+      }
+    });
+
+    it('with fourth argument as anything', () => {
+      function testTimeout($timeout: $Timeout) {
+        $timeout(() => {}, 123, true, 123);
+        $timeout(() => {}, 123, true, 'text');
+        $timeout(() => {}, 123, true, {});
+      }
+    });
+  });
+
+  it('cannot be called', () => {
+    it('with something other than function as first argument', () => {
+      function testTimeout($timeout: $Timeout) {
+        //$FlowExpectedError
+        $timeout(123);
+      }
+    });
+
+    it('with something other than a number in the second argument', () => {
+      function testTimeout($timeout: $Timeout) {
+        //$FlowExpectedError
+        $timeout(() => {}, '123');
+      }
+    });
+
+    it('with something other than a boolean in the third argument', () => {
+      function testTimeout($timeout: $Timeout) {
+        //$FlowExpectedError
+        $timeout(() => {}, 123, 'text');
+      }
+    });
+  });
+
+  it('returns back the angular promise', () => {
+    function testTimeout($timeout: $Timeout) {
+      ($timeout(): AngularPromise<any>);
+    }
+  });
+});
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_v1.5.x.js
new file mode 100644
index 0000000000..a4a37be9a4
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_angular_v1.5.x.js
@@ -0,0 +1,368 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import {
+  type AngularPromise,
+  type AngularQ,
+  type JqliteElement,
+  type AngularHttpService,
+  typeof AngularResourceFactory,
+  type AngularResourceResult,
+  type AngularResource,
+  typeof AngularCompileService
+} from "angular";
+
+("use strict");
+const angular = require("angular");
+
+describe("Angular modules", () => {
+  it("can be declared", () => {
+    const module1 = angular.module("foo", []);
+    const module2 = angular.module("foo", ["bazz", "qux"]);
+  });
+
+  it("can be retrieved after being declared", () => {
+    const module1 = angular.module("foo");
+  });
+
+  it("requires a name", () => {
+    // $FlowExpectedError undefined. This type is incompatible with string
+    const module1 = angular.module();
+  });
+});
+
+describe("directives", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).directive("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return {
+          restrict: "E",
+          templateUrl: "foo.html"
+        };
+      }
+    ]);
+  });
+
+  it("requires a directive to be returned", () => {
+    angular.module("foo", []).directive("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        // $FlowExpectedError string. This type is incompatible with Directive
+        return "this is clearly not a directive";
+      }
+    ]);
+  });
+
+  it("requires proper restrict when defined", () => {
+    // $FlowExpectedError
+    angular.module("foo", []).directive("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return {
+          restrict: "fails to this",
+          templateUrl: "foo.html"
+        };
+      }
+    ]);
+  });
+
+  it("does not accept random properties", () => {
+    angular.module("foo", []).directive("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        // $FlowExpectedError
+        return {
+          random: "prop which is not allowed",
+          templateUrl: "foo.html"
+        };
+      }
+    ]);
+  });
+
+  it("all bells and whistles for directive", () => {
+    angular.module("foo", []).directive("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return {
+          bindToController: true,
+          controllerAs: "ctrl",
+          templateUrl: "foo.html",
+          scope: {
+            prop: "<"
+          },
+          controller: () => {}
+        };
+      }
+    ]);
+  });
+});
+
+describe("service", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).service("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return { foo: "bar" };
+      }
+    ]);
+  });
+
+  it("can return object", () => {
+    angular.module("foo", []).service("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return { foo: "bar" };
+      }
+    ]);
+  });
+
+  it("can return function", () => {
+    angular.module("foo", []).service("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return () => {};
+      }
+    ]);
+  });
+
+  it("cant return other types", () => {
+    angular.module("foo", []).service("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        //$FlowExpectedError
+        return 123;
+      }
+    ]);
+  });
+});
+
+describe("factory", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).factory("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return { a: bar, b: bazz };
+      }
+    ]);
+  });
+
+  it("requires a return value of some kind", () => {
+    angular
+      .module("foo", [])
+      // $FlowExpectedError undefined. This type is incompatible with
+      .factory("foo", ["bar", "bazz", (bar, bazz) => undefined]);
+  });
+});
+
+describe("controller", () => {
+  it("can be declared", () => {
+    angular
+      .module("foo", [])
+      .controller("foo", ["bar", "bazz", (bar, bazz) => {}]);
+  });
+});
+
+describe("config", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).config(["bar", "bazz", (bar, bazz) => {}]);
+  });
+});
+
+describe("filter", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).filter("foo", [
+      "bar",
+      "bazz",
+      (bar, bazz) => {
+        return () => {};
+      }
+    ]);
+  });
+
+  it("requires a return value of some kind", () => {
+    // $FlowExpectedError cant return object
+    angular.module("foo", []).filter("foo", ["bar", "bazz", () => ({})]);
+  });
+});
+
+describe("filter", () => {
+  it("can be declared", () => {
+    angular.module("foo", []).run(["bar", "bazz", (bar, bazz) => {}]);
+  });
+});
+
+describe("value", () => {
+  it("can be declared to any value", () => {
+    angular.module("foo", []).value("foo", 123);
+    angular.module("foo", []).value("foo", "str");
+    angular.module("foo", []).value("foo", {});
+  });
+});
+
+describe("constant", () => {
+  it("can be declared to any value", () => {
+    angular.module("foo", []).constant("foo", 123);
+    angular.module("foo", []).constant("foo", "str");
+    angular.module("foo", []).constant("foo", {});
+  });
+});
+
+describe("element", () => {
+  it("creates a jqlite element from a string", () => {
+    const element: JqliteElement = angular.element("<span>foo</span>");
+  });
+
+  it("creates a jqlite element from an element", () => {
+    const element: JqliteElement = angular.element(window.document.body);
+  });
+
+  it("does not accept other types as a parameter", () => {
+    // $FlowExpectedError number. This type is incompatible with string
+    angular.element(5);
+  });
+});
+
+describe("copy", () => {
+  it("copies preserving the type", () => {
+    const foo: number = angular.copy(5);
+  });
+
+  it("does not change the type", () => {
+    // $FlowExpectedError string. This type is incompatible with number
+    const foo: number = angular.copy("5");
+  });
+});
+
+describe("jqlite", () => {
+  it("can remove itself", () => {
+    angular.element("foo").remove();
+  });
+
+  it("yields nothing on removal", () => {
+    // $FlowExpectedError string. This type is incompatible with void
+    const removal: string = angular.element("foo").remove();
+  });
+
+  it("can retrieve contents as a JqliteElement", () => {
+    const contents: JqliteElement = angular.element("foo").contents();
+  });
+
+  it("does not yield a string", () => {
+    // $FlowExpectedError string. This type is incompatible with JqliteElement
+    const contents: string = angular.element("foo").contents("bar");
+  });
+});
+
+describe("$compile", () => {
+  it("is a function that uses a jqlite element", () => {
+    angular.mock.inject(($compile: AngularCompileService) => {
+      $compile(angular.element("foo"));
+    });
+  });
+
+  it("returns a compiled jqlite element", () => {
+    angular.mock.inject(($compile: AngularCompileService) => {
+      const element: JqliteElement = $compile(angular.element("foo"));
+    });
+  });
+});
+
+describe("$resource", () => {
+  it("returns a $resource instance when invoked", () => {
+    angular.mock.inject(($resource: AngularResourceFactory) => {
+      const resource: AngularResource = $resource("/foo");
+    });
+  });
+
+  describe("instance", () => {
+    it("has a get function that returns a special $resource result", () => {
+      angular.mock.inject(($resource: AngularResourceFactory) => {
+        const resource: AngularResource = $resource("/foo");
+        const promise: AngularPromise<any> = resource.get().$promise;
+      });
+    });
+  });
+});
+
+describe("$q", () => {
+  it("can create a promise that resolves a pre-defined value", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      const promise: AngularPromise<string> = $q.when("foo");
+    });
+  });
+
+  it("creates a promise with the type provided the value resolved", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      // $FlowExpectedError number. This type is incompatible with string
+      const promise: AngularPromise<number> = $q.when("foo");
+    });
+  });
+
+  it("can chain promises between mapped types", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      const finalPromise: AngularPromise<string> = $q
+        .when("foo")
+        .then(s => parseInt(s))
+        .then(n => n.toString());
+    });
+  });
+
+  it("catches with errors", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      $q.when("foo").catch(e => console.log(e.message));
+    });
+  });
+
+  it("chains rejected promises into resolved promises", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      const promise: AngularPromise<string> = $q.when("foo").catch(e => "bar");
+    });
+  });
+
+  it("has both an error and a resolved value potential in finally", () => {
+    angular.mock.inject(($q: AngularQ) => {
+      $q.when("foo").finally(v => {
+        if (typeof v == "string") {
+          const s: string = v;
+        } else if (v instanceof Error) {
+          const e: Error = v;
+        }
+      });
+    });
+  });
+});
+
+describe("mock", () => {
+  describe("module", () => {
+    it("takes strings, functions and objects", () => {
+      angular.mock.module("string", () => {}, {});
+    });
+
+    it("does not accept numbers", () => {
+      //$FlowExpectedError
+      angular.mock.module(123);
+    });
+
+    it("returns a function", () => {
+      angular.mock.module("string", {})();
+    });
+  });
+});
+
+describe("$http", () => {
+  it("can POST", () => {
+    angular.mock.inject(($http: AngularHttpService) => {
+      const promise: AngularPromise<any> = $http.post("/foo", { bar: "bazz" });
+    });
+  });
+});
diff --git a/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_utility_functions_v1.5.x.js b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_utility_functions_v1.5.x.js
new file mode 100644
index 0000000000..0374d809f6
--- /dev/null
+++ b/definitions/npm/angular_v1.5.x/flow_v0.201.x-/test_utility_functions_v1.5.x.js
@@ -0,0 +1,79 @@
+// @flow
+
+import angular, { type JqliteElement } from "angular";
+
+function testElement() {
+  //accepts string
+  angular.element("str");
+  // accepts document
+  angular.element(document);
+  // returns JqLite object
+  (angular.element(document): JqliteElement);
+}
+
+function testCopy() {
+  //returns given type
+  (angular.copy("str"): string);
+  (angular.copy(123): number);
+  (angular.copy({ a: 123 }).a: number);
+}
+
+function testExtend() {
+  // extends object type
+  (angular.extend({ a: 1 }, { b: 2 }): {
+    a: number,
+    b: number,
+    ...
+  });
+  (angular.extend({ a: 1 }, { b: 2 }, { c: "str", d: 123 }): {
+    a: number,
+    b: number,
+    c: string,
+    d: number,
+    ...
+  });
+}
+
+function testForEach() {
+  //accepts object
+  angular.forEach({}, () => {});
+  // accepts array
+  angular.forEach([], (val: mixed, key: number) => {});
+  //$FlowExpectedError does not accept anything else
+  angular.forEach(123, () => {});
+
+  // callback gets array stuff in
+  angular.forEach([1, 2, 3], val => {
+    (val: number);
+  });
+
+  // key is number if array
+  angular.forEach([1, 2, 3], (val: number, key: number) => {
+    (key: number);
+  });
+
+  // key is  string if object
+  angular.forEach({ a: 123 }, (val, key) => {
+    (key: string);
+  });
+}
+
+function testFromJson() {
+  // accepts string
+  angular.fromJson("");
+  //$FlowExpectedError does not take in other types
+  angular.fromJson(123);
+}
+
+function testToJson() {
+  // returns string
+  (angular.toJson({}): string);
+  // takes boolean as second argument
+  angular.toJson({}, true);
+  // takes number as second argument
+  angular.toJson({}, 123);
+  //$FlowExpectedError does not take anything else as second argument
+  angular.toJson({}, "");
+  //$FlowExpectedError cannot be called without parameters
+  angular.toJson();
+}
diff --git a/definitions/npm/antd_v3.x.x/flow_v0.104.x-/antd_v3.x.x.js b/definitions/npm/antd_v3.x.x/flow_v0.104.x-v.200.x/antd_v3.x.x.js
similarity index 100%
rename from definitions/npm/antd_v3.x.x/flow_v0.104.x-/antd_v3.x.x.js
rename to definitions/npm/antd_v3.x.x/flow_v0.104.x-v.200.x/antd_v3.x.x.js
diff --git a/definitions/npm/antd_v3.x.x/flow_v0.104.x-/test_antd_v3.x.x.js b/definitions/npm/antd_v3.x.x/flow_v0.104.x-v.200.x/test_antd_v3.x.x.js
similarity index 100%
rename from definitions/npm/antd_v3.x.x/flow_v0.104.x-/test_antd_v3.x.x.js
rename to definitions/npm/antd_v3.x.x/flow_v0.104.x-v.200.x/test_antd_v3.x.x.js
diff --git a/definitions/npm/antd_v3.x.x/flow_v0.201.x-/antd_v3.x.x.js b/definitions/npm/antd_v3.x.x/flow_v0.201.x-/antd_v3.x.x.js
new file mode 100644
index 0000000000..a4c0aa73fe
--- /dev/null
+++ b/definitions/npm/antd_v3.x.x/flow_v0.201.x-/antd_v3.x.x.js
@@ -0,0 +1,686 @@
+declare module "antd" {
+  import type { Node, Component } from "react";
+
+  declare type ModalReference = { destroy: () => void, ... };
+
+  declare type messageFn<TReturn> = (
+    content: React$Node,
+    duration?: number,
+    onClose?: () => mixed
+  ) => TReturn;
+
+  declare type modalFnArguments = {
+    title?: string,
+    content?: React$Node,
+    onOk?: () => mixed,
+    ...
+  };
+
+  declare function modalFn(args: modalFnArguments): ModalReference;
+
+  declare export class Alert extends React$Component<{...}> {}
+
+  declare export class Avatar extends React$Component<{...}> {}
+
+  declare export type AutoCompleteDataItem =
+    | string
+    | {
+    value: string,
+    text: string,
+    ...
+  }
+    | React$Element<typeof SelectOption>
+    | React$Element<typeof SelectOptGroup>;
+
+  declare export type AutoCompleteProps<T = SelectValue> = {
+    allowClear?: boolean,
+    autoFocus?: boolean,
+    backfill?: boolean,
+    dataSource?: AutoCompleteDataItem[],
+    defaultActiveFirstOption?: boolean,
+    defaultValue?: T,
+    disabled?: boolean,
+    filterOption?: boolean | (input: string, option: React$Node) => boolean,
+    open?: boolean,
+    optionLabelProp?: string,
+    placeholder?: string,
+    value?: T,
+    onBlur?: () => void,
+    onChange?: (value: T) => void,
+    onDropdownVisibleChange?: (open: boolean) => void,
+    onFocus?: () => void,
+    onSearch?: (value: string) => void,
+    onSelect?: (value: T, option: React$Node) => void,
+    ...
+  }
+
+  declare export class AutoComplete<T = SelectValue> extends React$Component<AutoCompleteProps<T>> {
+    static Option: typeof SelectOption;
+    static OptGroup: typeof SelectOptGroup;
+  }
+
+  declare export class Badge extends React$Component<{...}> {}
+
+  declare export type ButtonProps = {
+    disabled?: boolean,
+    ghost?: boolean,
+    href?: string,
+    htmlType?: string,
+    icon?: string,
+    loading?: boolean | { delay: number, ... },
+    shape?: 'circle' | 'round',
+    size?: 'small' | 'large',
+    target?: string,
+    type?: 'primary' | 'ghost' | 'dashed' | 'danger' | 'link' | 'default',
+    onClick?: (event: SyntheticEvent<HTMLButtonElement>) => void,
+    block?: boolean,
+    ...
+  }
+
+  declare export class Button extends React$Component<ButtonProps> {
+    static Group: typeof ButtonGroup
+  }
+
+  declare class ButtonGroup extends React$Component<{...}> {}
+
+  declare export class Card extends React$Component<{...}> {}
+
+  declare export class Checkbox extends React$Component<{...}> {
+    static Group: typeof CheckboxGroup;
+  }
+
+  declare class CheckboxGroup extends React$Component<{...}> {}
+
+  declare export class Divider extends React$Component<{...}> {}
+
+  declare export class Col extends React$Component<{...}> {}
+
+  declare export type DatePickerProps = {...};
+
+  declare export class DatePicker extends React$Component<DatePickerProps> {
+    static RangePicker: typeof DatePicker$RangePicker;
+  }
+
+  declare export class Dropdown extends React$Component<{...}> {}
+
+  declare export class Grid extends React$Component<{
+    className?: string,
+    style?: $Shape<CSSStyleDeclaration>,
+    ...
+  }> {}
+
+  declare export class Meta extends React$Component<{
+    avatar?: React$Node,
+    className?: string,
+    description?: React$Node,
+    style?: $Shape<CSSStyleDeclaration>,
+    title?: React$Node,
+    ...
+  }> {}
+
+  declare export class Card extends React$Component<{
+    actions?: Array<Node>,
+    activeTabKey?: string,
+    headStyle?: $Shape<CSSStyleDeclaration>,
+    bodyStyle?: $Shape<CSSStyleDeclaration>,
+    bordered?: boolean,
+    cover?: React$Node,
+    defaultActiveTabKey?: string,
+    extra?: React$Node,
+    hoverable?: boolean,
+    loading?: boolean,
+    tabList?: Array<{
+      key: string,
+      tab: React$Node,
+      ...
+    }>,
+    title?: React$Node,
+    type?: "inner",
+    onTabChange?: (key: string) => void,
+    ...
+  }> {
+    static Grid: typeof Grid;
+    static Meta: typeof Meta;
+  }
+
+  declare type CascaderOption = {
+    value: string,
+    label: string,
+    children?: CascaderOption[],
+    ...
+  };
+
+  declare export type CascaderProps = {
+    allowClear?: boolean,
+    autoFocus?: boolean,
+    changeOnSelect?: boolean,
+    className?: string,
+    disabled?: boolean,
+    expandTrigger?: "click" | "hover",
+    notFoundContent?: string,
+    onChange?: (values: string[]) => mixed,
+    options: CascaderOption[],
+    placeholder?: string,
+    popupClassName?: string,
+    popupPlacement?: "bottomLeft" | "bottomRight" | "topLeft" | "topRight",
+    popupVisible?: boolean,
+    showSearch?: boolean,
+    size?: "large" | "default" | "small",
+    value?: string[],
+    ...
+  };
+
+  declare export class Cascader extends React$Component<CascaderProps> {}
+
+  declare export class Col extends React$Component<{...}> {}
+
+  declare export type CollapsePanelProps = {...};
+
+  declare class CollapsePanel extends React$Component<CollapsePanelProps> {}
+
+  declare export type CollapseProps = {...};
+
+  declare export class Collapse extends React$Component<CollapseProps> {
+    static Panel: typeof CollapsePanel;
+  }
+
+  declare export class Dropdown extends React$Component<{...}> {}
+
+  declare export class Drawer extends React$Component<{...}> {}
+
+  declare type ValidationRule = {
+    enum?: string | string[],
+    len?: number,
+    max?: number,
+    message?: string,
+    min?: number,
+    pattern?: RegExp,
+    required?: boolean,
+    transform?: (value: mixed) => mixed,
+    type?: string,
+    validator?: (
+      rule: mixed,
+      value: mixed,
+      callback: mixed,
+      source?: mixed,
+      options?: mixed
+    ) => mixed,
+    whitespace?: boolean,
+    ...
+  };
+  declare type ValidateCallback = (erros: mixed, values: mixed) => void;
+  declare type GetFieldDecoratorOptions = {
+    exclusive?: boolean,
+    getValueFromEvent?: (...args: mixed[]) => mixed,
+    initialValue?: mixed,
+    normalize?: (value: mixed, prevValue: mixed, allValues: mixed) => mixed,
+    rules?: ValidationRule[],
+    trigger?: string,
+    validateFirst?: boolean,
+    validateTrigger?: string | string[],
+    valuePropName?: string,
+    ...
+  };
+
+  declare export type WrappedFormUtils = {
+    getFieldDecorator(
+      id: string,
+      options?: GetFieldDecoratorOptions
+    ): (node: React$Node) => React$Node,
+    getFieldError(name: string): mixed[],
+    getFieldsError(names?: Array<string>): mixed,
+    getFieldsValue(fieldNames?: Array<string>): mixed,
+    getFieldValue(fieldName: string): mixed,
+    isFieldsTouched(names?: Array<string>): boolean,
+    isFieldTouched(name: string): boolean,
+    isFieldValidating(name: string): boolean,
+    resetFields(names?: Array<string>): void,
+    setFields(obj: Object): void,
+    setFieldsValue(obj: Object): void,
+    validateFields(callback: ValidateCallback): mixed,
+    validateFields(
+      fieldNames: Array<string>,
+      callback: ValidateCallback
+    ): mixed,
+    validateFields(
+      fieldNames: Array<string>,
+      options: Object,
+      callback: ValidateCallback
+    ): mixed,
+    validateFields(options: Object, callback: ValidateCallback): mixed,
+    validateFieldsAndScroll(
+      fieldNames?: Array<string>,
+      options?: Object,
+      callback?: ValidateCallback
+    ): void,
+    validateFieldsAndScroll(callback?: ValidateCallback): void,
+    validateFieldsAndScroll(
+      fieldNames?: Array<string>,
+      callback?: ValidateCallback
+    ): void,
+    validateFieldsAndScroll(options?: Object, callback?: ValidateCallback): void,
+    ...
+  };
+
+  declare interface RcBaseFormProps {
+    wrappedComponentRef?: any;
+  }
+
+  declare interface FormComponentProps extends RcBaseFormProps {
+    form: WrappedFormUtils;
+  }
+
+  declare type FormWrappedProps<T> = <C: React$ComponentType<T>>
+  (component: C) => React$ComponentType<$Diff<T, { form: any, ... }>>;
+
+  declare export type FormProps = {
+    className?: string,
+    form?: WrappedFormUtils,
+    hideRequiredMark?: boolean,
+    horizontal?: boolean,
+    inline?: boolean,
+    layout?: "horizontal" | "inline" | "vertical",
+    onSubmit?: (e: SyntheticEvent<HTMLFormElement>) => void,
+    prefixCls?: string,
+    style?: $Shape<CSSStyleDeclaration>,
+    vertical?: boolean,
+    ...
+  };
+
+  declare export type FormCreateOption<T> = {
+    onFieldsChange?: (props: T, fields: Array<mixed>) => void,
+    onValuesChange?: (props: T, values: mixed) => void,
+    mapPropsToFields?: (props: T) => void,
+    withRef?: boolean,
+    ...
+  };
+
+  declare export class Form extends React$Component<FormProps> {
+    static Item: typeof FormItem;
+    static create: <TOwnProps: FormComponentProps>(
+      options?: FormCreateOption<TOwnProps>
+    ) => FormWrappedProps<TOwnProps>;
+  }
+
+  declare export type FormItemProps = {
+    help?: React$Node,
+    extra?: React$Node,
+    validateStatus?: "success" | "warning" | "error" | "validating" | "",
+    ...
+  };
+
+  declare class FormItem extends React$Component<FormItemProps> {}
+
+  declare export type RangePickerProps = {...};
+
+  declare export class DatePicker$RangePicker extends React$Component<
+    RangePickerProps
+  > {}
+
+  declare export class Icon extends React$Component<{...}> {}
+
+  declare export class InputNumber extends React$Component<{...}> {}
+
+  declare type InputProps = {
+    onBlur?: (event: SyntheticFocusEvent<HTMLInputElement>) => mixed,
+    onChange?: (event: SyntheticKeyboardEvent<HTMLInputElement>) => mixed,
+    ...
+  };
+
+  declare export class Input extends React$Component<InputProps> {
+    static Search: typeof InputSearch;
+    static TextArea: typeof InputTextArea;
+    static Password: typeof InputPassword;
+  }
+
+  declare class InputSearch extends React$Component<{...}> {
+    input: { input: HTMLInputElement, ... };
+  }
+
+  declare class InputTextArea extends React$Component<{...}> {}
+
+  declare type InputPasswordProps = { visibilityToggle?: boolean, ... };
+
+  // Added in 3.12.0
+  declare class InputPassword extends React$Component<InputPasswordProps> {}
+
+  declare export class Layout extends React$Component<{...}> {
+    static Content: typeof LayoutContent;
+    static Footer: typeof LayoutFooter;
+    static Header: typeof LayoutHeader;
+    static Sider: typeof LayoutSider;
+  }
+
+  declare class LayoutContent extends React$Component<{...}> {}
+
+  declare class LayoutFooter extends React$Component<{...}> {}
+
+  declare class LayoutHeader extends React$Component<{...}> {}
+
+  declare class LayoutSider extends React$Component<{...}> {}
+
+  declare export type ListItemProps = {...};
+
+  declare export class ListItem extends React$Component<ListItemProps> {
+    static Meta: typeof Meta;
+  }
+
+  declare export class List extends React$Component<{...}> {
+    static Item: typeof ListItem;
+  }
+
+  declare export class LocaleProvider extends React$Component<{...}> {}
+
+  declare export type MenuProps = { onClick?: ({
+    domEvent: SyntheticMouseEvent<HTMLElement>,
+    item: React$Component<MenuItem>,
+    key: string,
+    keyPath: string[],
+    ...
+  }) => mixed, ... };
+
+  declare export class Menu extends React$Component<MenuProps> {
+    static Item: typeof MenuItem;
+    static SubMenu: typeof MenuSubMenu;
+  }
+
+  declare class MenuItem extends React$Component<{...}> {}
+
+  declare class MenuSubMenu extends React$Component<{...}> {}
+
+  declare export class message {
+    static config({
+      duration?: number,
+      getContainer?: () => HTMLElement,
+      top?: number,
+      ...
+    }): void;
+    static destroy: () => void;
+    static success: messageFn<mixed>;
+    static error: messageFn<mixed>;
+    static info: messageFn<mixed>;
+    static warning: messageFn<mixed>;
+    static warn: messageFn<mixed>;
+    static loading: messageFn<() => void>;
+  }
+
+  declare export class Modal extends React$Component<{...}> {
+    static info: typeof modalFn;
+    static success: typeof modalFn;
+    static error: typeof modalFn;
+    static warning: typeof modalFn;
+    static confirm: typeof modalFn;
+  }
+
+  declare export type PaginationProps = {
+    current?: number,
+    defaultCurrent?: number,
+    defaultPageSize?: number,
+    hideOnSinglePage?: boolean,
+    itemRender?: (
+      page: number,
+      type: "page" | "prev" | "next",
+      originalElement: React$Node
+    ) => React$Node,
+    pageSize?: number,
+    pageSizeOptions?: string[],
+    showQuickJumper?: boolean,
+    showSizeChanger?: boolean,
+    showTotal?: (total: number, range: number[]) => React$Node,
+    simple?: boolean,
+    size?: string,
+    total?: number,
+    onChange?: (page: number, pageSize: number) => void,
+    onShowSizeChange?: (current: number, size: number) => void,
+    ...
+  };
+
+  declare export class Pagination extends React$Component<PaginationProps> {}
+
+  // These props are shared by Tooltip, Popconfirm, and Poopover
+  declare type TooltipSharedProps = {
+    arrowPointAtCenter?: boolean,
+    autoAdjustOverflow?: boolean,
+    defaultVisible?: boolean,
+    getPopupContainer?: (element?: HTMLElement) => HTMLElement,
+    mouseEnterDelay?: number,
+    mouseLeaveDelay?: number,
+    overlayClassName?: string,
+    overlayStyle?: $Shape<CSSStyleDeclaration>,
+    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom',
+    trigger?: 'hover' | 'focus' | 'click' | 'contextMenu',
+    visible?: boolean,
+    onVisibleChange?: (visible: boolean) => void,
+    align?: AlignConfig,
+    ...
+  }
+
+  // for alignConfig value, antd documentation points to rc-tooltip docs,
+  // which poits to https://github.com/yiminghe/dom-align
+  declare type AlignConfig = {|
+    points?: string,
+    offset?: number | string,
+    targetOffset?: number | string,
+    overflow?: {| adjustX?: boolean, adjustY?: boolean |},
+    useCssRight?: boolean,
+    useCssBottom?: boolean,
+    useCssTransform:? boolean
+  |}
+
+  declare export type PopconfirmProps = {
+    cancelText?: string,
+    okText?: string,
+    okType?: 'primary' | 'dashed' | 'ghost' | 'danger' | 'default',
+    title?: 'string' | React$Node,
+    onCancel?: (event: SyntheticEvent<>) => void,
+    onConfirm?: (event: SyntheticEvent<>) => void,
+    icon?: React$Node,
+    ...
+  } & TooltipSharedProps
+
+  declare export class Popconfirm extends React$Component<PopconfirmProps> {}
+
+  declare export type PopoverProps = {
+    content?: 'string' | React$Node,
+    title?: 'string' | React$Node,
+    ...
+  } & TooltipSharedProps
+
+  declare export class Popover extends React$Component<PopoverProps> {}
+
+  declare export class Progress extends React$Component<{...}> {}
+
+  declare export class Radio extends React$Component<{...}> {
+    static Group: typeof RadioGroup;
+    static Button: typeof RadioButton;
+  }
+
+  declare class RadioGroup extends React$Component<{...}> {}
+
+  declare class RadioButton extends React$Component<{...}> {}
+
+  declare export class Row extends React$Component<{...}> {}
+
+  declare export type SelectValue = string | string[] | number | number[];
+
+  declare export type SelectProps<T = SelectValue> = {
+    allowClear?: boolean,
+    autoClearSearchValue?: boolean,
+    autoFocus?: boolean,
+    defaultActiveFirstOption?: boolean,
+    defaultOpen?: boolean,
+    defaultValue?: T,
+    disabled?: boolean,
+    dropdownClassName?: string,
+    dropdownMatchSelectWidth?: boolean,
+    filterOption?: boolean | (input: string, option: React$Node) => boolean,
+    firstActiveValue?: string | string[],
+    labelInValue?: boolean,
+    loading?: boolean,
+    maxTagCount?: number,
+    mode?: 'default' | 'multiple' | 'tags',
+    notFoundContent?: string,
+    open?: boolean,
+    optionFilterProp?: string,
+    optionLabelProp?: string,
+    placeholder?: string | React$Node,
+    showArrow?: boolean,
+    showSearch?: boolean,
+    size?: 'default' | 'small' | 'large' | string,
+    suffixIcon?: React$Node,
+    removeIcon?: React$Node,
+    clearIcon?: React$Node,
+    menuItemSelectedIcon?: React$Node,
+    tokenSeparators?: string[],
+    value?: T,
+    onBlur?: () => void,
+    onChange?: (value: T, option: React$Node) => void,
+    onDeselect?: (value: T, option: React$Node) => void,
+    onDropdownVisibleChange?: (open: boolean) => void,
+    onFocus?: () => void,
+    onSearch?: (value: string) => void,
+    onSelect?: (value: T, option: React$Node) => void,
+    ...
+  };
+
+  declare export class Select<T = SelectValue> extends React$Component<SelectProps<T>> {
+    static Option: typeof SelectOption;
+    static OptGroup: typeof SelectOptGroup;
+    blur: () => void;
+    focus: () => void;
+  }
+
+  declare export type SelectOptionProps = {
+    className?: string,
+    disabled?: boolean,
+    key?: string,
+    title?: string,
+    value?: string | number,
+    ...
+  };
+
+  declare class SelectOption extends React$Component<SelectOptionProps> {}
+
+  declare export type SelectOptGroupProps = {
+    key?: string,
+    label?: string | React$Node,
+    ...
+  };
+
+  declare class SelectOptGroup extends React$Component<SelectOptGroupProps> {}
+
+  declare export class Slider extends React$Component<{...}> {}
+
+  declare export type SpinProps = {
+    delay?: number,
+    size?: "small" | "default" | "large",
+    spinning?: boolean,
+    tip?: string,
+    ...
+  };
+
+  declare export class Spin extends React$Component<SpinProps> {}
+
+  declare export class Step extends React$Component<{
+    description?: React$Node,
+    icon?: React$Node,
+    status?: "wait" | "process" | "finish" | "error",
+    title?: React$Node,
+    ...
+  }> {}
+
+  declare export class Steps extends React$Component<{
+    current?: number,
+    direction?: "horizontal" | "vertical",
+    labelPlacement?: "horizontal" | "vertical",
+    progressDot?:
+      | boolean
+      | ((
+          iconDot: React$Node,
+          {
+            index: number,
+            status: "wait" | "process" | "finish" | "error",
+            title: React$Node,
+            description: React$Node,
+            ...
+          }
+        ) => React$Node),
+    size?: "default" | "small",
+    status?: "wait" | "process" | "finish" | "error",
+    ...
+  }> {
+    static Step: typeof Step;
+  }
+
+  declare export class Switch extends React$Component<{...}> {}
+
+  declare export class Table extends React$Component<{...}> {}
+
+  declare export class Tabs extends React$Component<{...}> {
+    static TabPane: typeof TabsTabPane;
+  }
+
+  declare export class TabsTabPane extends React$Component<{...}> {}
+
+  declare export class Tag extends React$Component<{...}> {}
+
+  declare export type TooltipProps = { title: React$Node | () => React$Node, ... } & TooltipSharedProps
+
+  declare export class Tooltip extends React$Component<TooltipProps> {}
+
+  declare export class TreeSelect extends React$Component<{...}> {
+    static TreeNode: typeof TreeSelectTreeNode;
+  }
+
+  declare export class TreeSelectTreeNode extends React$Component<{...}> {}
+
+  declare export class Upload extends React$Component<{...}> {
+    static Dragger: typeof UploadDragger;
+  }
+
+  declare export class UploadDragger extends React$Component<{...}> {}
+
+
+  declare export type NotificationPlacement = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+
+  declare export type NotificationConfigProps = {
+    top?: number,
+    bottom?: number,
+    duration?: number,
+    placement?: NotificationPlacement,
+    getContainer?: () => HTMLElement,
+    ...
+  }
+
+  declare export type NotificationProps = {
+    message: React$Node,
+    description?: React$Node,
+    btn?: React$Node,
+    key?: string,
+    onClose?: () => void,
+    duration?: number | null,
+    icon?: React$Node,
+    placement?: NotificationPlacement,
+    style?: $Shape<CSSStyleDeclaration>,
+    prefixCls?: string,
+    className?: string,
+    +type?: 'success' | 'info' | 'error' | 'warning',
+    onClick?: () => void,
+    top?: number,
+    bottom?: number,
+    getContainer?: () => HTMLElement,
+    ...
+  }
+
+  declare export class notification {
+    static success: NotificationProps => void;
+    static error:  NotificationProps => void;
+    static info:  NotificationProps => void;
+    static warn:  NotificationProps => void;
+    static warning: NotificationProps => void;
+    static open: NotificationProps => void;
+    static close: string => void;
+    static config: NotificationConfigProps => void;
+    static destroy: () => void;
+  }
+}
diff --git a/definitions/npm/antd_v3.x.x/flow_v0.201.x-/test_antd_v3.x.x.js b/definitions/npm/antd_v3.x.x/flow_v0.201.x-/test_antd_v3.x.x.js
new file mode 100644
index 0000000000..ba383654df
--- /dev/null
+++ b/definitions/npm/antd_v3.x.x/flow_v0.201.x-/test_antd_v3.x.x.js
@@ -0,0 +1,903 @@
+// @flow
+import * as React from "react";
+import { describe, it } from "flow-typed-test";
+import {
+  Alert,
+  AutoComplete,
+  Avatar,
+  Badge,
+  Button,
+  Card,
+  Cascader,
+  Checkbox,
+  Col,
+  Collapse,
+  DatePicker,
+  Dropdown,
+  Form,
+  Icon,
+  Input,
+  Layout,
+  LocaleProvider,
+  Menu,
+  message,
+  Modal,
+  Pagination,
+  Popconfirm,
+  Popover,
+  Radio,
+  Row,
+  Select,
+  Slider,
+  Spin,
+  Steps,
+  Table,
+  Tabs,
+  Tag,
+  Tooltip,
+  TreeSelect
+} from "antd";
+
+const { RangePicker } = DatePicker;
+
+import type { WrappedFormUtils } from "antd";
+
+describe("Alert", () => {
+  it("is a react component", () => {
+    const alert = <Alert />;
+  });
+});
+
+describe("Avatar", () => {
+  it("is a react component", () => {
+    const avatar = <Avatar />;
+  });
+});
+
+describe("AutoComplete", () => {
+  it("is a react component", () => {
+    const autocomplete = <AutoComplete />;
+  });
+
+  it("with prop allowClear", () => {
+    const autocomplete1 = <AutoComplete allowClear={false} />;
+    const autocomplete2 = <AutoComplete allowClear={true} />;
+    const autocomplete3 = <AutoComplete allowClear />;
+  });
+
+  it("with prop autoFocus", () => {
+    const autocomplete1 = <AutoComplete autoFocus={false} />;
+    const autocomplete2 = <AutoComplete autoFocus={true} />;
+    const autocomplete3 = <AutoComplete autoFocus />;
+  });
+
+  it("with prop backfill", () => {
+    const autocomplete1 = <AutoComplete backfill={false} />;
+    const autocomplete2 = <AutoComplete backfill={true} />;
+    const autocomplete3 = <AutoComplete backfill />;
+  });
+
+  it("with prop defaultActiveFirstOption", () => {
+    const autocomplete1 = <AutoComplete defaultActiveFirstOption={false} />;
+    const autocomplete2 = <AutoComplete defaultActiveFirstOption={true} />;
+    const autocomplete3 = <AutoComplete defaultActiveFirstOption />;
+  });
+
+  it("with prop defaultValue", () => {
+    const autocomplete1 = <AutoComplete defaultValue="key-123" />;
+    const autocomplete2 = <AutoComplete defaultValue={["key-123", "key-456"]} />;
+    const autocomplete3 = <AutoComplete defaultValue={123} />;
+    const autocomplete4 = <AutoComplete defaultValue={[123, 456]} />;
+  });
+
+  it("with prop disabled", () => {
+    const autocomplete1 = <AutoComplete disabled={false} />;
+    const autocomplete2 = <AutoComplete disabled={true} />;
+    const autocomplete3 = <AutoComplete disabled />;
+  });
+
+  it("with prop filterOption", () => {
+    const autocomplete1 = <AutoComplete filterOption={true} />;
+    const autocomplete2 = <AutoComplete filterOption={(input: string, option: React$Node) => true} />;
+  });
+
+  it("with prop open", () => {
+    const autocomplete1 = <AutoComplete open={false} />;
+    const autocomplete2 = <AutoComplete open={true} />;
+    const autocomplete3 = <AutoComplete open />;
+  });
+
+  it("with prop optionLabelProp", () => {
+    const autocomplete = <AutoComplete optionLabelProp="name" />;
+  });
+
+  it("with prop placeholder", () => {
+    const autocomplete = <AutoComplete placeholder="Please select..." />;
+  });
+
+  it("with prop value", () => {
+    const autocomplete1 = <AutoComplete value="key-123" />;
+    const autocomplete2 = <AutoComplete value={["key-123", "key-456"]} />;
+    const autocomplete3 = <AutoComplete value={123} />;
+    const autocomplete4 = <AutoComplete value={[123, 456]} />;
+  });
+
+  it("with prop onBlur", () => {
+    const autocomplete = <AutoComplete onBlur={() => undefined} />;
+  });
+
+  it("with prop onChange", () => {
+    const autocomplete1 = <AutoComplete onChange={() => undefined} />;
+    const autocomplete2 = <AutoComplete value="key-123" onChange={(value: string) => undefined} />;
+    const autocomplete3 = <AutoComplete value={["key-123", "key-456"]} onChange={(value: string[]) => undefined} />;
+    const autocomplete4 = <AutoComplete value={123} onChange={(value: number) => undefined} />;
+    const autocomplete5 = <AutoComplete value={[123, 456]} onChange={(value: number[]) => undefined} />;
+  });
+
+  it("with prop onDropdownVisibleChange", () => {
+    const autocomplete = <AutoComplete onDropdownVisibleChange={(open: boolean) => undefined} />;
+  });
+
+  it("with prop onFocus", () => {
+    const autocomplete = <AutoComplete onFocus={() => undefined} />;
+  });
+
+  it("with prop onSearch", () => {
+    const autocomplete = <AutoComplete onSearch={(value: string) => undefined} />;
+  });
+
+  it("with prop onSelect", () => {
+    const autocomplete1 = <AutoComplete onSelect={() => undefined} />;
+    const autocomplete2 = <AutoComplete value="key-123" onSelect={(value: string) => undefined} />;
+    const autocomplete3 = <AutoComplete value={["key-123", "key-456"]} onSelect={(value: string[]) => undefined} />;
+    const autocomplete4 = <AutoComplete value={123} onSelect={(value: number) => undefined} />;
+    const autocomplete5 = <AutoComplete value={[123, 456]} onSelect={(value: number[]) => undefined} />;
+  });
+});
+
+describe("AutoComplete.Option", () => {
+  it("is a react component", () => {
+    const option = <AutoComplete.Option />;
+  });
+});
+
+describe("AutoComplete.OptGroup", () => {
+  it("is a react component", () => {
+    const group = <AutoComplete.OptGroup />;
+  });
+});
+
+describe("Badge", () => {
+  it("is a react component", () => {
+    const badge = <Badge />;
+  });
+});
+
+describe("Button", () => {
+  it("is a react component", () => {
+    const button = <Button />;
+  });
+  it("should accept nullary or unary onClick handler", () => {
+    const good0 = <Button onClick={() => undefined} />;
+    const good1 = (
+      <Button
+        onClick={(event: SyntheticEvent<HTMLButtonElement>) => undefined}
+      />
+    );
+    // $FlowExpectedError
+    const bad = <Button onClick="bad" />;
+  });
+  it("should accept only certain strings for type prop", () => {
+    const good0 = <Button type="primary" />;
+    const good1 = <Button type="ghost" />;
+    const good2 = <Button type="dashed" />;
+    const good3 = <Button type="danger" />;
+    const good5 = <Button type="link" />;
+    const good4 = <Button type="default" />;
+    // $FlowExpectedError
+    const bad = <Button type="bad" />;
+  });
+});
+
+describe("Button.Group", () => {
+  it("is a react component", () => {
+    const group = <Button.Group />;
+  });
+});
+
+describe("Card", () => {
+  it("is a react component", () => {
+    const card = <Card />;
+  });
+
+  it("with content", () => {
+    const card = (
+      <Card
+        title="Card title"
+        bordered={false}
+        extra={<a href="#">More</a>}
+        style={{ width: 300 }}
+      >
+        <p>Card content</p>
+        <p>Card content</p>
+      </Card>
+    );
+  });
+
+  it("with Card.Grid", () => {
+    const card = (
+      <Card title="Card Title">
+        <Card.Grid style={{ width: "25%", textAlign: "center" }}>
+          Content
+        </Card.Grid>
+      </Card>
+    );
+  });
+
+  it("with Card.Meta", () => {
+    const card = (
+      <Card
+        hoverable
+        style={{ width: 240 }}
+        cover={
+          <img
+            alt="example"
+            src="https://os.alipayobjects.com/rmsportal/QBnOOoLaAfKPirc.png"
+          />
+        }
+      >
+        <Card.Meta
+          avatar={
+            <Avatar src="https://zos.alipayobjects.com/rmsportal/ODTLcjxAfvqbxHnVXCYX.png" />
+          }
+          title="Europe Street beat"
+          description="www.instagram.com"
+        />
+      </Card>
+    );
+  });
+});
+
+describe("Cascader", () => {
+  it("is a react component", () => {
+    const cascader = (
+      <Cascader
+        options={[
+          {
+            label: "l1",
+            value: "v1",
+            children: [
+              {
+                label: "l11",
+                value: "v11"
+              }
+            ]
+          }
+        ]}
+      />
+    );
+  });
+});
+
+describe("Checkbox", () => {
+  it("is a react component", () => {
+    const checkbox = <Checkbox />;
+  });
+});
+
+describe("Checkbox.Group", () => {
+  it("is a react component", () => {
+    const group = <Checkbox.Group />;
+  });
+});
+
+describe("Col", () => {
+  it("is a react component", () => {
+    const col = <Col />;
+  });
+});
+
+describe("Collapse", () => {
+  it("is a react component", () => {
+    const collapse = <Collapse />;
+  });
+});
+
+describe("Collapse.Panel", () => {
+  it("is a react component", () => {
+    const panel = <Collapse.Panel />;
+  });
+});
+
+describe("DatePicker", () => {
+  it("is a react component", () => {
+    const datePicker = <DatePicker />;
+  });
+});
+
+describe("RangePicker", () => {
+  it("is a react component", () => {
+    const rangePicker = <RangePicker />;
+  });
+});
+
+describe("Dropdown", () => {
+  it("is a react component", () => {
+    const dropdown = <Dropdown />;
+  });
+});
+
+describe("Form", () => {
+  it("is a react component", () => {
+    const form = <Form />;
+  });
+  it("have create method that wrap a component with a form", () => {
+
+    type PropsGoodTest = {
+      a:string,
+      form: WrappedFormUtils,
+      ...
+    };
+    type PropsBadTest = { a:string, ... };
+    class GoodTestComponent extends React.Component<PropsGoodTest> {}
+    class BadTestComponent extends React.Component<PropsBadTest> {}
+
+    // create is a function
+    const GoodWrappedTestForm: React$ComponentType<$Diff<PropsGoodTest, { form: any, ... }>> =
+      Form.create<PropsGoodTest>({name: 'good_test_form'})(GoodTestComponent);
+
+    const BadWrappedTestForm: React$ComponentType<$Diff<PropsBadTest, { form: any, ... }>> =
+      // $FlowExpectedError PropsBadTest. it must contain form attribute
+      Form.create<PropsBadTest>({name: 'bad_test_form'})(BadTestComponent);
+
+  });
+});
+
+describe("Form.Item", () => {
+  it("is a react component", () => {
+    const formItem = <Form.Item />;
+  });
+});
+
+describe("Icon", () => {
+  it("is a react component", () => {
+    const icon = <Icon />;
+  });
+});
+
+describe("Input", () => {
+  it("is a react component", () => {
+    const input = <Input />;
+  });
+});
+
+describe("Input.Search", () => {
+  it("is a react component", () => {
+    const inputSearch = <Input.Search />;
+  });
+});
+
+describe("Input.TextArea", () => {
+  it("is a react component", () => {
+    const inputTextArea = <Input.TextArea />;
+  });
+});
+
+describe("Input.Password", () => {
+  it("is a react component", () => {
+    const inputPassword = <Input.Password />;
+  });
+  it("should accept boolean visibilityToggle", () => {
+    const good = <Input.Password visibilityToggle={false} />;
+    // $FlowExpectedError string. visibilityToggle must be of type boolean
+    const bad = <Input.Password visibilityToggle={"false"} />
+  });
+});
+
+describe("Layout", () => {
+  it("is a react component", () => {
+    const layout = <Layout />;
+  });
+});
+
+describe("Layout.Content", () => {
+  it("is a react component", () => {
+    const layoutContent = <Layout.Content />;
+  });
+});
+
+describe("Layout.Footer", () => {
+  it("is a react component", () => {
+    const layoutFooter = <Layout.Footer />;
+  });
+});
+
+describe("Layout.Header", () => {
+  it("is a react component", () => {
+    const layoutHeader = <Layout.Header />;
+  });
+});
+
+describe("LocaleProvider", () => {
+  it("is a react component", () => {
+    const localeProvider = <LocaleProvider />;
+  });
+});
+
+describe("Menu", () => {
+  it("is a react component", () => {
+    const menu = <Menu />;
+  });
+});
+
+describe("Menu.Item", () => {
+  it("is a react component", () => {
+    const menuItem = <Menu.Item />;
+  });
+});
+
+describe("Menu.SubMenu", () => {
+  it("is a react component", () => {
+    const menuSubMenu = <Menu.SubMenu />;
+  });
+});
+
+describe("message", () => {
+  it("have a config function", () => {
+    const element = document.createElement("div");
+    message.config({
+      duration: 1000,
+      getContainer: () => element,
+      top: 42
+    });
+  });
+  it("have a destroy function", () => {
+    message.destroy();
+  });
+  it("have a success function", () => {
+    message.success("hello", 2000, () => "closed");
+  });
+  it("have a error function", () => {
+    message.error("hello", 2000, () => "closed");
+  });
+  it("have an info function", () => {
+    message.info("hello", 2000, () => "closed");
+  });
+  it("have a warning function", () => {
+    message.warning("hello", 2000, () => "closed");
+  });
+  it("have a warn function", () => {
+    message.warn("hello", 2000, () => "closed");
+  });
+  it("have a loading function", () => {
+    const stopLoading = message.loading("hello", 2000, () => "closed");
+    stopLoading();
+  });
+});
+
+describe("Modal", () => {
+  it("is a react component", () => {
+    const modal = <Modal />;
+  });
+  it("have an info method", () => {
+    const ref = Modal.info({
+      title: "hello",
+      content: "world",
+      onOk: () => 42
+    });
+    ref.destroy();
+  });
+  it("have a success method", () => {
+    const ref = Modal.success({
+      title: "hello",
+      content: "world",
+      onOk: () => 42
+    });
+    ref.destroy();
+  });
+  it("have an error method", () => {
+    const ref = Modal.error({
+      title: "hello",
+      content: "world",
+      onOk: () => 42
+    });
+    ref.destroy();
+  });
+  it("have a warning method", () => {
+    const ref = Modal.warning({
+      title: "hello",
+      content: "world",
+      onOk: () => 42
+    });
+    ref.destroy();
+  });
+  it("have a confirm method", () => {
+    const ref = Modal.confirm({
+      title: "hello",
+      content: "world",
+      onOk: () => 42
+    });
+    ref.destroy();
+  });
+});
+
+describe("Pagination", () => {
+  it("is a react component", () => {
+    const pagination = <Pagination />;
+  });
+});
+
+describe("Popconfirm", () => {
+  it("is a react component", () => {
+    const popconfirm = <Popconfirm />;
+  });
+  it("should accept only certain strings for placement prop", () => {
+    // Testing placement prop in particular just to verify sharing between
+    // Popconfirm, Popover, and Tooltip is working.
+    const good = <Popconfirm placement='top' />;
+    // $FlowExpectedError
+    const bad = <Popconfirm placement='topCenter' />;
+  });
+});
+
+describe("Popover", () => {
+  it("is a react component", () => {
+    const popover = <Popover />;
+  });
+
+  it("should accept only certain strings for placement prop", () => {
+    // Testing placement prop in particular just to verify sharing between
+    // Popconfirm, Popover, and Tooltip is working.
+    const good = <Popover placement='top' />;
+    // $FlowExpectedError
+    const bad = <Popover placement='topCenter' />;
+  });
+});
+
+describe("Radio", () => {
+  it("is a react component", () => {
+    const radio = <Radio />;
+  });
+});
+
+describe("Radio.Group", () => {
+  it("is a react component", () => {
+    const radioGroup = <Radio.Group />;
+  });
+});
+
+describe("Row", () => {
+  it("is a react component", () => {
+    const row = <Row />;
+  });
+});
+
+describe("Select", () => {
+  it("is a react component", () => {
+    const select = <Select />;
+  });
+
+  it("with prop allowClear", () => {
+    const select1 = <Select allowClear={false} />;
+    const select2 = <Select allowClear={true} />;
+    const select3 = <Select allowClear />;
+  });
+
+  it("with prop autoClearSearchValue", () => {
+    const select1 = <Select autoClearSearchValue={false} />;
+    const select2 = <Select autoClearSearchValue={true} />;
+    const select3 = <Select autoClearSearchValue />;
+  });
+
+  it("with prop autoFocus", () => {
+    const select1 = <Select autoFocus={false} />;
+    const select2 = <Select autoFocus={true} />;
+    const select3 = <Select autoFocus />;
+  });
+
+  it("with prop defaultActiveFirstOption", () => {
+    const select1 = <Select defaultActiveFirstOption={false} />;
+    const select2 = <Select defaultActiveFirstOption={true} />;
+    const select3 = <Select defaultActiveFirstOption />;
+  });
+
+  it("with prop defaultOpen", () => {
+    const select1 = <Select defaultOpen={false} />;
+    const select2 = <Select defaultOpen={true} />;
+    const select3 = <Select defaultOpen />;
+  });
+
+  it("with prop defaultValue", () => {
+    const select1 = <Select defaultValue="key-123" />;
+    const select2 = <Select defaultValue={["key-123", "key-456"]} />;
+    const select3 = <Select defaultValue={123} />;
+    const select4 = <Select defaultValue={[123, 456]} />;
+  });
+
+  it("with prop disabled", () => {
+    const select1 = <Select disabled={false} />;
+    const select2 = <Select disabled={true} />;
+    const select3 = <Select disabled />;
+  });
+
+  it("with prop dropdownClassName", () => {
+    const select = <Select dropdownClassName="dropdown-css-class" />;
+  });
+
+  it("with prop dropdownMatchSelectWidth", () => {
+    const select1 = <Select dropdownMatchSelectWidth={false} />;
+    const select2 = <Select dropdownMatchSelectWidth={true} />;
+    const select3 = <Select dropdownMatchSelectWidth />;
+  });
+
+  it("with prop filterOption", () => {
+    const select1 = <Select filterOption={true} />;
+    const select2 = <Select filterOption={(input: string, option: React$Node) => true} />;
+  });
+
+  it("with prop firstActiveValue", () => {
+    const select1 = <Select firstActiveValue="key-123" />;
+    const select2 = <Select firstActiveValue={["key-123", "key-456", "key-789"]} />;
+  });
+
+  it("with prop labelInValue", () => {
+    const select1 = <Select labelInValue={false} />;
+    const select2 = <Select labelInValue={true} />;
+    const select3 = <Select labelInValue />;
+  });
+
+  it("with prop loading", () => {
+    const select1 = <Select loading={false} />;
+    const select2 = <Select loading={true} />;
+    const select3 = <Select loading />;
+  });
+
+  it("with prop maxTagCount", () => {
+    const select = <Select maxTagCount={10} />;
+  });
+
+  it("with prop mode", () => {
+    const select1 = <Select mode="default" />;
+    const select2 = <Select mode="multiple" />;
+    const select3 = <Select mode="tags" />;
+    // $FlowExpectedError
+    const select4 = <Select mode="notARealOption" />;
+  });
+
+  it("with prop notFoundContent", () => {
+    const select = <Select notFoundContent="No Items" />;
+  });
+
+  it("with prop open", () => {
+    const select1 = <Select open={false} />;
+    const select2 = <Select open={true} />;
+    const select3 = <Select open />;
+  });
+
+  it("with prop optionFilterProp", () => {
+    const select = <Select optionFilterProp="id" />;
+  });
+
+  it("with prop optionLabelProp", () => {
+    const select = <Select optionLabelProp="name" />;
+  });
+
+  it("with prop placeholder", () => {
+    const select1 = <Select placeholder="Please select..." />;
+    const select2 = <Select placeholder={<span>Please select...</span>} />;
+  });
+
+  it("with prop showArrow", () => {
+    const select1 = <Select showArrow={false} />;
+    const select2 = <Select showArrow={true} />;
+    const select3 = <Select showArrow />;
+  });
+
+  it("with prop showSearch", () => {
+    const select1 = <Select showSearch={false} />;
+    const select2 = <Select showSearch={true} />;
+    const select3 = <Select showSearch />;
+  });
+
+  it("with prop size", () => {
+    const select1 = <Select size="default" />;
+    const select2 = <Select size="small" />;
+    const select3 = <Select size="large" />;
+    const select4 = <Select size="32px" />;
+  });
+
+  it("with prop suffixIcon", () => {
+    const select = <Select suffixIcon={<Icon />} />;
+  });
+
+  it("with prop removeIcon", () => {
+    const select = <Select removeIcon={<Icon />} />;
+  });
+
+  it("with prop clearIcon", () => {
+    const select = <Select clearIcon={<Icon />} />;
+  });
+
+  it("with prop menuItemSelectedIcon", () => {
+    const select = <Select menuItemSelectedIcon={<Icon />} />;
+  });
+
+  it("with prop tokenSeparators", () => {
+    const select = <Select tokenSeparators={[",", "|"]} />;
+  });
+
+  it("with prop value", () => {
+    const select1 = <Select value="key-123" />;
+    const select2 = <Select value={["key-123", "key-456"]} />;
+    const select3 = <Select value={123} />;
+    const select4 = <Select value={[123, 456]} />;
+  });
+
+  it("with prop onBlur", () => {
+    const select = <Select onBlur={() => undefined} />;
+  });
+
+  it("with prop onChange", () => {
+    const select1 = <Select onChange={() => undefined} />;
+    const select2 = <Select value="key-123" onChange={(value: string) => undefined} />;
+    const select3 = <Select value={["key-123", "key-456"]} onChange={(value: string[]) => undefined} />;
+    const select4 = <Select value={123} onChange={(value: number) => undefined} />;
+    const select5 = <Select value={[123, 456]} onChange={(value: number[]) => undefined} />;
+  });
+
+  it("with prop onDeselect", () => {
+    const select1 = <Select onDeselect={() => undefined} />;
+    const select2 = <Select value="key-123" onDeselect={(value: string) => undefined} />;
+    const select3 = <Select value={["key-123", "key-456"]} onDeselect={(value: string[]) => undefined} />;
+    const select4 = <Select value={123} onDeselect={(value: number) => undefined} />;
+    const select5 = <Select value={[123, 456]} onDeselect={(value: number[]) => undefined} />;
+  });
+
+  it("with prop onDropdownVisibleChange", () => {
+    const select = <Select onDropdownVisibleChange={(open: boolean) => undefined} />;
+  });
+
+  it("with prop onFocus", () => {
+    const select = <Select onFocus={() => undefined} />;
+  });
+
+  it("with prop onSearch", () => {
+    const select = <Select onSearch={(value: string) => undefined} />;
+  });
+
+  it("with prop onSelect", () => {
+    const select1 = <Select onSelect={() => undefined} />;
+    const select2 = <Select value="key-123" onSelect={(value: string) => undefined} />;
+    const select3 = <Select value={["key-123", "key-456"]} onSelect={(value: string[]) => undefined} />;
+    const select4 = <Select value={123} onSelect={(value: number) => undefined} />;
+    const select5 = <Select value={[123, 456]} onSelect={(value: number[]) => undefined} />;
+  });
+});
+
+describe("Select.Option", () => {
+  it("is a react component", () => {
+    const selectOption = <Select.Option />;
+  });
+
+  it("with prop className", () => {
+    const selectOption = <Select.Option className="my-option" />;
+  })
+
+  it("with prop disabled", () => {
+    const selectOption1 = <Select.Option disabled={false} />;
+    const selectOption2 = <Select.Option disabled={true} />;
+    const selectOption3 = <Select.Option disabled />;
+  })
+
+  it("with prop key", () => {
+    const selectOption = <Select.Option key="key-123" />;
+  })
+
+  it("with prop title", () => {
+    const selectOption = <Select.Option title="This is a test title." />;
+  })
+
+  it("with prop value", () => {
+    const selectOption1 = <Select.Option value="value-123" />;
+    const selectOption2 = <Select.Option value={123} />;
+  })
+});
+
+describe("Select.OptGroup", () => {
+  it("is a react component", () => {
+    const selectOptGroup = <Select.OptGroup />;
+  })
+
+  it("with prop key", () => {
+    const selectOptGroup = <Select.OptGroup key="key-123" />;
+  })
+
+  it("with prop label", () => {
+    const selectOptGroup = <Select.OptGroup label="This is a test label." />;
+  })
+})
+
+describe("Slider", () => {
+  it("is a react component", () => {
+    const slider = <Slider />;
+  });
+});
+
+describe("Spin", () => {
+  it("is a react component", () => {
+    const spin = <Spin />;
+  });
+});
+
+describe("Steps", () => {
+  it("is a react component", () => {
+    const steps = <Steps />;
+  });
+
+  it("with Steps.Step", () => {
+    const steps = (
+      <Steps size="small" current={1}>
+        <Steps.Step title="Finished" description="This is a description." />
+        <Steps.Step
+          stats="process"
+          title="In Progress"
+          description="This is a description."
+        />
+        <Steps.Step
+          status="wait"
+          title="Waiting"
+          description="This is a description."
+        />
+      </Steps>
+    );
+  });
+});
+
+describe("Table", () => {
+  it("is a react component", () => {
+    const table = <Table />;
+  });
+});
+
+describe("Tabs", () => {
+  it("is a react component", () => {
+    const tabs = <Tabs />;
+  });
+});
+
+describe("Tabs.TabPane", () => {
+  it("is a react component", () => {
+    const tabPane = <Tabs.TabPane />;
+  });
+});
+
+describe("Tag", () => {
+  it("is a react component", () => {
+    const tag = <Tag />;
+  });
+});
+
+describe("Tooltip", () => {
+  it("is a react component", () => {
+    const tooltip = <Tooltip title="hello" />;
+  });
+  it("should accept only certain strings for placement prop", () => {
+    // Testing placement prop in particular just to verify sharing between
+    // Popconfirm, Popover, and Tooltip is working.
+    const good = <Tooltip title='tooltip' placement='top' />;
+    // $FlowExpectedError
+    const bad = <Tooltip title='tooltip' placement='topCenter' />;
+  });
+});
+
+describe("TreeSelect", () => {
+  it("is a react component", () => {
+    const treeSelect = <TreeSelect />;
+  });
+});
+
+describe("TreeSelect.TreeNode", () => {
+  it("is a react component", () => {
+    const treeNode = <TreeSelect.TreeNode />;
+  });
+});
diff --git a/definitions/npm/axios_v0.17.x/flow_v0.104.x-/axios_v0.17.x.js b/definitions/npm/axios_v0.17.x/flow_v0.104.x-v.200.x/axios_v0.17.x.js
similarity index 100%
rename from definitions/npm/axios_v0.17.x/flow_v0.104.x-/axios_v0.17.x.js
rename to definitions/npm/axios_v0.17.x/flow_v0.104.x-v.200.x/axios_v0.17.x.js
diff --git a/definitions/npm/axios_v0.17.x/flow_v0.104.x-/test_axios-v0.17.js b/definitions/npm/axios_v0.17.x/flow_v0.104.x-v.200.x/test_axios-v0.17.js
similarity index 100%
rename from definitions/npm/axios_v0.17.x/flow_v0.104.x-/test_axios-v0.17.js
rename to definitions/npm/axios_v0.17.x/flow_v0.104.x-v.200.x/test_axios-v0.17.js
diff --git a/definitions/npm/axios_v0.17.x/flow_v0.201.x-/axios_v0.17.x.js b/definitions/npm/axios_v0.17.x/flow_v0.201.x-/axios_v0.17.x.js
new file mode 100644
index 0000000000..33ad6a5ee1
--- /dev/null
+++ b/definitions/npm/axios_v0.17.x/flow_v0.201.x-/axios_v0.17.x.js
@@ -0,0 +1,148 @@
+declare module 'axios' {
+  declare interface ProxyConfig {
+    host: string;
+    port: number;
+  }
+  declare interface Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+  declare interface Canceler {
+    (message?: string): void;
+  }
+  declare interface CancelTokenSource {
+    token: CancelToken;
+    cancel: Canceler;
+  }
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): CancelToken;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+  declare interface AxiosXHRConfigBase<T> {
+    adapter?: <T>(config: AxiosXHRConfig<T>) => Promise<AxiosXHR<T>>;
+    auth?: {
+      username: string,
+      password: string,
+      ...
+    };
+    baseURL?: string;
+    cancelToken?: CancelToken;
+    headers?: Object;
+    httpAgent?: mixed; // Missing the type in the core flow node libdef
+    httpsAgent?: mixed; // Missing the type in the core flow node libdef
+    maxContentLength?: number;
+    maxRedirects?: number;
+    params?: Object;
+    paramsSerializer?: (params: Object) => string;
+    onUploadProgress?: (progressEvent: ProgressEvent) => void;
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void;
+    proxy?: ProxyConfig | false;
+    responseType?:
+      | 'arraybuffer'
+      | 'blob'
+      | 'document'
+      | 'json'
+      | 'text'
+      | 'stream';
+    timeout?: number;
+    transformRequest?: Array<<U>(data: T) => U | Array<<U>(data: T) => U>>;
+    transformResponse?: Array<<U>(data: T) => U>;
+    validateStatus?: (status: number) => boolean;
+    withCredentials?: boolean;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+  }
+  declare type $AxiosXHRConfigBase<T> = AxiosXHRConfigBase<T>;
+  declare interface AxiosXHRConfig<T> extends AxiosXHRConfigBase<T> {
+    data?: T;
+    method?: string;
+    url: string;
+  }
+  declare type $AxiosXHRConfig<T> = AxiosXHRConfig<T>;
+  declare class AxiosXHR<T> {
+    config: AxiosXHRConfig<T>;
+    data: T;
+    headers?: Object;
+    status: number;
+    statusText: string;
+    request: http$ClientRequest<> | XMLHttpRequest;
+  }
+  declare type $AxiosXHR<T> = AxiosXHR<T>;
+  declare type AxiosInterceptorIdent = number;
+  declare class AxiosRequestInterceptor<T> {
+    use(
+      successHandler: ?(
+        response: AxiosXHRConfig<T>
+      ) => Promise<AxiosXHRConfig<any>> | AxiosXHRConfig<any>,
+      errorHandler: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent;
+    eject(ident: AxiosInterceptorIdent): void;
+  }
+  declare class AxiosResponseInterceptor<T> {
+    use(
+      successHandler: ?(response: AxiosXHR<T>) => mixed,
+      errorHandler: ?(error: $AxiosError<any>) => mixed
+    ): AxiosInterceptorIdent;
+    eject(ident: AxiosInterceptorIdent): void;
+  }
+  declare type AxiosPromise<T> = Promise<AxiosXHR<T>>;
+  declare class Axios {
+    constructor<T>(config?: AxiosXHRConfigBase<T>): void;
+    static <T>(
+      config: AxiosXHRConfig<T> | string,
+      config?: AxiosXHRConfig<T>
+    ): AxiosPromise<T>;
+    request<T>(config: AxiosXHRConfig<T>): AxiosPromise<T>;
+    delete<T>(url: string, config?: AxiosXHRConfigBase<T>): AxiosPromise<T>;
+    get<T>(url: string, config?: AxiosXHRConfigBase<T>): AxiosPromise<T>;
+    head<T>(url: string, config?: AxiosXHRConfigBase<T>): AxiosPromise<T>;
+    post<T>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T>
+    ): AxiosPromise<T>;
+    put<T>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T>
+    ): AxiosPromise<T>;
+    patch<T>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T>
+    ): AxiosPromise<T>;
+    interceptors: {
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+      ...
+    };
+    defaults: { headers: Object, ... } & AxiosXHRConfig<any>;
+  }
+
+  declare class AxiosError<T> extends Error {
+    config: AxiosXHRConfig<T>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T>;
+    code?: string;
+  }
+
+  declare type $AxiosError<T> = AxiosError<T>;
+
+  declare interface AxiosExport extends Axios {
+    <T>(
+      config: AxiosXHRConfig<T> | string,
+      config?: AxiosXHRConfig<T>
+    ): AxiosPromise<T>;
+    Axios: typeof Axios;
+    Cancel: Class<Cancel>;
+    CancelToken: Class<CancelToken>;
+    isCancel(value: any): boolean;
+    create(config?: AxiosXHRConfigBase<any>): Axios;
+    all: typeof Promise.all;
+    spread(callback: Function): (arr: Array<any>) => Function;
+  }
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.17.x/flow_v0.201.x-/test_axios-v0.17.js b/definitions/npm/axios_v0.17.x/flow_v0.201.x-/test_axios-v0.17.js
new file mode 100644
index 0000000000..8506ecc63e
--- /dev/null
+++ b/definitions/npm/axios_v0.17.x/flow_v0.201.x-/test_axios-v0.17.js
@@ -0,0 +1,89 @@
+// @flow
+import axios from 'axios';
+import type {
+  $AxiosXHR,
+  CancelTokenSource,
+  Cancel,
+} from 'axios';
+(axios.get('foo'): Promise<any>);
+(axios.post('bar', {}, {
+  headers: {
+    foo: 'asdf',
+  },
+  xsrfCookieName: 'cookie',
+}): Promise<any>);
+// $FlowExpectedError
+(axios.post(123): Promise<any>);
+
+(axios('url'): Promise<any>);
+
+const client = axios.create();
+
+client.post('/something', {});
+
+(client.defaults.headers.common.Authorization = 'test')
+
+const source: CancelTokenSource = axios.CancelToken.source();
+source.token.promise.then((cancel: Cancel) => {
+  const x: string = cancel.message;
+});
+client.get('/something', {
+  cancelToken: source.token,
+});
+// $FlowExpectedError
+client.get('/something', {
+  cancelToken: source,
+});
+
+source.cancel();
+source.cancel('canceled');
+// $FlowExpectedError
+source.cancel(42);
+
+// $FlowExpectedError
+client.post(232);
+
+type Data = {
+    items: Array<string>,
+    ...
+};
+
+axios.get('/user', {
+  params: {
+    ID: 12345
+  }
+}).then((res) => {
+    res.data[0];
+});
+
+// Send a POST request
+axios({
+  method: 'post',
+  url: '/user/12345',
+  data: {
+    firstName: 'Fred',
+    lastName: 'Flintstone'
+  }
+}).then(r => {
+  // $FlowExpectedError
+  (r.status: string);
+});
+
+class AxiosExtended extends axios.Axios {
+  specialPut(...args) {
+    return super.put(...args);
+  }
+}
+
+const extended = new AxiosExtended();
+axios.all([
+  extended.specialPut('foo')
+    .then((r) => {
+        // $FlowExpectedError
+        (r.statusText: number)
+    }),
+    Promise.reject(12)
+]).then(([a, b]) => {
+    // $FlowExpectedError
+    (a: string);
+})
diff --git a/definitions/npm/axios_v0.18.x/flow_v0.104.x-/axios_v0.18.x.js b/definitions/npm/axios_v0.18.x/flow_v0.104.x-v.200.x/axios_v0.18.x.js
similarity index 100%
rename from definitions/npm/axios_v0.18.x/flow_v0.104.x-/axios_v0.18.x.js
rename to definitions/npm/axios_v0.18.x/flow_v0.104.x-v.200.x/axios_v0.18.x.js
diff --git a/definitions/npm/axios_v0.18.x/flow_v0.104.x-/test_axios_v0.18.x.js b/definitions/npm/axios_v0.18.x/flow_v0.104.x-v.200.x/test_axios_v0.18.x.js
similarity index 100%
rename from definitions/npm/axios_v0.18.x/flow_v0.104.x-/test_axios_v0.18.x.js
rename to definitions/npm/axios_v0.18.x/flow_v0.104.x-v.200.x/test_axios_v0.18.x.js
diff --git a/definitions/npm/axios_v0.18.x/flow_v0.201.x-/axios_v0.18.x.js b/definitions/npm/axios_v0.18.x/flow_v0.201.x-/axios_v0.18.x.js
new file mode 100644
index 0000000000..9277aa14ef
--- /dev/null
+++ b/definitions/npm/axios_v0.18.x/flow_v0.201.x-/axios_v0.18.x.js
@@ -0,0 +1,169 @@
+declare module 'axios' {
+  declare interface AxiosTransformer<T> {
+    (data: T, headers?: Object): Object;
+  }
+  declare interface ProxyConfig {
+    host: string;
+    port: number;
+    auth?: {
+      username: string,
+      password: string,
+      ...
+    };
+  }
+  declare interface Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+  declare interface Canceler {
+    (message?: string): void;
+  }
+  declare interface CancelTokenSource {
+    token: CancelToken;
+    cancel: Canceler;
+  }
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): CancelToken;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+  declare interface AxiosXHRConfigBase<T, R = T> {
+    adapter?: <T, R>(config: AxiosXHRConfig<T, R>) => Promise<AxiosXHR<T, R>>;
+    auth?: {
+      username: string,
+      password: string,
+      ...
+    };
+    baseURL?: string;
+    cancelToken?: CancelToken;
+    headers?: Object;
+    httpAgent?: mixed; // Missing the type in the core flow node libdef
+    httpsAgent?: mixed; // Missing the type in the core flow node libdef
+    maxContentLength?: number;
+    maxRedirects?: number;
+    params?: Object;
+    paramsSerializer?: (params: Object) => string;
+    onUploadProgress?: (progressEvent: ProgressEvent) => void;
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void;
+    proxy?: ProxyConfig | false;
+    responseType?:
+      | 'arraybuffer'
+      | 'blob'
+      | 'document'
+      | 'json'
+      | 'text'
+      | 'stream';
+    timeout?: number;
+    transformRequest?: AxiosTransformer<T> | Array<AxiosTransformer<T>>;
+    transformResponse?: AxiosTransformer<R> | Array<AxiosTransformer<R>>;
+    validateStatus?: (status: number) => boolean;
+    withCredentials?: boolean;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+  }
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+  declare interface AxiosXHRConfig<T, R = T> extends AxiosXHRConfigBase<T, R> {
+    data?: T;
+    method?: string;
+    url: string;
+  }
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+  declare class AxiosXHR<T, R = T> {
+    config: AxiosXHRConfig<T, R>;
+    data: R;
+    headers?: Object;
+    status: number;
+    statusText: string;
+    request: http$ClientRequest<> | XMLHttpRequest;
+  }
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+  declare type AxiosInterceptorIdent = number;
+  declare class AxiosRequestInterceptor<T, R = T> {
+    use(
+      successHandler: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<any, any>> | AxiosXHRConfig<any, any>,
+      errorHandler: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent;
+    eject(ident: AxiosInterceptorIdent): void;
+  }
+  declare class AxiosResponseInterceptor<T, R = T> {
+    use(
+      successHandler: ?(response: AxiosXHR<T, R>) => mixed,
+      errorHandler: ?(error: $AxiosError<any>) => mixed
+    ): AxiosInterceptorIdent;
+    eject(ident: AxiosInterceptorIdent): void;
+  }
+  declare type AxiosPromise<T, R = T> = Promise<AxiosXHR<T, R>>;
+  declare class Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfig<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(config: AxiosXHRConfig<T, R>): AxiosPromise<T, R>;
+    delete<T, R>(
+      url: string,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    get<T, R>(
+      url: string,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    options<T, R>(
+      url: string,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    head<T, R>(
+      url: string,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    post<T, R>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: mixed,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+      ...
+    };
+    defaults: { headers: Object, ... } & AxiosXHRConfig<any, any>;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+  }
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfig<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: Class<Cancel>;
+    CancelToken: Class<CancelToken>;
+    isCancel(value: any): boolean;
+    create(config?: AxiosXHRConfigBase<any, any>): Axios;
+    all: typeof Promise.all;
+    spread(callback: Function): (arr: Array<any>) => Function;
+  }
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.18.x/flow_v0.201.x-/test_axios_v0.18.x.js b/definitions/npm/axios_v0.18.x/flow_v0.201.x-/test_axios_v0.18.x.js
new file mode 100644
index 0000000000..e91c6022a8
--- /dev/null
+++ b/definitions/npm/axios_v0.18.x/flow_v0.201.x-/test_axios_v0.18.x.js
@@ -0,0 +1,111 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosXHR,
+  CancelTokenSource,
+  Cancel,
+  AxiosPromise,
+} from 'axios';
+(axios.get('foo'): Promise<any>);
+(axios.post('bar', {}, {
+  headers: {
+    foo: 'asdf',
+  },
+  xsrfCookieName: 'cookie',
+}): Promise<any>);
+// $FlowExpectedError
+(axios.post(123): Promise<any>);
+
+(axios('url'): Promise<any>);
+
+const client = axios.create();
+
+client.post('/something', {});
+client.options('/something', {});
+
+(client.defaults.headers.common.Authorization = 'test')
+
+const source: CancelTokenSource = axios.CancelToken.source();
+source.token.promise.then((cancel: Cancel) => {
+  const x: string = cancel.message;
+});
+client.get('/something', {
+  cancelToken: source.token,
+});
+// $FlowExpectedError
+client.get('/something', {
+  cancelToken: source,
+});
+
+source.cancel();
+source.cancel('canceled');
+// $FlowExpectedError
+source.cancel(42);
+
+// $FlowExpectedError
+client.post(232);
+
+type Data = {
+    items: Array<string>,
+    ...
+};
+
+axios.get('/user', {
+  params: {
+    ID: 12345
+  }
+}).then((res) => {
+    res.data[0];
+});
+
+// Send a POST request
+axios({
+  method: 'post',
+  url: '/user/12345',
+  data: {
+    firstName: 'Fred',
+    lastName: 'Flintstone'
+  }
+}).then(r => {
+  // $FlowExpectedError
+  (r.status: string);
+});
+
+class AxiosExtended extends axios.Axios {
+  specialPut(...args) {
+    return super.put(...args);
+  }
+}
+
+const extended = new AxiosExtended();
+axios.all([
+  extended.specialPut('foo')
+    .then((r) => {
+        // $FlowExpectedError
+        (r.statusText: number)
+    }),
+    Promise.reject(12)
+]).then(([a, b]) => {
+    // $FlowExpectedError
+    (a: string);
+})
+
+const promise1: AxiosPromise<{ foo: string, ... }, { bar: string, ... }> = axios({ url: '/', method: 'post', data: { foo: 'bar' }})
+promise1.then(({ data }) => {
+  (data.bar: string);
+  // $FlowExpectedError
+  data.foo;
+});
+
+const promise2: AxiosPromise<{ foo: number, ... }> = axios({ url: '/', method: 'post', data: { foo: 1 }})
+promise2.then(({ data }) => {
+  data.foo + 1;
+});
+
+describe('create', () => {
+  it('returns a callable axios instance', () => {
+    const a = axios.create();
+    a({ method: 'post', url: 'https://foo.bar' })
+  })
+})
diff --git a/definitions/npm/backbone-collection_v1.x.x/flow_v0.104.x-/backbone-collection_v1.x.x.js b/definitions/npm/backbone-collection_v1.x.x/flow_v0.104.x-v.200.x/backbone-collection_v1.x.x.js
similarity index 100%
rename from definitions/npm/backbone-collection_v1.x.x/flow_v0.104.x-/backbone-collection_v1.x.x.js
rename to definitions/npm/backbone-collection_v1.x.x/flow_v0.104.x-v.200.x/backbone-collection_v1.x.x.js
diff --git a/definitions/npm/backbone-collection_v1.x.x/flow_v0.201.x-/backbone-collection_v1.x.x.js b/definitions/npm/backbone-collection_v1.x.x/flow_v0.201.x-/backbone-collection_v1.x.x.js
new file mode 100644
index 0000000000..496a24b93c
--- /dev/null
+++ b/definitions/npm/backbone-collection_v1.x.x/flow_v0.201.x-/backbone-collection_v1.x.x.js
@@ -0,0 +1,221 @@
+// subset of the `backbone` module
+
+// repeated in backbone, backbone-model, and backbone-collection
+
+type Comparator<T> = (attr: string) => any | ((attrA: T, attrB: T) => number);
+
+declare module "backbone-collection" {
+  declare type EventCallback = (event: Event) => void | mixed;
+  declare type Backbone$Attrs = { [name: string]: mixed, ... };
+  declare type CRUDMethod = "create" | "read" | "update" | "delete";
+
+  declare var version: string;
+
+  /**
+   * Events Module - http://backbonejs.org/#Events
+   */
+  declare class Events {
+    // Not sure the best way of adding these to the declaration files
+    on(event: string, callback: EventCallback, context?: Object): void;
+    once(event: string, callback: EventCallback, context?: Object): void;
+    bind(event: string, callback: EventCallback, context?: Object): void;
+    off(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    unbind(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    trigger(event: string, ...args?: Array<mixed>): void;
+    listenTo(other: Events, event: string, callback: EventCallback): void;
+    listenToOnce(other: Events, event: string, callback: EventCallback): void;
+    stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static on(event: string, callback: EventCallback, context?: Object): void;
+    static bind(event: string, callback: EventCallback, context?: Object): void;
+    static off(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static unbind(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static trigger(event: string, ...args?: Array<mixed>): void;
+    static listenTo(
+      other: Events,
+      event: string,
+      callback: EventCallback
+    ): void;
+    static stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+  }
+
+  /**
+   * Model Class - http://backbonejs.org/#Model
+   */
+  declare type ModelOpts = {
+    [optionName: string]: mixed,
+    collection?: Collection<any>,
+    parse?: Function,
+    ...
+  };
+
+  declare class Model {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Model & P> & CP;
+    constructor(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    static initialize(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    initialize(): void;
+    get(attr: ?string): any;
+    set(attrs: Backbone$Attrs, options?: Object): this;
+    set(attr: string, value: mixed, options?: Object): this;
+    escape(attr: string): mixed;
+    has(attr: string): boolean;
+    unset(attr: string, options?: { unset?: boolean, ... }): this;
+    clear(options?: Object): this;
+    id: string | number;
+    idAttribute: string;
+    cid: string;
+    cidPrefix: string;
+    attributes: Backbone$Attrs;
+    changed: Object;
+    defaults: Backbone$Attrs;
+    toJSON(): Backbone$Attrs;
+    sync: typeof sync;
+    //Start jQuery XHR
+    // @TODO should return a jQuery XHR, but I cannot define this without the dependency on jquery lib def
+    fetch(options?: Object): any;
+    save(attrs: Backbone$Attrs, options?: Object): any;
+    save(attr: string, value: mixed, options?: Object): any;
+    destroy(options?: Object): any;
+    // End jQuery XHR
+    validate(attrs: Backbone$Attrs, options?: Object): boolean;
+    validationError: ?Object;
+    isValid(): boolean;
+    url(): string;
+    urlRoot: string | (() => string);
+    parse(response: Object, options?: Object): any;
+    clone(): this;
+    isNew(): boolean;
+    hasChanged(attribute?: string): boolean;
+    changedAttributes(attributes?: { [attr: string]: mixed, ... }): boolean;
+    previous(attribute: string): mixed;
+    previousAttributes(): Backbone$Attrs;
+    // Start Underscore methods
+    // @TODO Underscore Methods should be defined by the library definition
+    keys(): string[];
+    values(): mixed[];
+    pairs: Function;
+    invert: Function;
+    pick: Function;
+    omit: Function;
+    chain(): Function;
+    isEmpty(): boolean;
+    // End underscore methods
+  }
+
+  /**
+   * Collection Class - http://backbonejs.org/#Collection
+   */
+  declare class Collection<TModel> {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Collection<any> & P> & CP;
+    constructor(models?: TModel, options?: Object): this;
+    initialize(models?: TModel, options?: Object): this;
+    model: TModel;
+    modelId(attributes: TModel): string;
+    models: TModel[];
+    toJSON(options?: Object): TModel[];
+    sync: typeof sync;
+    // Underscore Methods
+    // @TODO should be defined by the underscore library defintion and not as generic functions.
+    forEach: Function; //(each)
+    map: Function; //(collect)
+    reduce: Function; // (foldl, inject)
+    reduceRight: Function; //(foldr)
+    find: Function; // (detect)
+    findIndex: Function;
+    findLastIndex: Function;
+    filter: Function; //(select)
+    reject: Function;
+    every: Function; //(all)
+    some: Function; //(any)
+    contains: Function; //(includes)
+    invoke: Function;
+    max: Function;
+    min: Function;
+    sortBy: Function;
+    groupBy: Function;
+    shuffle: Function;
+    toArray: Function;
+    size: Function;
+    first: Function; //(head, take)
+    initial: Function;
+    rest: Function; //(tail, drop)
+    last: Function;
+    without: Function;
+    indexOf: Function;
+    lastIndexOf: Function;
+    isEmpty: Function;
+    chain: Function;
+    difference: Function;
+    sample: Function;
+    partition: Function;
+    countBy: Function;
+    indexBy: Function;
+    // end underscore methods
+    add(models: Array<TModel>, options?: Object): TModel[];
+    add(model?: TModel, options?: Object): ?TModel;
+    remove(models: Array<TModel>, options?: Object): TModel[];
+    remove(model: TModel, options?: Object): ?TModel;
+    reset(models: Array<TModel>, options?: Object): TModel[];
+    reset(model?: TModel, options?: Object): ?TModel;
+    set(models: Array<TModel>, options?: Object): TModel[];
+    set(model?: TModel, options?: Object): ?TModel;
+    get(id: string): ?TModel;
+    at(index: number): ?TModel;
+    push(model: TModel, options?: Object): void;
+    pop(otions?: Object): void;
+    unshift(model: TModel, options?: Object): void;
+    shift(options?: Object): TModel;
+    slice(begin: number, end: number): Array<TModel>;
+    length: number;
+    comparator: string | Comparator<TModel>;
+    sort(options?: Object): Array<TModel>;
+    pluck(attribute: string): Array<TModel>;
+    where(attributes: { [attributeName: string]: mixed, ... }): Array<TModel>;
+    findWhere(attributes: { [attributeName: string]: mixed, ... }): TModel;
+    url: () => string | string;
+    parse(response: Object, options: Object): Object;
+    clone(): this;
+    fetch(options?: Object): void;
+    create(attributes: Object, options?: Object): void;
+  }
+
+  /**
+   * Sync - http://backbonejs.org/#Sync
+   */
+  declare function sync(
+    method: CRUDMethod,
+    model: Model,
+    options?: Object
+  ): any; // Should really be a jQuery XHR.
+
+  /**
+   * Declaring the export for backbone as well.
+   */
+  declare class Backbone {
+    // subset of the `backbone` module
+    Collection: typeof Collection;
+  }
+
+  declare module.exports: Backbone;
+}
diff --git a/definitions/npm/backbone-model_v1.x.x/flow_v0.104.x-/backbone-model_v1.x.x.js b/definitions/npm/backbone-model_v1.x.x/flow_v0.104.x-v.200.x/backbone-model_v1.x.x.js
similarity index 100%
rename from definitions/npm/backbone-model_v1.x.x/flow_v0.104.x-/backbone-model_v1.x.x.js
rename to definitions/npm/backbone-model_v1.x.x/flow_v0.104.x-v.200.x/backbone-model_v1.x.x.js
diff --git a/definitions/npm/backbone-model_v1.x.x/flow_v0.201.x-/backbone-model_v1.x.x.js b/definitions/npm/backbone-model_v1.x.x/flow_v0.201.x-/backbone-model_v1.x.x.js
new file mode 100644
index 0000000000..2a2fe6ec96
--- /dev/null
+++ b/definitions/npm/backbone-model_v1.x.x/flow_v0.201.x-/backbone-model_v1.x.x.js
@@ -0,0 +1,219 @@
+// subset of the `backbone` module
+
+// repeated in backbone, backbone-model, and backbone-collection
+
+type Comparator<T> = (attr: string) => any | ((attrA: T, attrB: T) => number);
+
+declare module "backbone-model" {
+  declare type EventCallback = (event: Event) => void | mixed;
+  declare type Backbone$Attrs = { [name: string]: mixed, ... };
+  declare type CRUDMethod = "create" | "read" | "update" | "delete";
+
+  /**
+   * Events Module - http://backbonejs.org/#Events
+   */
+  declare class Events {
+    // Not sure the best way of adding these to the declaration files
+    on(event: string, callback: EventCallback, context?: Object): void;
+    once(event: string, callback: EventCallback, context?: Object): void;
+    bind(event: string, callback: EventCallback, context?: Object): void;
+    off(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    unbind(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    trigger(event: string, ...args?: Array<mixed>): void;
+    listenTo(other: Events, event: string, callback: EventCallback): void;
+    listenToOnce(other: Events, event: string, callback: EventCallback): void;
+    stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static on(event: string, callback: EventCallback, context?: Object): void;
+    static bind(event: string, callback: EventCallback, context?: Object): void;
+    static off(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static unbind(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static trigger(event: string, ...args?: Array<mixed>): void;
+    static listenTo(
+      other: Events,
+      event: string,
+      callback: EventCallback
+    ): void;
+    static stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+  }
+
+  /**
+   * Model Class - http://backbonejs.org/#Model
+   */
+  declare type ModelOpts = {
+    [optionName: string]: mixed,
+    collection?: Collection<any>,
+    parse?: Function,
+    ...
+  };
+
+  declare class Model {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Model & P> & CP;
+    constructor(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    static initialize(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    initialize(): void;
+    get(attr: ?string): any;
+    set(attrs: Backbone$Attrs, options?: Object): this;
+    set(attr: string, value: mixed, options?: Object): this;
+    escape(attr: string): mixed;
+    has(attr: string): boolean;
+    unset(attr: string, options?: { unset?: boolean, ... }): this;
+    clear(options?: Object): this;
+    id: string | number;
+    idAttribute: string;
+    cid: string;
+    cidPrefix: string;
+    attributes: Backbone$Attrs;
+    changed: Object;
+    defaults: Backbone$Attrs;
+    toJSON(): Backbone$Attrs;
+    sync: typeof sync;
+    //Start jQuery XHR
+    // @TODO should return a jQuery XHR, but I cannot define this without the dependency on jquery lib def
+    fetch(options?: Object): any;
+    save(attrs: Backbone$Attrs, options?: Object): any;
+    save(attr: string, value: mixed, options?: Object): any;
+    destroy(options?: Object): any;
+    // End jQuery XHR
+    validate(attrs: Backbone$Attrs, options?: Object): boolean;
+    validationError: ?Object;
+    isValid(): boolean;
+    url(): string;
+    urlRoot: string | (() => string);
+    parse(response: Object, options?: Object): any;
+    clone(): this;
+    isNew(): boolean;
+    hasChanged(attribute?: string): boolean;
+    changedAttributes(attributes?: { [attr: string]: mixed, ... }): boolean;
+    previous(attribute: string): mixed;
+    previousAttributes(): Backbone$Attrs;
+    // Start Underscore methods
+    // @TODO Underscore Methods should be defined by the library definition
+    keys(): string[];
+    values(): mixed[];
+    pairs: Function;
+    invert: Function;
+    pick: Function;
+    omit: Function;
+    chain(): Function;
+    isEmpty(): boolean;
+    // End underscore methods
+  }
+
+  /**
+   * Collection Class - http://backbonejs.org/#Collection
+   */
+  declare class Collection<TModel> {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Collection<any> & P> & CP;
+    constructor(models?: TModel, options?: Object): this;
+    initialize(models?: TModel, options?: Object): this;
+    model: TModel;
+    modelId(attributes: TModel): string;
+    models: TModel[];
+    toJSON(options?: Object): TModel[];
+    sync: typeof sync;
+    // Underscore Methods
+    // @TODO should be defined by the underscore library defintion and not as generic functions.
+    forEach: Function; //(each)
+    map: Function; //(collect)
+    reduce: Function; // (foldl, inject)
+    reduceRight: Function; //(foldr)
+    find: Function; // (detect)
+    findIndex: Function;
+    findLastIndex: Function;
+    filter: Function; //(select)
+    reject: Function;
+    every: Function; //(all)
+    some: Function; //(any)
+    contains: Function; //(includes)
+    invoke: Function;
+    max: Function;
+    min: Function;
+    sortBy: Function;
+    groupBy: Function;
+    shuffle: Function;
+    toArray: Function;
+    size: Function;
+    first: Function; //(head, take)
+    initial: Function;
+    rest: Function; //(tail, drop)
+    last: Function;
+    without: Function;
+    indexOf: Function;
+    lastIndexOf: Function;
+    isEmpty: Function;
+    chain: Function;
+    difference: Function;
+    sample: Function;
+    partition: Function;
+    countBy: Function;
+    indexBy: Function;
+    // end underscore methods
+    add(models: Array<TModel>, options?: Object): TModel[];
+    add(model?: TModel, options?: Object): ?TModel;
+    remove(models: Array<TModel>, options?: Object): TModel[];
+    remove(model: TModel, options?: Object): ?TModel;
+    reset(models: Array<TModel>, options?: Object): TModel[];
+    reset(model?: TModel, options?: Object): ?TModel;
+    set(models: Array<TModel>, options?: Object): TModel[];
+    set(model?: TModel, options?: Object): ?TModel;
+    get(id: string): ?TModel;
+    at(index: number): ?TModel;
+    push(model: TModel, options?: Object): void;
+    pop(otions?: Object): void;
+    unshift(model: TModel, options?: Object): void;
+    shift(options?: Object): TModel;
+    slice(begin: number, end: number): Array<TModel>;
+    length: number;
+    comparator: string | Comparator<TModel>;
+    sort(options?: Object): Array<TModel>;
+    pluck(attribute: string): Array<TModel>;
+    where(attributes: { [attributeName: string]: mixed, ... }): Array<TModel>;
+    findWhere(attributes: { [attributeName: string]: mixed, ... }): TModel;
+    url: () => string | string;
+    parse(response: Object, options: Object): Object;
+    clone(): this;
+    fetch(options?: Object): void;
+    create(attributes: Object, options?: Object): void;
+  }
+
+  /**
+   * Sync - http://backbonejs.org/#Sync
+   */
+  declare function sync(
+    method: CRUDMethod,
+    model: Model,
+    options?: Object
+  ): any; // Should really be a jQuery XHR.
+
+  /**
+   * Declaring the export for backbone as well.
+   */
+  declare class Backbone {
+    // subset of the `backbone` module
+    Model: typeof Model;
+  }
+
+  declare module.exports: Backbone;
+}
diff --git a/definitions/npm/backbone_v1.x.x/flow_v0.104.x-/backbone_v1.x.x.js b/definitions/npm/backbone_v1.x.x/flow_v0.104.x-v.200.x/backbone_v1.x.x.js
similarity index 100%
rename from definitions/npm/backbone_v1.x.x/flow_v0.104.x-/backbone_v1.x.x.js
rename to definitions/npm/backbone_v1.x.x/flow_v0.104.x-v.200.x/backbone_v1.x.x.js
diff --git a/definitions/npm/backbone_v1.x.x/flow_v0.201.x-/backbone_v1.x.x.js b/definitions/npm/backbone_v1.x.x/flow_v0.201.x-/backbone_v1.x.x.js
new file mode 100644
index 0000000000..82fc70064b
--- /dev/null
+++ b/definitions/npm/backbone_v1.x.x/flow_v0.201.x-/backbone_v1.x.x.js
@@ -0,0 +1,324 @@
+type Comparator<T> = (attr: string) => any | ((attrA: T, attrB: T) => number);
+
+declare module "backbone" {
+  declare var $: any; // @TODO this is no correct, but it is difficult to require another definition from here.
+  declare var _: any; // @TODO this is no correct, but it is difficult to require another definition from here.
+  declare var version: string;
+
+  declare type EventCallback = (event: Event) => void | mixed;
+  declare type Backbone$Attrs = { [name: string]: mixed, ... };
+  declare type CRUDMethod = "create" | "read" | "update" | "delete";
+
+  /**
+   * Events Module - http://backbonejs.org/#Events
+   */
+  declare class Events {
+    // Not sure the best way of adding these to the declaration files
+    on(event: string, callback: EventCallback, context?: Object): void;
+    once(event: string, callback: EventCallback, context?: Object): void;
+    bind(event: string, callback: EventCallback, context?: Object): void;
+    off(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    unbind(event: ?string, callback?: ?EventCallback, context?: Object): void;
+    trigger(event: string, ...args?: Array<mixed>): void;
+    listenTo(other: Events, event: string, callback: EventCallback): void;
+    listenToOnce(other: Events, event: string, callback: EventCallback): void;
+    stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static on(event: string, callback: EventCallback, context?: Object): void;
+    static bind(event: string, callback: EventCallback, context?: Object): void;
+    static off(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static unbind(
+      event: ?string,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+    static trigger(event: string, ...args?: Array<mixed>): void;
+    static listenTo(
+      other: Events,
+      event: string,
+      callback: EventCallback
+    ): void;
+    static stopListening(
+      other: Events,
+      callback?: ?EventCallback,
+      context?: Object
+    ): void;
+  }
+
+  /**
+   * Model Class - http://backbonejs.org/#Model
+   */
+  declare type ModelOpts = {
+    [optionName: string]: mixed,
+    collection?: Collection<any>,
+    parse?: Function,
+    ...
+  };
+
+  declare class Model extends Events {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Model & P> & CP;
+    constructor(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    static initialize(attributes?: Backbone$Attrs, options?: ModelOpts): void;
+    initialize(): void;
+    get(attr: ?string): any;
+    set(attrs: Backbone$Attrs, options?: Object): this;
+    set(attr: string, value: mixed, options?: Object): this;
+    escape(attr: string): mixed;
+    has(attr: string): boolean;
+    unset(attr: string, options?: { unset?: boolean, ... }): this;
+    clear(options?: Object): this;
+    id: string | number;
+    idAttribute: string;
+    cid: string;
+    cidPrefix: string;
+    attributes: Backbone$Attrs;
+    changed: Object;
+    defaults(): Backbone$Attrs;
+    toJSON(): Backbone$Attrs;
+    sync: typeof sync;
+    //Start jQuery XHR
+    // @TODO should return a jQuery XHR, but I cannot define this without the dependency on jquery lib def
+    fetch(options?: { [key: string]: any, ... }): any;
+    save(attrs: Backbone$Attrs, options?: Object): any;
+    save(attr: string, value: mixed, options?: Object): any;
+    destroy(options?: Object): any;
+    // End jQuery XHR
+    validate(attrs: Backbone$Attrs, options?: Object): boolean;
+    validationError: ?Object;
+    isValid(): boolean;
+    url(): string;
+    urlRoot: string | (() => string);
+    parse(response: Object, options?: Object): any;
+    clone(): this;
+    isNew(): boolean;
+    hasChanged(attribute?: string): boolean;
+    changedAttributes(attributes?: { [attr: string]: mixed, ... }): boolean;
+    previous(attribute: string): mixed;
+    previousAttributes(): Backbone$Attrs;
+    // Start Underscore methods
+    // @TODO Underscore Methods should be defined by the library definition
+    keys(): string[];
+    values(): mixed[];
+    pairs: Function;
+    invert: Function;
+    pick: Function;
+    omit: Function;
+    chain(): Function;
+    isEmpty(): boolean;
+    // End underscore methods
+  }
+
+  /**
+   * Collection Class - http://backbonejs.org/#Collection
+   */
+  declare class Collection<TModel> extends Events {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Collection<any> & P> & CP;
+    constructor(models?: TModel, options?: Object): this;
+    initialize(models?: TModel, options?: Object): this;
+    model: TModel;
+    modelId(attributes: TModel): string;
+    models: TModel[];
+    toJSON(options?: { [key: string]: any, ... }): TModel[];
+    sync: typeof sync;
+    // Underscore Methods
+    // @TODO should be defined by the underscore library defintion and not as generic functions.
+    forEach: Function; //(each)
+    map: Function; //(collect)
+    reduce: Function; // (foldl, inject)
+    reduceRight: Function; //(foldr)
+    find: Function; // (detect)
+    findIndex: Function;
+    findLastIndex: Function;
+    filter: Function; //(select)
+    reject: Function;
+    every: Function; //(all)
+    some: Function; //(any)
+    contains: Function; //(includes)
+    invoke: Function;
+    max: Function;
+    min: Function;
+    sortBy: Function;
+    groupBy: Function;
+    shuffle: Function;
+    toArray: Function;
+    size: Function;
+    first: Function; //(head, take)
+    initial: Function;
+    rest: Function; //(tail, drop)
+    last: Function;
+    without: Function;
+    indexOf: Function;
+    lastIndexOf: Function;
+    isEmpty: Function;
+    chain: Function;
+    difference: Function;
+    sample: Function;
+    partition: Function;
+    countBy: Function;
+    indexBy: Function;
+    // end underscore methods
+    add(models: Array<TModel>, options?: Object): TModel[];
+    add(model?: TModel, options?: Object): ?TModel;
+    remove(models: Array<TModel>, options?: Object): TModel[];
+    remove(model: TModel, options?: Object): ?TModel;
+    reset(models: Array<TModel>, options?: Object): TModel[];
+    reset(model?: TModel, options?: Object): ?TModel;
+    set(models: Array<TModel>, options?: Object): TModel[];
+    set(model?: TModel, options?: Object): ?TModel;
+    get(id: string): ?TModel;
+    at(index: number): ?TModel;
+    push(model: TModel, options?: Object): void;
+    pop(otions?: Object): void;
+    unshift(model: TModel, options?: Object): void;
+    shift(options?: Object): TModel;
+    slice(begin: number, end: number): Array<TModel>;
+    length: number;
+    comparator: string | Comparator<TModel>;
+    sort(options?: Object): Array<TModel>;
+    pluck(attribute: string): Array<TModel>;
+    where(attributes: { [attributeName: string]: mixed, ... }): Array<TModel>;
+    findWhere(attributes: { [attributeName: string]: mixed, ... }): TModel;
+    url: () => string | string;
+    parse(response: Object, options: Object): Object;
+    clone(): this;
+    fetch(options?: { [key: string]: any, ... }): void;
+    create(attributes: Object, options?: Object): void;
+  }
+
+  /**
+   * Router Class http://backbonejs.org/#Router
+   */
+  declare class Router extends Events {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<Router & P> & CP;
+    routes: { [route: string]: string | ((e: Event) => mixed | void), ... };
+    constructor(options?: Object): this;
+    initialize(options?: Object): this;
+    route(
+      route: string,
+      name: string,
+      callback?: (e: Event) => mixed | void
+    ): this;
+    navigate(
+      fragment: string,
+      options?: {
+        trigger?: boolean,
+        replace?: boolean,
+        ...
+      }
+    ): this;
+    execute(callback: Function, args: Array<mixed>, name: string): void | mixed;
+  }
+
+  /**
+   * History - http://backbonejs.org/#History
+   */
+  declare class History extends Events {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<History & P> & CP;
+    static started: boolean;
+    constructor(options?: Object): this;
+    initialize(options?: Object): this;
+    start(options?: {
+      pushState?: boolean,
+      hashChange?: boolean,
+      root?: string,
+      ...
+    }): this;
+    navigate(
+      fragment: string,
+      options?: {
+        trigger?: boolean,
+        replace?: boolean,
+        ...
+      }
+    ): boolean | void;
+    loadUrl(fragment: string): boolean;
+    route(route: string, callback: Function): void;
+    decodeFragment(fragment: string): string;
+    getFragment(): string;
+    fragment: string;
+  }
+  declare var history: History;
+
+  /**
+   * Sync - http://backbonejs.org/#Sync
+   */
+  declare function sync(
+    method: CRUDMethod,
+    model: Model,
+    options?: Object
+  ): any; // Should really be a jQuery XHR.
+  declare function ajax(request: Object): any;
+  declare var emulateHTTP: boolean;
+  declare var emulateJSON: boolean;
+
+  /**
+   * View -
+   */
+  declare type AttributesHasMap = { [attribute: string]: mixed, ... };
+  declare type EventsHash = { [event: string]: string | Function, ... };
+  declare class View extends Events {
+    static extend<P, CP>(
+      instanceProperies: P,
+      classProperties?: CP
+    ): Class<View & P> & CP;
+    constructor(options?: Object): void;
+    initialize(options?: Object): void;
+    el: HTMLElement | string;
+    $el: any;
+    setElement(el: HTMLElement): this;
+    attributes: AttributesHasMap | (() => AttributesHasMap);
+    $: typeof $;
+    template(data: Object): string;
+    render(): this | mixed;
+    remove(): this;
+    events: EventsHash | (() => EventsHash);
+    delegateEvents(events?: EventsHash): this;
+    undelegateEvents(): this;
+  }
+
+  /**
+   * Declaring the export for backbone as well.
+   */
+  declare class Backbone extends Events {
+    Events: typeof Events;
+    Model: typeof Model;
+    Collection: typeof Collection;
+    Router: typeof Router;
+    History: typeof History;
+    history: typeof history;
+    View: typeof View;
+
+    // Sync
+    sync: typeof sync;
+    ajax: typeof ajax;
+    emulateHTTP: typeof emulateHTTP;
+    emulateJSON: typeof emulateJSON;
+
+    // Utilty
+    $: typeof $; // @TODO this is no correct, but it is difficult to require another definition from here.
+    _: typeof _; // @TODO this is no correct, but it is difficult to require another definition from here.
+    version: typeof version;
+    noConflict(): this;
+  }
+
+  declare module.exports: Backbone;
+}
diff --git a/definitions/npm/bee-queue_v1.x.x/flow_v0.104.x-/bee-queue_v1.x.x.js b/definitions/npm/bee-queue_v1.x.x/flow_v0.104.x-v.200.x/bee-queue_v1.x.x.js
similarity index 100%
rename from definitions/npm/bee-queue_v1.x.x/flow_v0.104.x-/bee-queue_v1.x.x.js
rename to definitions/npm/bee-queue_v1.x.x/flow_v0.104.x-v.200.x/bee-queue_v1.x.x.js
diff --git a/definitions/npm/bee-queue_v1.x.x/flow_v0.201.x-/bee-queue_v1.x.x.js b/definitions/npm/bee-queue_v1.x.x/flow_v0.201.x-/bee-queue_v1.x.x.js
new file mode 100644
index 0000000000..00b1aca42f
--- /dev/null
+++ b/definitions/npm/bee-queue_v1.x.x/flow_v0.201.x-/bee-queue_v1.x.x.js
@@ -0,0 +1,76 @@
+declare class BeeQueue$Job extends events$EventEmitter {
+  constructor(queue: BeeQueue$Queue, jobId: number, data: any, options: any): this,
+  backoff(strategy: string, delayFactor?: number): this,
+  data: any,
+  delayUntil(timestamp: number): this,
+  delayUntil(date: Date): this,
+  queue: BeeQueue$Queue,
+  id: number | string,
+  options: any,
+  progress: number,
+  remove(): Promise<this>,
+  remove(callback: (err: ?Error) => void): void,
+  reportProgress(progress: number): this,
+  retries(n: number): this,
+  setId(id: number | string): this,
+  save(): Promise<this>,
+  save(callback: (err: ?Error, job: this) => void): void,
+  status: string,
+  timeout(ms: number): this
+}
+
+type BeeQueue$Page = {
+  end?: number,
+  size?: number,
+  start?: number,
+  ...
+};
+type BeeQueue$Handler = (
+  job: BeeQueue$Job,
+  done: (err?: ?Error, result?: mixed) => void
+) => ?Promise<any>;
+type BeeQueue$Health = { [key: string]: number, ... };
+
+declare class BeeQueue$Queue extends events$EventEmitter {
+  constructor(name: string, settings?: {...}): this,
+  close(timeout: number): Promise<any>,
+  close(timeout: number, callback: (err: ?Error) => void): void,
+  createJob(payload: any): BeeQueue$Job,
+  checkHealth(): Promise<BeeQueue$Health>,
+  checkHealth(callback: (err: ?Error, health: BeeQueue$Health) => void): void,
+  checkStalledJobs(
+    timeout?: number,
+    callback?: (err: ?Error, num: number) => void
+  ): void,
+  destroy(): Promise<any>,
+  destroy(callback: (err: ?Error) => void): void,
+  getJob(jobId: number): Promise<BeeQueue$Job>,
+  getJob(
+    jobId: number,
+    callback: (err: ?Error, job: BeeQueue$Job) => void
+  ): void,
+  getJobs(type: string, page: BeeQueue$Page): Promise<Array<BeeQueue$Job>>,
+  getJobs(
+    type: string,
+    page: BeeQueue$Page,
+    callback: (err: ?Error, jobs: Array<BeeQueue$Job>) => void
+  ): void,
+  jobs: Map<any, BeeQueue$Job>,
+  keyPrefix: string,
+  name: string,
+  paused: boolean,
+  process(handler: BeeQueue$Handler): void,
+  process(concurrency: number, handler: BeeQueue$Handler): void,
+	ready(): Promise<any>,
+	ready(cb: Function): void,
+  removeJob(jobId: number): Promise<any>,
+  removeJob(jobId: number, callback: (err: ?Error) => void): void,
+  settings: {...}
+}
+
+declare module "bee-queue" {
+  declare type Queue = BeeQueue$Queue;
+  declare type Job = BeeQueue$Job;
+
+  declare module.exports: typeof BeeQueue$Queue;
+}
diff --git a/definitions/npm/bluebird_v3.x.x/flow_v0.104.x-/bluebird_v3.x.x.js b/definitions/npm/bluebird_v3.x.x/flow_v0.104.x-v.200.x/bluebird_v3.x.x.js
similarity index 100%
rename from definitions/npm/bluebird_v3.x.x/flow_v0.104.x-/bluebird_v3.x.x.js
rename to definitions/npm/bluebird_v3.x.x/flow_v0.104.x-v.200.x/bluebird_v3.x.x.js
diff --git a/definitions/npm/bluebird_v3.x.x/flow_v0.104.x-/test_bluebird_v3.x.x.js b/definitions/npm/bluebird_v3.x.x/flow_v0.104.x-v.200.x/test_bluebird_v3.x.x.js
similarity index 100%
rename from definitions/npm/bluebird_v3.x.x/flow_v0.104.x-/test_bluebird_v3.x.x.js
rename to definitions/npm/bluebird_v3.x.x/flow_v0.104.x-v.200.x/test_bluebird_v3.x.x.js
diff --git a/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/bluebird_v3.x.x.js b/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/bluebird_v3.x.x.js
new file mode 100644
index 0000000000..8d54369e59
--- /dev/null
+++ b/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/bluebird_v3.x.x.js
@@ -0,0 +1,327 @@
+type Bluebird$RangeError = Error;
+type Bluebird$CancellationErrors = Error;
+type Bluebird$TimeoutError = Error;
+type Bluebird$RejectionError = Error;
+type Bluebird$OperationalError = Error;
+
+type Bluebird$ConcurrencyOption = { concurrency: number, ... };
+type Bluebird$SpreadOption = { spread: boolean, ... };
+type Bluebird$MultiArgsOption = { multiArgs: boolean, ... };
+type Bluebird$BluebirdConfig = {
+  warnings?: boolean,
+  longStackTraces?: boolean,
+  cancellation?: boolean,
+  monitoring?: boolean,
+  ...
+};
+
+declare class Bluebird$PromiseInspection<T> {
+  isCancelled(): boolean;
+  isFulfilled(): boolean;
+  isRejected(): boolean;
+  pending(): boolean;
+  reason(): any;
+  value(): T;
+}
+
+type Bluebird$PromisifyOptions = {|
+  multiArgs?: boolean,
+  context: any
+|};
+
+declare type Bluebird$PromisifyAllOptions = {
+  suffix?: string,
+  filter?: (
+    name: string,
+    func: Function,
+    target?: any,
+    passesDefaultFilter?: boolean
+  ) => boolean,
+  // The promisifier gets a reference to the original method and should return a function which returns a promise
+  promisifier?: (originalMethod: Function) => () => Bluebird$Promise<any>,
+  ...
+};
+
+declare type $Promisable<T> = Promise<T> | T;
+
+declare class Bluebird$Disposable<R> {}
+
+declare class Bluebird$Promise<+R> extends Promise<R> {
+  static RangeError: Class<Bluebird$RangeError>;
+  static CancellationErrors: Class<Bluebird$CancellationErrors>;
+  static TimeoutError: Class<Bluebird$TimeoutError>;
+  static RejectionError: Class<Bluebird$RejectionError>;
+  static OperationalError: Class<Bluebird$OperationalError>;
+
+  static Defer: Class<Bluebird$Defer>;
+  static PromiseInspection: Class<Bluebird$PromiseInspection<any>>;
+
+  static all<T: Iterable<mixed>>(promises: Promise<T>): Bluebird$Promise<
+    $TupleMap<T, <V>(p: Promise<V> | V) => V>
+  >;
+  static all<T: Iterable<mixed>>(promises: T): Bluebird$Promise<
+    $TupleMap<T, <V>(p: Promise<V> | V) => V>
+  >;
+  static props(
+    input: Object | Map<any, any> | $Promisable<Object | Map<any, any>>
+  ): Bluebird$Promise<any>;
+  static any<T, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>
+  ): Bluebird$Promise<T>;
+  static race<T, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>
+  ): Bluebird$Promise<T>;
+  static reject<T>(error?: any): Bluebird$Promise<T>;
+  static resolve(): Bluebird$Promise<void>;
+  static resolve<T>(object: Promise<T>): Bluebird$Promise<T>;
+  static resolve<T>(object: T): Bluebird$Promise<T>;
+  static some<T, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    count: number
+  ): Bluebird$Promise<Array<T>>;
+  static join<T, A>(
+    value1: $Promisable<A>,
+    handler: (a: A) => $Promisable<T>
+  ): Bluebird$Promise<T>;
+  static join<T, A, B>(
+    value1: $Promisable<A>,
+    value2: $Promisable<B>,
+    handler: (a: A, b: B) => $Promisable<T>
+  ): Bluebird$Promise<T>;
+  static join<T, A, B, C>(
+    value1: $Promisable<A>,
+    value2: $Promisable<B>,
+    value3: $Promisable<C>,
+    handler: (a: A, b: B, c: C) => $Promisable<T>
+  ): Bluebird$Promise<T>;
+  static map<T, U, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    mapper: (item: T, index: number, arrayLength: number) => $Promisable<U>,
+    options?: Bluebird$ConcurrencyOption
+  ): Bluebird$Promise<Array<U>>;
+  static mapSeries<T, U, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    mapper: (item: T, index: number, arrayLength: number) => $Promisable<U>
+  ): Bluebird$Promise<Array<U>>;
+  static reduce<T, U, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    reducer: (
+      total: U,
+      current: T,
+      index: number,
+      arrayLength: number
+    ) => $Promisable<U>,
+    initialValue?: $Promisable<U>
+  ): Bluebird$Promise<U>;
+  static filter<T, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    filterer: (
+      item: T,
+      index: number,
+      arrayLength: number
+    ) => $Promisable<boolean>,
+    option?: Bluebird$ConcurrencyOption
+  ): Bluebird$Promise<Array<T>>;
+  static each<T, Elem: $Promisable<T>>(
+    Promises: Iterable<Elem> | $Promisable<Iterable<Elem>>,
+    iterator: (
+      item: T,
+      index: number,
+      arrayLength: number
+    ) => $Promisable<mixed>
+  ): Bluebird$Promise<Array<T>>;
+  static try<T>(
+    fn: () => $Promisable<T>,
+    args: ?Array<any>,
+    ctx: ?any
+  ): Bluebird$Promise<T>;
+  static attempt<T>(
+    fn: () => $Promisable<T>,
+    args: ?Array<any>,
+    ctx: ?any
+  ): Bluebird$Promise<T>;
+  static delay<T>(ms: number, value: $Promisable<T>): Bluebird$Promise<T>;
+  static delay(ms: number): Bluebird$Promise<void>;
+  static config(config: Bluebird$BluebirdConfig): void;
+
+  static defer(): Bluebird$Defer;
+  static setScheduler(
+    scheduler: (callback: (...args: Array<any>) => void) => void
+  ): void;
+  static promisify(
+    nodeFunction: Function,
+    receiver?: Bluebird$PromisifyOptions
+  ): Function;
+  static promisifyAll(
+    target: Object | Array<Object>,
+    options?: Bluebird$PromisifyAllOptions
+  ): void;
+
+  static coroutine(generatorFunction: Function): Function;
+  static spawn<T>(generatorFunction: Function): Promise<T>;
+
+  // It doesn't seem possible to have type-generics for a variable number of arguments.
+  // Handle up to 3 arguments, then just give up and accept 'any'.
+  static method<T, R: $Promisable<T>>(fn: () => R): () => Bluebird$Promise<T>;
+  static method<T, R: $Promisable<T>, A>(
+    fn: (a: A) => R
+  ): (a: A) => Bluebird$Promise<T>;
+  static method<T, R: $Promisable<T>, A, B>(
+    fn: (a: A, b: B) => R
+  ): (a: A, b: B) => Bluebird$Promise<T>;
+  static method<T, R: $Promisable<T>, A, B, C>(
+    fn: (a: A, b: B, c: C) => R
+  ): (a: A, b: B, c: C) => Bluebird$Promise<T>;
+  static method<T, R: $Promisable<T>>(
+    fn: (...args: any) => R
+  ): (...args: any) => Bluebird$Promise<T>;
+
+  static cast<T>(value: $Promisable<T>): Bluebird$Promise<T>;
+  // static bind(ctx: any): Bluebird$Promise<void>;
+  static is(value: any): boolean;
+  static longStackTraces(): void;
+
+  static onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
+  static fromCallback<T>(
+    resolver: (fn: (error: ?Error, value?: T) => any) => any,
+    options?: Bluebird$MultiArgsOption
+  ): Bluebird$Promise<T>;
+
+  constructor(
+    callback: (
+      resolve: (result?: $Promisable<R>) => void,
+      reject: (error?: any) => void,
+      onCancel?: (fn?: () => void) => void,
+    ) => mixed
+  ): void;
+  then(onFulfill: null | void, onReject: null | void): Bluebird$Promise<R>;
+  then<U>(
+    onFulfill: null | void,
+    onReject: (error: any) => Promise<U> | U
+  ): Bluebird$Promise<R | U>;
+  then<U>(
+    onFulfill: (value: R) => Promise<U> | U,
+    onReject: null | void | ((error: any) => Promise<U> | U)
+  ): Bluebird$Promise<U>;
+  catch(onReject: null | void): Promise<R>;
+  catch<U>(onReject?: (error: any) => $Promisable<U>): Bluebird$Promise<U>;
+  catch<U, ErrorT: Error>(
+    err: Class<ErrorT>,
+    onReject: (error: ErrorT) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  catch<U, ErrorT: Error>(
+    err1: Class<ErrorT>,
+    err2: Class<ErrorT>,
+    onReject: (error: ErrorT) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  catch<U, ErrorT: Error>(
+    err1: Class<ErrorT>,
+    err2: Class<ErrorT>,
+    err3: Class<ErrorT>,
+    onReject: (error: ErrorT) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  caught<U, ErrorT: Error>(
+    err: Class<ErrorT>,
+    onReject: (error: Error) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  caught<U, ErrorT: Error>(
+    err1: Class<ErrorT>,
+    err2: Class<ErrorT>,
+    onReject: (error: ErrorT) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  caught<U, ErrorT: Error>(
+    err1: Class<ErrorT>,
+    err2: Class<ErrorT>,
+    err3: Class<ErrorT>,
+    onReject: (error: ErrorT) => $Promisable<U>
+  ): Bluebird$Promise<U>;
+  caught<U>(onReject: (error: any) => $Promisable<U>): Bluebird$Promise<U>;
+
+  error<U>(onReject?: (error: any) => ?$Promisable<U>): Bluebird$Promise<U>;
+  done<U>(
+    onFulfill?: (value: R) => mixed,
+    onReject?: (error: any) => mixed
+  ): void;
+  finally<T>(onDone?: (value: R) => mixed): Bluebird$Promise<T>;
+  lastly<T>(onDone?: (value: R) => mixed): Bluebird$Promise<T>;
+  tap<T>(onDone?: (value: R) => mixed): Bluebird$Promise<T>;
+  delay(ms: number): Bluebird$Promise<R>;
+  timeout(ms: number, message?: string): Bluebird$Promise<R>;
+  cancel(): void;
+
+  // bind(ctx: any): Bluebird$Promise<R>;
+  call(propertyName: string, ...args: Array<any>): Bluebird$Promise<any>;
+  throw(reason: Error): Bluebird$Promise<R>;
+  thenThrow(reason: Error): Bluebird$Promise<R>;
+  all<T>(): Bluebird$Promise<Array<T>>;
+  any<T>(): Bluebird$Promise<T>;
+  some<T>(count: number): Bluebird$Promise<Array<T>>;
+  race<T>(): Bluebird$Promise<T>;
+  map<T, U>(
+    mapper: (item: T, index: number, arrayLength: number) => $Promisable<U>,
+    options?: Bluebird$ConcurrencyOption
+  ): Bluebird$Promise<Array<U>>;
+  mapSeries<T, U>(
+    mapper: (item: T, index: number, arrayLength: number) => $Promisable<U>
+  ): Bluebird$Promise<Array<U>>;
+  reduce<T, U>(
+    reducer: (
+      total: T,
+      item: U,
+      index: number,
+      arrayLength: number
+    ) => $Promisable<T>,
+    initialValue?: $Promisable<T>
+  ): Bluebird$Promise<T>;
+  filter<T>(
+    filterer: (
+      item: T,
+      index: number,
+      arrayLength: number
+    ) => $Promisable<boolean>,
+    options?: Bluebird$ConcurrencyOption
+  ): Bluebird$Promise<Array<T>>;
+  each<T, U>(
+    iterator: (item: T, index: number, arrayLength: number) => $Promisable<U>
+  ): Bluebird$Promise<Array<T>>;
+  asCallback<T>(
+    callback: (error: ?any, value?: T) => any,
+    options?: Bluebird$SpreadOption
+  ): void;
+  return<T>(value: T): Bluebird$Promise<T>;
+  thenReturn<T>(value: T): Bluebird$Promise<T>;
+  spread<T>(...args: Array<T>): Bluebird$Promise<any>;
+
+  reflect(): Bluebird$Promise<Bluebird$PromiseInspection<any>>;
+
+  isFulfilled(): boolean;
+  isRejected(): boolean;
+  isPending(): boolean;
+  isResolved(): boolean;
+
+  value(): R;
+  reason(): any;
+
+  disposer(
+    disposer: (value: R, promise: Promise<any>) => void
+  ): Bluebird$Disposable<R>;
+
+  static using<T, A>(
+    disposable: Bluebird$Disposable<T>,
+    handler: (value: T) => $Promisable<A>
+  ): Bluebird$Promise<A>;
+
+  suppressUnhandledRejections(): void;
+}
+
+declare class Bluebird$Defer {
+  promise: Bluebird$Promise<any>;
+  resolve: (value: any) => any;
+  reject: (value: any) => any;
+}
+
+declare module "bluebird" {
+  declare module.exports: typeof Bluebird$Promise;
+
+  declare type Disposable<T> = Bluebird$Disposable<T>;
+}
diff --git a/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/test_bluebird_v3.x.x.js b/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/test_bluebird_v3.x.x.js
new file mode 100644
index 0000000000..f7d2b6ced3
--- /dev/null
+++ b/definitions/npm/bluebird_v3.x.x/flow_v0.201.x-/test_bluebird_v3.x.x.js
@@ -0,0 +1,154 @@
+// @flow
+import Bluebird from 'bluebird';
+import type { Disposable } from 'bluebird';
+
+const defer: Bluebird.Defer = Bluebird.defer();
+const promise: Bluebird<any> = defer.promise;
+(promise.isFulfilled(): boolean);
+promise.reflect().then(inspection => {
+  (inspection.isCancelled(): boolean);
+  (inspection.pending(): boolean);
+});
+
+// $FlowExpectedError[incompatible-call]
+new Bluebird();
+
+const emptyPromise: Bluebird<void> = Bluebird.resolve();
+
+Bluebird.all([
+  new Bluebird(() => {}),
+]);
+Bluebird.map([1], (x: number) => new Bluebird(() => {})).all();
+Bluebird.map(Bluebird.resolve([1]), (x: number) => new Bluebird(() => {})).all();
+Bluebird.reject('test');
+Bluebird.all([
+  1
+]);
+Bluebird.all(Promise.resolve([
+  new Bluebird(() => {}),
+]));
+
+function mapper(x: number): Promise<number> {
+  return Bluebird.resolve(x);
+}
+let mapResult: Promise<number[]> = Bluebird.map([1], mapper);
+let mapSeriesResult: Promise<number[]> = Bluebird.mapSeries([1], mapper);
+
+Bluebird.resolve([1,2,3]).then(function(arr: [1,2,3]) {
+  let l = arr.length;
+  // $FlowExpectedError[prop-missing] Property not found in Array
+  arr.then(r => r);
+});
+
+let response = fetch('/').then(r => r.text())
+Bluebird.resolve(response).then(function(responseBody: string) {
+  let length: number = responseBody.length;
+  // $FlowExpectedError[prop-missing] Property not found in string
+  responseBody.then(r => r);
+});
+
+Bluebird.all([1, Bluebird.resolve(1), Promise.resolve(1)]).then(function(r: Array<number>) { });
+Bluebird.all(['hello', Bluebird.resolve('world'), Promise.resolve('!')]).then(function(r: Array<string>) { });
+Bluebird.all(['hello', Bluebird.resolve('world'), Promise.resolve('!')]).then(function(r: [string, string, string]) { });
+
+// $FlowExpectedError[incompatible-call] Wrong tuple type
+Bluebird.all(['hello', Bluebird.resolve('world'), Promise.resolve('!')]).then(function(r: [string, string, number]) { });
+Bluebird.all(['hello', Bluebird.resolve(3), Promise.resolve([1, 2, 3])]).then(function(r: [string, number, Array<number>]) { });
+
+Bluebird.join(1, Bluebird.resolve(2), function (a, b) { return a + b }).then(function (s) { return s + 1 })
+Bluebird.join(
+  1,
+  Bluebird.resolve(2),
+  Promise.resolve(3),
+  function (a, b) { return a + b }).then(function (s) { return s + 1 })
+
+Bluebird.join(1, Bluebird.resolve(2),
+  function (a, b) { return Bluebird.resolve(a + b) }).then(function (s) { return s + 1 })
+
+// $FlowExpectedError[incompatible-call]
+Bluebird.all([1, Bluebird.resolve(1), Promise.resolve(1)]).then(function(r: Array<string>) { });
+
+function foo(a: number, b: string) {
+  throw new Error('oh no');
+}
+let fooPromise = Bluebird.method(foo);
+fooPromise(1, 'b').catch(function(e) {
+  let m: string = e.message;
+});
+fooPromise(1, 'b').catch(Error, function(e: Error) {
+  let m: string = e.message;
+});
+// $FlowExpectedError[incompatible-call]
+fooPromise(1, 'b').catch(Error, function(e: TypeError) {
+  let m: string = e.message;
+});
+
+function fooPlain (a: number, b: string) {
+  return 1;
+}
+let fooPlainPromise = Bluebird.method(fooPlain);
+fooPlainPromise(1, 'a').then(function (n: number) {
+  let n2 = n;
+});
+
+function fooNative (a: number, b: string) {
+  return Promise.resolve(2);
+}
+let fooNativePromise = Bluebird.method(fooNative);
+fooNativePromise(1, 'a').then(function (n: number) {
+  let n2 = n;
+});
+
+function fooBluebird (a: number, b: string) {
+  return Bluebird.resolve(3);
+}
+let fooBluebirdPromise = Bluebird.method(fooBluebird);
+fooBluebirdPromise(1, 'a').then(function (n: number) {
+  let n2 = n;
+});
+
+// $FlowExpectedError[incompatible-call]
+fooPromise('a', 1)
+// $FlowExpectedError[incompatible-call]
+fooPromise()
+
+Bluebird.resolve(['arr', { some: 'value' }, 42])
+  .spread((someString: string, map: Object, answer: number) => answer)
+  .then(answer => answer * 2);
+
+Bluebird.reduce([5, Bluebird.resolve(6), Promise.resolve(7)], (memo, next) => memo + next);
+Bluebird.reduce([5, Bluebird.resolve(6), Promise.resolve(7)], (memo, next) => memo + next, 1);
+Bluebird.reduce([5, Bluebird.resolve(6), Promise.resolve(7)], (memo, next) => memo + next, Bluebird.resolve(1));
+Bluebird.reduce([5, Bluebird.resolve(6), Promise.resolve(7)], (memo, next) => memo + next, Promise.resolve(1));
+
+Bluebird.reduce(Promise.resolve([5, Bluebird.resolve(6), Promise.resolve(7)]), (memo, next) => memo + next);
+Bluebird.reduce(Bluebird.resolve([5, Bluebird.resolve(6), Promise.resolve(7)]), (memo, next) => memo + next, 1);
+
+Bluebird.reduce([1, Bluebird.resolve(2), Promise.resolve(3)], (prev, num) => Promise.resolve(prev * num));
+Bluebird.reduce([1, Bluebird.resolve(2), Promise.resolve(3)], (prev, num) => Bluebird.resolve(prev * num));
+
+type PromiseOutput<T> = () => Promise<T>;
+let givePromise1: PromiseOutput<number> = () => Promise.resolve(1);
+let givePromise2: PromiseOutput<number> = () => Bluebird.resolve(2);
+
+type PromiseInput<T> = (input: Promise<T>) => Function
+let takePromise: PromiseInput<number> = (promise) => promise.then
+takePromise(Promise.resolve(1));
+takePromise(Bluebird.resolve(1));
+
+Bluebird.delay(500);
+Bluebird.delay(500, 1);
+Bluebird.delay(500, Promise.resolve(5));
+Bluebird.delay(500, Bluebird.resolve(5));
+
+Bluebird.resolve().return(5).then((result: number) => {});
+Bluebird.resolve().thenReturn(5).then((result: number) => {});
+// $FlowExpectedError[incompatible-call]
+Bluebird.resolve().return(5).then((result: string) => {});
+// $FlowExpectedError[incompatible-call]
+Bluebird.resolve().thenReturn(5).then((result: string) => {});
+
+let disposable: Disposable<boolean> = Bluebird.resolve(true).disposer((value: boolean) => {});
+Bluebird.using(disposable, (value: boolean) => 9).then((result: number) => {});
+// $FlowExpectedError[incompatible-call]
+Bluebird.using(disposable, (value: number) => 9);
diff --git a/definitions/npm/chai_v3.5.x/flow_v0.104.x-/chai_v3.5.x.js b/definitions/npm/chai_v3.5.x/flow_v0.104.x-v.200.x/chai_v3.5.x.js
similarity index 100%
rename from definitions/npm/chai_v3.5.x/flow_v0.104.x-/chai_v3.5.x.js
rename to definitions/npm/chai_v3.5.x/flow_v0.104.x-v.200.x/chai_v3.5.x.js
diff --git a/definitions/npm/chai_v3.5.x/flow_v0.201.x-/chai_v3.5.x.js b/definitions/npm/chai_v3.5.x/flow_v0.201.x-/chai_v3.5.x.js
new file mode 100644
index 0000000000..bc8fa61a40
--- /dev/null
+++ b/definitions/npm/chai_v3.5.x/flow_v0.201.x-/chai_v3.5.x.js
@@ -0,0 +1,240 @@
+declare module "chai" {
+  declare type ExpectChain<T> = {
+    and: ExpectChain<T>,
+    at: ExpectChain<T>,
+    be: ExpectChain<T>,
+    been: ExpectChain<T>,
+    have: ExpectChain<T>,
+    has: ExpectChain<T>,
+    is: ExpectChain<T>,
+    of: ExpectChain<T>,
+    same: ExpectChain<T>,
+    that: ExpectChain<T>,
+    to: ExpectChain<T>,
+    which: ExpectChain<T>,
+    with: ExpectChain<T>,
+    not: ExpectChain<T>,
+    deep: ExpectChain<T>,
+    any: ExpectChain<T>,
+    all: ExpectChain<T>,
+    a: ExpectChain<T> & ((type: string) => ExpectChain<T>),
+    an: ExpectChain<T> & ((type: string) => ExpectChain<T>),
+    include: ExpectChain<T> & ((value: mixed) => ExpectChain<T>),
+    includes: ExpectChain<T> & ((value: mixed) => ExpectChain<T>),
+    contain: ExpectChain<T> & ((value: mixed) => ExpectChain<T>),
+    contains: ExpectChain<T> & ((value: mixed) => ExpectChain<T>),
+    eql: (value: T) => ExpectChain<T>,
+    equal: (value: T) => ExpectChain<T>,
+    equals: (value: T) => ExpectChain<T>,
+    above: (value: T & number) => ExpectChain<T>,
+    greaterThan: (value: T & number) => ExpectChain<T>,
+    gt: (value: T & number) => ExpectChain<T>,
+    least: (value: T & number) => ExpectChain<T>,
+    below: (value: T & number) => ExpectChain<T>,
+    lessThan: (value: T & number) => ExpectChain<T>,
+    lt: (value: T & number) => ExpectChain<T>,
+    most: (value: T & number) => ExpectChain<T>,
+    within: (start: T & number, finish: T & number) => ExpectChain<T>,
+    instanceof: (constructor: mixed) => ExpectChain<T>,
+    property: <P>(
+      name: string,
+      value?: P
+    ) => ExpectChain<P> & ((name: string) => ExpectChain<mixed>),
+    length: ExpectChain<number> & ((value: number, message?: string) => ExpectChain<T>),
+    lengthOf: (value: number) => ExpectChain<T>,
+    match: (regex: RegExp) => ExpectChain<T>,
+    matches: (regex: RegExp) => ExpectChain<T>,
+    string: (string: string) => ExpectChain<T>,
+    key: (key: string) => ExpectChain<T>,
+    keys: (
+      key: string | Array<string>,
+      ...keys: Array<string>
+    ) => ExpectChain<T>,
+    throw: <E>(
+      err?: Class<E> | Error | RegExp | string,
+      errMsgMatcher?: RegExp | string,
+      msg?: string
+    ) => ExpectChain<T>,
+    respondTo: (method: string) => ExpectChain<T>,
+    itself: ExpectChain<T>,
+    satisfy: (method: (value: T) => boolean) => ExpectChain<T>,
+    closeTo: (expected: T & number, delta: number) => ExpectChain<T>,
+    members: (set: mixed) => ExpectChain<T>,
+    oneOf: (list: Array<T>) => ExpectChain<T>,
+    change: (obj: mixed, key: string) => ExpectChain<T>,
+    increase: (obj: mixed, key: string) => ExpectChain<T>,
+    decrease: (obj: mixed, key: string) => ExpectChain<T>,
+    // dirty-chai
+    ok: () => ExpectChain<T>,
+    true: () => ExpectChain<T>,
+    false: () => ExpectChain<T>,
+    null: () => ExpectChain<T>,
+    undefined: () => ExpectChain<T>,
+    exist: () => ExpectChain<T>,
+    empty: () => ExpectChain<T>,
+    extensible: () => ExpectChain<T>,
+    sealed: () => ExpectChain<T>,
+    frozen: () => ExpectChain<T>,
+    // chai-immutable
+    size: (n: number) => ExpectChain<T>,
+    // sinon-chai
+    called: () => ExpectChain<T>,
+    callCount: (n: number) => ExpectChain<T>,
+    calledOnce: () => ExpectChain<T>,
+    calledTwice: () => ExpectChain<T>,
+    calledThrice: () => ExpectChain<T>,
+    calledBefore: (spy: mixed) => ExpectChain<T>,
+    calledAfter: (spy: mixed) => ExpectChain<T>,
+    calledWith: (...args: Array<mixed>) => ExpectChain<T>,
+    calledWithMatch: (...args: Array<mixed>) => ExpectChain<T>,
+    calledWithExactly: (...args: Array<mixed>) => ExpectChain<T>,
+    // chai-as-promised
+    eventually: ExpectChain<T>,
+    resolvedWith: (value: mixed) => Promise<mixed> & ExpectChain<T>,
+    resolved: () => Promise<mixed> & ExpectChain<T>,
+    rejectedWith: (value: mixed) => Promise<mixed> & ExpectChain<T>,
+    rejected: () => Promise<mixed> & ExpectChain<T>,
+    notify: (callback: () => mixed) => ExpectChain<T>,
+    // chai-subset
+    containSubset: (obj: {...} | Array< {...} >) => ExpectChain<T>,
+    // chai-redux-mock-store
+    dispatchedActions: (
+      actions: Array<{...} | ((action: {...}) => any)>
+    ) => ExpectChain<T>,
+    dispatchedTypes: (actions: Array<string>) => ExpectChain<T>,
+    ...
+  };
+
+  declare function expect<T>(actual: T): ExpectChain<T>;
+
+  declare function use(plugin: (chai: Object, utils: Object) => void): void;
+
+  declare class assert {
+    static (expression: mixed, message?: string): void;
+    static fail(
+      actual: mixed,
+      expected: mixed,
+      message?: string,
+      operator?: string
+    ): void;
+
+    static isOk(object: mixed, message?: string): void;
+    static isNotOk(object: mixed, message?: string): void;
+
+    static equal(actual: mixed, expected: mixed, message?: string): void;
+    static notEqual(actual: mixed, expected: mixed, message?: string): void;
+
+    static strictEqual(act: mixed, exp: mixed, msg?: string): void;
+    static notStrictEqual(act: mixed, exp: mixed, msg?: string): void;
+
+    static deepEqual(act: mixed, exp: mixed, msg?: string): void;
+    static notDeepEqual(act: mixed, exp: mixed, msg?: string): void;
+
+    static ok(val: mixed, msg?: string): void;
+    static isTrue(val: mixed, msg?: string): void;
+    static isNotTrue(val: mixed, msg?: string): void;
+    static isFalse(val: mixed, msg?: string): void;
+    static isNotFalse(val: mixed, msg?: string): void;
+
+    static isNull(val: mixed, msg?: string): void;
+    static isNotNull(val: mixed, msg?: string): void;
+
+    static isUndefined(val: mixed, msg?: string): void;
+    static isDefined(val: mixed, msg?: string): void;
+
+    static isNaN(val: mixed, msg?: string): void;
+    static isNotNaN(val: mixed, msg?: string): void;
+
+    static isAbove(val: number, abv: number, msg?: string): void;
+    static isBelow(val: number, blw: number, msg?: string): void;
+
+    static isAtMost(val: number, atmst: number, msg?: string): void;
+    static isAtLeast(val: number, atlst: number, msg?: string): void;
+
+    static isFunction(val: mixed, msg?: string): void;
+    static isNotFunction(val: mixed, msg?: string): void;
+
+    static isObject(val: mixed, msg?: string): void;
+    static isNotObject(val: mixed, msg?: string): void;
+
+    static isArray(val: mixed, msg?: string): void;
+    static isNotArray(val: mixed, msg?: string): void;
+
+    static isString(val: mixed, msg?: string): void;
+    static isNotString(val: mixed, msg?: string): void;
+
+    static isNumber(val: mixed, msg?: string): void;
+    static isNotNumber(val: mixed, msg?: string): void;
+
+    static isBoolean(val: mixed, msg?: string): void;
+    static isNotBoolean(val: mixed, msg?: string): void;
+
+    static typeOf(val: mixed, type: string, msg?: string): void;
+    static notTypeOf(val: mixed, type: string, msg?: string): void;
+
+    static instanceOf(val: mixed, constructor: Class<any>, msg?: string): void;
+    static notInstanceOf(val: mixed, constructor: Class<any>, msg?: string): void;
+
+    static include(exp: string, inc: mixed, msg?: string): void;
+    static include<T>(exp: Array<T>, inc: T, msg?: string): void;
+
+    static notInclude(exp: string, inc: mixed, msg?: string): void;
+    static notInclude<T>(exp: Array<T>, inc: T, msg?: string): void;
+
+    static match(exp: mixed, re: RegExp, msg?: string): void;
+    static notMatch(exp: mixed, re: RegExp, msg?: string): void;
+
+    static property(obj: Object, prop: string, msg?: string): void;
+    static notProperty(obj: Object, prop: string, msg?: string): void;
+    static deepProperty(obj: Object, prop: string, msg?: string): void;
+    static notDeepProperty(obj: Object, prop: string, msg?: string): void;
+
+    static propertyVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+    static propertyNotVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+
+    static deepPropertyVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+    static deepPropertyNotVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+
+    static lengthOf(exp: mixed, len: number, msg?: string): void;
+
+    static throws<E>(
+      func: () => any,
+      err?: Class<E> | Error | RegExp | string,
+      errorMsgMatcher?: string | RegExp,
+      msg?: string
+    ): void;
+    static doesNotThrow<E>(
+      func: () => any,
+      err?: Class<E> | Error | RegExp | string,
+      errorMsgMatcher?: string | RegExp,
+      msg?: string
+    ): void;
+  }
+
+  declare var config: {
+    includeStack: boolean,
+    showDiff: boolean,
+    truncateThreshold: number,
+    ...
+  };
+}
diff --git a/definitions/npm/chai_v4.x.x/flow_v0.104.x-/chai_v4.x.x.js b/definitions/npm/chai_v4.x.x/flow_v0.104.x-v.200.x/chai_v4.x.x.js
similarity index 100%
rename from definitions/npm/chai_v4.x.x/flow_v0.104.x-/chai_v4.x.x.js
rename to definitions/npm/chai_v4.x.x/flow_v0.104.x-v.200.x/chai_v4.x.x.js
diff --git a/definitions/npm/chai_v4.x.x/flow_v0.201.x-/chai_v4.x.x.js b/definitions/npm/chai_v4.x.x/flow_v0.201.x-/chai_v4.x.x.js
new file mode 100644
index 0000000000..b409a7298a
--- /dev/null
+++ b/definitions/npm/chai_v4.x.x/flow_v0.201.x-/chai_v4.x.x.js
@@ -0,0 +1,301 @@
+declare module "chai" {
+  declare type ExpectChain<T> = {
+    and: ExpectChain<T>,
+    at: ExpectChain<T>,
+    be: ExpectChain<T>,
+    been: ExpectChain<T>,
+    have: ExpectChain<T>,
+    has: ExpectChain<T>,
+    is: ExpectChain<T>,
+    of: ExpectChain<T>,
+    same: ExpectChain<T>,
+    that: ExpectChain<T>,
+    to: ExpectChain<T>,
+    which: ExpectChain<T>,
+    with: ExpectChain<T>,
+    not: ExpectChain<T>,
+    deep: ExpectChain<T>,
+    any: ExpectChain<T>,
+    all: ExpectChain<T>,
+    own: ExpectChain<T>,
+    a: ExpectChain<T> & ((type: string, message?: string) => ExpectChain<T>),
+    an: ExpectChain<T> & ((type: string, message?: string) => ExpectChain<T>),
+    include: ExpectChain<T> & ((value: mixed, message?: string) => ExpectChain<T>),
+    includes: ExpectChain<T> & ((value: mixed, message?: string) => ExpectChain<T>),
+    contain: ExpectChain<T> & ((value: mixed, message?: string) => ExpectChain<T>),
+    contains: ExpectChain<T> & ((value: mixed, message?: string) => ExpectChain<T>),
+    eq: (value: T, message?: string) => ExpectChain<T>,
+    eql: (value: T, message?: string) => ExpectChain<T>,
+    equal: (value: T, message?: string) => ExpectChain<T>,
+    equals: (value: T, message?: string) => ExpectChain<T>,
+    above: (value: T & number, message?: string) => ExpectChain<T>,
+    gt: (value: T & number, message?: string) => ExpectChain<T>,
+    greaterThan: (value: T & number, message?: string) => ExpectChain<T>,
+    least: (value: T & number, message?: string) => ExpectChain<T>,
+    below: (value: T & number, message?: string) => ExpectChain<T>,
+    lessThan: (value: T & number, message?: string) => ExpectChain<T>,
+    lt: (value: T & number, message?: string) => ExpectChain<T>,
+    most: (value: T & number, message?: string) => ExpectChain<T>,
+    within: (start: T & number, finish: T & number, message?: string) => ExpectChain<T>,
+    instanceof: (constructor: mixed, message?: string) => ExpectChain<T>,
+    instanceOf: (constructor: mixed, message?: string) => ExpectChain<T>,
+    nested: ExpectChain<T>,
+    property: <P>(
+      name: string,
+      value?: P,
+      message?: string
+    ) => ExpectChain<P> & ((name: string) => ExpectChain<mixed>),
+    length: ExpectChain<number> & ((value: number, message?: string) => ExpectChain<T>),
+    lengthOf: (value: number, message?: string) => ExpectChain<T>,
+    match: (regex: RegExp, message?: string) => ExpectChain<T>,
+    matches: (regex: RegExp, message?: string) => ExpectChain<T>,
+    string: (string: string, message?: string) => ExpectChain<T>,
+    key: (key: string) => ExpectChain<T>,
+    keys: (
+      key: string | Array<string>,
+      ...keys: Array<string>
+    ) => ExpectChain<T>,
+    throw: <E>(
+      err?: Class<E> | Error | RegExp | string,
+      errMsgMatcher?: RegExp | string,
+      msg?: string
+    ) => ExpectChain<T>,
+    respondTo: (method: string, message?: string) => ExpectChain<T>,
+    itself: ExpectChain<T>,
+    satisfy: (method: (value: T) => boolean, message?: string) => ExpectChain<T>,
+    closeTo: (expected: T & number, delta: number, message?: string) => ExpectChain<T>,
+    members: (set: mixed, message?: string) => ExpectChain<T>,
+    oneOf: (list: Array<T>, message?: string) => ExpectChain<T>,
+    change: (obj: mixed, key: string, message?: string) => ExpectChain<T>,
+    increase: (obj: mixed, key: string, message?: string) => ExpectChain<T>,
+    decrease: (obj: mixed, key: string, message?: string) => ExpectChain<T>,
+    by: (delta: number, message?: string) => ExpectChain<T>,
+    ordered: ExpectChain<T>,
+    // dirty-chai
+    ok: () => ExpectChain<T>,
+    true: () => ExpectChain<T>,
+    false: () => ExpectChain<T>,
+    null: () => ExpectChain<T>,
+    undefined: () => ExpectChain<T>,
+    exist: () => ExpectChain<T>,
+    empty: () => ExpectChain<T>,
+    extensible: () => ExpectChain<T>,
+    sealed: () => ExpectChain<T>,
+    frozen: () => ExpectChain<T>,
+    NaN: () => ExpectChain<T>,
+    // chai-immutable
+    size: (n: number) => ExpectChain<T>,
+    // sinon-chai
+    called: () => ExpectChain<T>,
+    callCount: (n: number) => ExpectChain<T>,
+    calledOnce: () => ExpectChain<T>,
+    calledTwice: () => ExpectChain<T>,
+    calledThrice: () => ExpectChain<T>,
+    calledBefore: (spy: mixed) => ExpectChain<T>,
+    calledAfter: (spy: mixed) => ExpectChain<T>,
+    calledImmediatelyBefore: (spy: mixed) => ExpectChain<T>,
+    calledImmediatelyAfter: (spy: mixed) => ExpectChain<T>,
+    calledWith: (...args: Array<mixed>) => ExpectChain<T>,
+    calledOnceWith: (...args: Array<mixed>) => ExpectChain<T>,
+    calledWithMatch: (...args: Array<mixed>) => ExpectChain<T>,
+    calledWithExactly: (...args: Array<mixed>) => ExpectChain<T>,
+    calledOnceWithExactly: (...args: Array<mixed>) => ExpectChain<T>,
+    returned: (returnVal: mixed) => ExpectChain<T>,
+    alwaysReturned: (returnVal: mixed) => ExpectChain<T>,
+    // chai-as-promised
+    eventually: ExpectChain<T>,
+    resolvedWith: (value: mixed) => Promise<mixed> & ExpectChain<T>,
+    resolved: () => Promise<mixed> & ExpectChain<T>,
+    rejectedWith: (
+      value: mixed,
+      errMsgMatcher?: RegExp | string,
+      msg?: string
+    ) => Promise<mixed> & ExpectChain<T>,
+    rejected: () => Promise<mixed> & ExpectChain<T>,
+    notify: (callback: () => mixed) => ExpectChain<T>,
+    fulfilled: () => Promise<mixed> & ExpectChain<T>,
+    // chai-subset
+    containSubset: (obj: {...} | Array< {...} >) => ExpectChain<T>,
+    // chai-redux-mock-store
+    dispatchedActions: (
+      actions: Array<{...} | ((action: {...}) => any)>
+    ) => ExpectChain<T>,
+    dispatchedTypes: (actions: Array<string>) => ExpectChain<T>,
+    // chai-enzyme
+    attr: (key: string, val?: any) => ExpectChain<T>,
+    data: (key: string, val?: any) => ExpectChain<T>,
+    prop: (key: string, val?: any) => ExpectChain<T>,
+    state: (key: string, val?: any) => ExpectChain<T>,
+    value: (val: string) => ExpectChain<T>,
+    className: (val: string) => ExpectChain<T>,
+    text: (val: string) => ExpectChain<T>,
+    // chai-karma-snapshot
+    matchSnapshot: (lang?: any, update?: boolean, msg?: any) => ExpectChain<T>,
+    ...
+  };
+
+
+  declare var expect: {
+    <T>(actual: T, message?: string): ExpectChain<T>,
+    fail: ((message?: string) => void) & ((actual: any, expected: any, message?: string, operator?: string) => void),
+    ...
+  };
+
+  declare function use(plugin: (chai: Object, utils: Object) => void): void;
+
+  declare class assert {
+    static (expression: mixed, message?: string): void;
+    static fail(
+      actual: mixed,
+      expected: mixed,
+      message?: string,
+      operator?: string
+    ): void;
+
+    static isOk(object: mixed, message?: string): void;
+    static isNotOk(object: mixed, message?: string): void;
+
+    static empty(object: mixed, message?: string): void;
+    static isEmpty(object: mixed, message?: string): void;
+    static notEmpty(object: mixed, message?: string): void;
+    static isNotEmpty(object: mixed, message?: string): void;
+
+    static equal(actual: mixed, expected: mixed, message?: string): void;
+    static notEqual(actual: mixed, expected: mixed, message?: string): void;
+
+    static strictEqual(act: mixed, exp: mixed, msg?: string): void;
+    static notStrictEqual(act: mixed, exp: mixed, msg?: string): void;
+
+    static deepEqual(act: mixed, exp: mixed, msg?: string): void;
+    static notDeepEqual(act: mixed, exp: mixed, msg?: string): void;
+
+    static ok(val: mixed, msg?: string): void;
+    static isTrue(val: mixed, msg?: string): void;
+    static isNotTrue(val: mixed, msg?: string): void;
+    static isFalse(val: mixed, msg?: string): void;
+    static isNotFalse(val: mixed, msg?: string): void;
+
+    static isNull(val: mixed, msg?: string): void;
+    static isNotNull(val: mixed, msg?: string): void;
+
+    static isUndefined(val: mixed, msg?: string): void;
+    static isDefined(val: mixed, msg?: string): void;
+
+    static isNaN(val: mixed, msg?: string): void;
+    static isNotNaN(val: mixed, msg?: string): void;
+
+    static isAbove(val: number, abv: number, msg?: string): void;
+    static isBelow(val: number, blw: number, msg?: string): void;
+
+    static exists(val : mixed, msg? : string) : void;
+    static notExists(val : mixed, msg? : string) : void;
+
+    static isAtMost(val: number, atmst: number, msg?: string): void;
+    static isAtLeast(val: number, atlst: number, msg?: string): void;
+
+    static isFunction(val: mixed, msg?: string): void;
+    static isNotFunction(val: mixed, msg?: string): void;
+
+    static isObject(val: mixed, msg?: string): void;
+    static isNotObject(val: mixed, msg?: string): void;
+
+    static isArray(val: mixed, msg?: string): void;
+    static isNotArray(val: mixed, msg?: string): void;
+
+    static isString(val: mixed, msg?: string): void;
+    static isNotString(val: mixed, msg?: string): void;
+
+    static isNumber(val: mixed, msg?: string): void;
+    static isNotNumber(val: mixed, msg?: string): void;
+
+    static isBoolean(val: mixed, msg?: string): void;
+    static isNotBoolean(val: mixed, msg?: string): void;
+
+    static typeOf(val: mixed, type: string, msg?: string): void;
+    static notTypeOf(val: mixed, type: string, msg?: string): void;
+
+    static instanceOf(val: mixed, constructor: Class<any>, msg?: string): void;
+    static notInstanceOf(val: mixed, constructor: Class<any>, msg?: string): void;
+
+    static include(exp: string, inc: mixed, msg?: string): void;
+    static include<T>(exp: Array<T>, inc: T, msg?: string): void;
+
+    static notInclude(exp: string, inc: mixed, msg?: string): void;
+    static notInclude<T>(exp: Array<T>, inc: T, msg?: string): void;
+
+    static deepInclude<T>(haystack : T[] | string, needle : $Shape<T>, msg?: string) : void;
+    static notDeepInclude<T>(haystack : T[] | string, needle : $Shape<T>, msg?: string) : void;
+
+    static match(exp: mixed, re: RegExp, msg?: string): void;
+    static notMatch(exp: mixed, re: RegExp, msg?: string): void;
+
+    static property(obj: Object, prop: string, msg?: string): void;
+    static notProperty(obj: Object, prop: string, msg?: string): void;
+    static deepProperty(obj: Object, prop: string, msg?: string): void;
+    static notDeepProperty(obj: Object, prop: string, msg?: string): void;
+
+    static propertyVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+    static propertyNotVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+
+    static deepPropertyVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+    static deepPropertyNotVal(
+      obj: Object,
+      prop: string,
+      val: mixed,
+      msg?: string
+    ): void;
+
+    static lengthOf(exp: mixed, len: number, msg?: string): void;
+
+    static throws<E>(
+      func: () => any,
+      err?: Class<E> | Error | RegExp | string,
+      errorMsgMatcher?: string | RegExp,
+      msg?: string
+    ): void;
+    static doesNotThrow<E>(
+      func: () => any,
+      err?: Class<E> | Error | RegExp | string,
+      errorMsgMatcher?: string | RegExp,
+      msg?: string
+    ): void;
+
+    static closeTo(
+      actual: number,
+      expected: number,
+      delta: number,
+      msg?: string
+    ): void;
+    static approximately(
+      actual: number,
+      expected: number,
+      delta: number,
+      msg?: string
+    ): void;
+
+    // chai-immutable
+    static sizeOf(val: mixed, length: number): void;
+  }
+
+  declare var config: {
+    includeStack: boolean,
+    showDiff: boolean,
+    truncateThreshold: number,
+    ...
+  };
+}
diff --git a/definitions/npm/classnames_v2.x.x/flow_v0.104.x-/classnames_v2.x.x.js b/definitions/npm/classnames_v2.x.x/flow_v0.104.x-v.200.x/classnames_v2.x.x.js
similarity index 100%
rename from definitions/npm/classnames_v2.x.x/flow_v0.104.x-/classnames_v2.x.x.js
rename to definitions/npm/classnames_v2.x.x/flow_v0.104.x-v.200.x/classnames_v2.x.x.js
diff --git a/definitions/npm/classnames_v2.x.x/flow_v0.201.x-/classnames_v2.x.x.js b/definitions/npm/classnames_v2.x.x/flow_v0.201.x-/classnames_v2.x.x.js
new file mode 100644
index 0000000000..4fdfd425f8
--- /dev/null
+++ b/definitions/npm/classnames_v2.x.x/flow_v0.201.x-/classnames_v2.x.x.js
@@ -0,0 +1,20 @@
+type $npm$classnames$Classes =
+  | string
+  | number
+  | { [className: string]: any, ... }
+  | boolean
+  | void
+  | null
+  | $ReadOnlyArray<$npm$classnames$Classes>;
+
+declare module "classnames" {
+  declare module.exports: (...classes: Array<$npm$classnames$Classes>) => string;
+}
+
+declare module "classnames/bind" {
+  declare module.exports: $Exports<"classnames">;
+}
+
+declare module "classnames/dedupe" {
+  declare module.exports: $Exports<"classnames">;
+}
diff --git a/definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-/clickable-box_v0.1.x.js b/definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-v.200.x/clickable-box_v0.1.x.js
similarity index 100%
rename from definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-/clickable-box_v0.1.x.js
rename to definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-v.200.x/clickable-box_v0.1.x.js
diff --git a/definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-/test_clickable-box_v0.1.x.js b/definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-v.200.x/test_clickable-box_v0.1.x.js
similarity index 100%
rename from definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-/test_clickable-box_v0.1.x.js
rename to definitions/npm/clickable-box_v0.1.x/flow_v0.104.x-v.200.x/test_clickable-box_v0.1.x.js
diff --git a/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/clickable-box_v0.1.x.js b/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/clickable-box_v0.1.x.js
new file mode 100644
index 0000000000..8fbd0e5b47
--- /dev/null
+++ b/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/clickable-box_v0.1.x.js
@@ -0,0 +1,14 @@
+declare module 'clickable-box' {
+  declare export type Props = {
+    is?: React$ElementType,
+    tabIndex?: number,
+    disabled?: boolean,
+    innerRef?: React$Ref<any>,
+    children?: React$Node,
+    onClick?: (evt: SyntheticMouseEvent<>) => void,
+    onKeyPress?: (evt: SyntheticKeyboardEvent<>) => void,
+    ...
+  };
+
+  declare export default class ClickableBox extends React$Component<Props> {}
+}
diff --git a/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/test_clickable-box_v0.1.x.js b/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/test_clickable-box_v0.1.x.js
new file mode 100644
index 0000000000..f8d50dd174
--- /dev/null
+++ b/definitions/npm/clickable-box_v0.1.x/flow_v0.201.x-/test_clickable-box_v0.1.x.js
@@ -0,0 +1,85 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+
+import React from 'react';
+import ClickableBox from 'clickable-box';
+
+const children = 'Test';
+const ref = React.createRef();
+const Component = () => <div />;
+
+describe('The `ClickableBox` component', () => {
+  it('should validate on default usage', () => {
+    <ClickableBox />;
+  });
+
+  it('should allow props forwarding', () => {
+    <ClickableBox data-testid="test" title="test" className="test" />;
+  });
+
+  describe('The `is` property', () => {
+    it('should accept a React.ElementType', () => {
+      <ClickableBox is="div" />;
+      <ClickableBox is={Component} />;
+      // $FlowExpectedError
+      <ClickableBox is={<div />} />;
+    });
+  });
+
+  describe('The `tabIndex` property', () => {
+    it('should accept numbers', () => {
+      <ClickableBox tabIndex={100} />;
+      // $FlowExpectedError
+      <ClickableBox tabIndex={false} />;
+    });
+  });
+
+  describe('The `disabled` property', () => {
+    it('should accept booleans', () => {
+      <ClickableBox disabled />;
+      // $FlowExpectedError
+      <ClickableBox disabled={0} />;
+    });
+  });
+
+  describe('The `innerRef` property', () => {
+    it('should accept a React.Ref', () => {
+      <ClickableBox innerRef="test" />;
+      <ClickableBox innerRef={ref} />;
+      <ClickableBox innerRef={node => (node: ?HTMLElement)} />;
+      // $FlowExpectedError
+      <ClickableBox innerRef={false} />;
+    });
+  });
+
+  describe('The `children` property', () => {
+    it('should accept a React.Node', () => {
+      <ClickableBox>children</ClickableBox>;
+      <ClickableBox>
+        <div />
+      </ClickableBox>;
+      <ClickableBox>
+        <Component />
+      </ClickableBox>;
+    });
+  });
+
+  describe('The `onClick` property', () => {
+    it('should accept a callback', () => {
+      <ClickableBox onClick={() => {}} />;
+      <ClickableBox onClick={(evt: SyntheticMouseEvent<>) => {}} />;
+      // $FlowExpectedError
+      <ClickableBox onClick={(evt: SyntheticInputEvent<>) => {}} />;
+    });
+  });
+
+  describe('The `onKeyPress` property', () => {
+    it('should accept a callback', () => {
+      <ClickableBox onKeyPress={() => {}} />;
+      <ClickableBox onKeyPress={(evt: SyntheticKeyboardEvent<>) => {}} />;
+      // $FlowExpectedError
+      <ClickableBox onKeyPress={(evt: SyntheticInputEvent<>) => {}} />;
+    });
+  });
+});
diff --git a/definitions/npm/clsx_v1.x.x/flow_v0.104.x-/clsx_v1.x.x.js b/definitions/npm/clsx_v1.x.x/flow_v0.104.x-v.200.x/clsx_v1.x.x.js
similarity index 100%
rename from definitions/npm/clsx_v1.x.x/flow_v0.104.x-/clsx_v1.x.x.js
rename to definitions/npm/clsx_v1.x.x/flow_v0.104.x-v.200.x/clsx_v1.x.x.js
diff --git a/definitions/npm/clsx_v1.x.x/flow_v0.201.x-/clsx_v1.x.x.js b/definitions/npm/clsx_v1.x.x/flow_v0.201.x-/clsx_v1.x.x.js
new file mode 100644
index 0000000000..f65bf625e3
--- /dev/null
+++ b/definitions/npm/clsx_v1.x.x/flow_v0.201.x-/clsx_v1.x.x.js
@@ -0,0 +1,12 @@
+declare module 'clsx' {
+  declare type Classes = 
+    | Array<Classes>
+    | { [className: string]: any, ... }
+    | string
+    | number
+    | boolean
+    | void
+    | null;
+
+  declare module.exports: (...classes: Array<Classes>) => string;
+}
diff --git a/definitions/npm/deepmerge_v1.x.x/flow_v0.104.x-/deepmerge_v1.x.x.js b/definitions/npm/deepmerge_v1.x.x/flow_v0.104.x-v.200.x/deepmerge_v1.x.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v1.x.x/flow_v0.104.x-/deepmerge_v1.x.x.js
rename to definitions/npm/deepmerge_v1.x.x/flow_v0.104.x-v.200.x/deepmerge_v1.x.x.js
diff --git a/definitions/npm/deepmerge_v1.x.x/flow_v0.201.x-/deepmerge_v1.x.x.js b/definitions/npm/deepmerge_v1.x.x/flow_v0.201.x-/deepmerge_v1.x.x.js
new file mode 100644
index 0000000000..39c33214e6
--- /dev/null
+++ b/definitions/npm/deepmerge_v1.x.x/flow_v0.201.x-/deepmerge_v1.x.x.js
@@ -0,0 +1,21 @@
+type DeepMergeOptionsType = {
+  arrayMerge?: (dest: Array<any>, source: Array<any>, options?: DeepMergeOptionsType) => Array<any>,
+  clone?: boolean,
+  ...
+};
+
+type DeepMergeObjects = {
+  (a: Object, b: Object, options?: DeepMergeOptionsType): Object,
+  all: (objects: Array<Object>, options?: DeepMergeOptionsType) => Object,
+  ...
+};
+
+type DeepMergeArrays = {
+  (a: Array<any>, b: Array<any>, options?: DeepMergeOptionsType): Array<any>,
+  all: (objects: Array<Array<any>>, options?: DeepMergeOptionsType) => Array<any>,
+  ...
+};
+
+declare module 'deepmerge' {
+  declare module.exports: DeepMergeObjects & DeepMergeArrays;
+}
diff --git a/definitions/npm/enzyme_v2.3.x/flow_v0.104.x-/enzyme_v2.3.x.js b/definitions/npm/enzyme_v2.3.x/flow_v0.104.x-v.200.x/enzyme_v2.3.x.js
similarity index 100%
rename from definitions/npm/enzyme_v2.3.x/flow_v0.104.x-/enzyme_v2.3.x.js
rename to definitions/npm/enzyme_v2.3.x/flow_v0.104.x-v.200.x/enzyme_v2.3.x.js
diff --git a/definitions/npm/enzyme_v2.3.x/flow_v0.104.x-/test_enzyme-v2.3.js b/definitions/npm/enzyme_v2.3.x/flow_v0.104.x-v.200.x/test_enzyme-v2.3.js
similarity index 100%
rename from definitions/npm/enzyme_v2.3.x/flow_v0.104.x-/test_enzyme-v2.3.js
rename to definitions/npm/enzyme_v2.3.x/flow_v0.104.x-v.200.x/test_enzyme-v2.3.js
diff --git a/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/enzyme_v2.3.x.js b/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/enzyme_v2.3.x.js
new file mode 100644
index 0000000000..b3a316a24e
--- /dev/null
+++ b/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/enzyme_v2.3.x.js
@@ -0,0 +1,108 @@
+import * as React from "react";
+
+declare module "enzyme" {
+  declare type PredicateFunction<T: Wrapper> = (
+    wrapper: T,
+    index: number
+  ) => boolean;
+  declare type NodeOrNodes = React.Node | Array<React.Node>;
+  declare type EnzymeSelector = string | Class<React.Component<any, any>> | {...};
+
+  // CheerioWrapper is a type alias for an actual cheerio instance
+  // TODO: Reference correct type from cheerio's type declarations
+  declare type CheerioWrapper = any;
+
+  declare class Wrapper {
+    find(selector: EnzymeSelector): this,
+    findWhere(predicate: PredicateFunction<this>): this,
+    filter(selector: EnzymeSelector): this,
+    filterWhere(predicate: PredicateFunction<this>): this,
+    contains(nodeOrNodes: NodeOrNodes): boolean,
+    containsMatchingElement(node: React.Node): boolean,
+    containsAllMatchingElements(nodes: NodeOrNodes): boolean,
+    containsAnyMatchingElements(nodes: NodeOrNodes): boolean,
+    dive(option?: { context?: Object, ... }): this,
+    exists(): boolean,
+    matchesElement(node: React.Node): boolean,
+    hasClass(className: string): boolean,
+    is(selector: EnzymeSelector): boolean,
+    isEmpty(): boolean,
+    not(selector: EnzymeSelector): this,
+    children(selector?: EnzymeSelector): this,
+    childAt(index: number): this,
+    parents(selector?: EnzymeSelector): this,
+    parent(): this,
+    closest(selector: EnzymeSelector): this,
+    render(): CheerioWrapper,
+    unmount(): this,
+    text(): string,
+    html(): string,
+    get(index: number): React.Node,
+    getNode(): React.Node,
+    getNodes(): Array<React.Node>,
+    getDOMNode(): HTMLElement | HTMLInputElement,
+    at(index: number): this,
+    first(): this,
+    last(): this,
+    state(key?: string): any,
+    context(key?: string): any,
+    props(): Object,
+    prop(key: string): any,
+    key(): string,
+    simulate(event: string, ...args: Array<any>): this,
+    setState(state: {...}, callback?: Function): this,
+    setProps(props: {...}): this,
+    setContext(context: Object): this,
+    instance(): React.Component<any, any>,
+    update(): this,
+    debug(options?: Object): string,
+    type(): string | Function | null,
+    name(): string,
+    forEach(fn: (node: this, index: number) => mixed): this,
+    map<T>(fn: (node: this, index: number) => T): Array<T>,
+    reduce<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    reduceRight<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    some(selector: EnzymeSelector): boolean,
+    someWhere(predicate: PredicateFunction<this>): boolean,
+    every(selector: EnzymeSelector): boolean,
+    everyWhere(predicate: PredicateFunction<this>): boolean,
+    length: number
+  }
+
+  declare export class ReactWrapper extends Wrapper {
+    constructor(nodes: NodeOrNodes, root: any, options?: ?Object): ReactWrapper,
+    mount(): this,
+    ref(refName: string): this,
+    detach(): void
+  }
+
+  declare export class ShallowWrapper extends Wrapper {
+    constructor(nodes: NodeOrNodes, root: any, options?: ?Object): ShallowWrapper;
+    equals(node: React.Node): boolean,
+    shallow(options?: { context?: Object, ... }): ShallowWrapper
+  }
+
+  declare export function shallow(
+    node: React.Node,
+    options?: { context?: Object, ... }
+  ): ShallowWrapper;
+  declare export function mount(
+    node: React.Node,
+    options?: {
+      context?: Object,
+      attachTo?: HTMLElement,
+      childContextTypes?: Object,
+      ...
+    }
+  ): ReactWrapper;
+  declare export function render(
+    node: React.Node,
+    options?: { context?: Object, ... }
+  ): CheerioWrapper;
+}
diff --git a/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/test_enzyme-v2.3.js b/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/test_enzyme-v2.3.js
new file mode 100644
index 0000000000..ba07233ab5
--- /dev/null
+++ b/definitions/npm/enzyme_v2.3.x/flow_v0.201.x-/test_enzyme-v2.3.js
@@ -0,0 +1,56 @@
+// @flow
+import * as React from "react";
+import { shallow, mount, render, ShallowWrapper, ReactWrapper } from "enzyme";
+
+const shallowWrapper = shallow(<div />);
+(render(<div />, { context: { foo: true } }).text(): string);
+const A: boolean = render(<div />, { context: { foo: true } })
+  .find("foo")
+  .is("bla");
+const B: boolean = render(<div />, { context: { foo: true } })
+  .update()
+  .filter("bla")
+  .equals(<div />);
+
+// Test against chaining returning `any`
+// $FlowExpectedError
+(shallow(<div />).children(): boolean);
+
+(shallow(<div />).children(): ShallowWrapper);
+
+// Test PredicateFunction
+shallow(<div />).findWhere((x: ShallowWrapper) => true);
+
+// Test selector functionality
+
+declare class ClassComponent extends React.Component<any, any> {}
+
+const StatelessComponent = () => <div />;
+
+shallow(<div />).find(ClassComponent);
+shallow(<div />).find(StatelessComponent);
+shallow(<div />).find({ a: 1 });
+// $FlowExpectedError
+shallow(<div />).find(true);
+
+shallowWrapper.instance();
+shallowWrapper.find("someSelector");
+shallowWrapper.prop("foo");
+shallowWrapper.props().foo;
+
+(mount(<div />).map(node => true): Array<boolean>);
+
+(mount(<div />).reduce((acc: number, node, i) => i + 1): Array<number>);
+// $FlowExpectedError
+(mount(<div />).reduce((acc: number, node, i) => i + 1): Array<boolean>);
+(mount(<div />).reduce((acc, node, i) => i + 1, 0): Array<number>);
+// $FlowExpectedError
+(mount(<div />).reduce((acc, node, i) => i + 1, 0): Array<boolean>);
+
+// Cheerio
+render(<div />).contents();
+
+// not in API docs but in example docs
+// http://airbnb.io/enzyme/docs/api/
+// https://github.com/airbnb/enzyme/blob/master/docs/api/shallow.md#shallow-rendering-api
+(shallow(<div />).length: number);
diff --git a/definitions/npm/enzyme_v3.x.x/flow_v0.104.x-/enzyme_v3.x.x.js b/definitions/npm/enzyme_v3.x.x/flow_v0.104.x-v.200.x/enzyme_v3.x.x.js
similarity index 100%
rename from definitions/npm/enzyme_v3.x.x/flow_v0.104.x-/enzyme_v3.x.x.js
rename to definitions/npm/enzyme_v3.x.x/flow_v0.104.x-v.200.x/enzyme_v3.x.x.js
diff --git a/definitions/npm/enzyme_v3.x.x/flow_v0.104.x-/test_enzyme-v3.x.js b/definitions/npm/enzyme_v3.x.x/flow_v0.104.x-v.200.x/test_enzyme-v3.x.js
similarity index 100%
rename from definitions/npm/enzyme_v3.x.x/flow_v0.104.x-/test_enzyme-v3.x.js
rename to definitions/npm/enzyme_v3.x.x/flow_v0.104.x-v.200.x/test_enzyme-v3.x.js
diff --git a/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/enzyme_v3.x.x.js b/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/enzyme_v3.x.x.js
new file mode 100644
index 0000000000..38bd6e0235
--- /dev/null
+++ b/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/enzyme_v3.x.x.js
@@ -0,0 +1,141 @@
+declare module "enzyme" {
+  declare type PredicateFunction<T: Wrapper<any>> = (
+    wrapper: T,
+    index: number
+  ) => boolean;
+  declare type UntypedSelector = string | { [key: string]: number|string|boolean, ... };
+  declare type EnzymeSelector = UntypedSelector | React$ElementType;
+
+  // CheerioWrapper is a type alias for an actual cheerio instance
+  // TODO: Reference correct type from cheerio's type declarations
+  declare type CheerioWrapper = any;
+
+  declare class Wrapper<RootComponent> {
+    at(index: number): this,
+    childAt(index: number): this,
+    children(selector?: UntypedSelector): this,
+    children<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    closest(selector: UntypedSelector): this,
+    closest<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    contains(nodes: React$Element<any> | $ReadOnlyArray<React$Element<any>>): boolean,
+    containsAllMatchingElements(nodes: $ReadOnlyArray<React$Element<any>>): boolean,
+    containsAnyMatchingElements(nodes: $ReadOnlyArray<React$Element<any>>): boolean,
+    containsMatchingElement(node: React$Element<any>): boolean,
+    context(key?: string): any,
+    debug(options?: Object): string,
+    dive(option?: { context?: Object, ... }): this,
+    equals(node: React$Element<any>): boolean,
+    every(selector: EnzymeSelector): boolean,
+    everyWhere(predicate: PredicateFunction<this>): boolean,
+    exists(selector?: EnzymeSelector): boolean,
+    filter(selector: UntypedSelector): this,
+    filter<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    filterWhere(predicate: PredicateFunction<this>): this,
+    find(selector: UntypedSelector): this,
+    find<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    findWhere(predicate: PredicateFunction<this>): this,
+    first(): this,
+    forEach(fn: (node: this, index: number) => mixed): this,
+    get<T = any>(index: number): React$Element<T>,
+    getDOMNode(): HTMLElement | HTMLInputElement,
+    hasClass(className: string): boolean,
+    hostNodes(): this,
+    html(): string,
+    instance(): React$ElementRef<RootComponent>,
+    invoke(propName: string): (...args: $ReadOnlyArray<any>) => mixed,
+    is(selector: EnzymeSelector): boolean,
+    isEmpty(): boolean,
+    isEmptyRender(): boolean,
+    key(): string,
+    last(): this,
+    length: number,
+    map<T>(fn: (node: this, index: number) => T): Array<T>,
+    matchesElement(node: React$Element<any>): boolean,
+    name(): string,
+    not(selector: EnzymeSelector): this,
+    parent(): this,
+    parents(selector?: UntypedSelector): this,
+    parents<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    prop(key: string): any,
+    props(): Object,
+    reduce<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    reduceRight<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    render(): CheerioWrapper,
+    renderProp(propName: string): (...args: Array<any>) => this,
+    setContext(context: Object): this,
+    setProps(props: {...}, callback?: () => void): this,
+    setState(state: {...}, callback?: () => void): this,
+    simulate(event: string, ...args: Array<any>): this,
+    simulateError(error: Error): this,
+    slice(begin?: number, end?: number): this,
+    some(selector: EnzymeSelector): boolean,
+    someWhere(predicate: PredicateFunction<this>): boolean,
+    state(key?: string): any,
+    text(): string,
+    type(): string | Function | null,
+    unmount(): this,
+    update(): this,
+  }
+
+  declare class ReactWrapper<T> extends Wrapper<T> {
+    constructor(nodes: React$Element<T>, root: any, options?: ?Object): ReactWrapper<T>,
+    mount(): this,
+    ref(refName: string): this,
+    detach(): void
+  }
+
+  declare class ShallowWrapper<T> extends Wrapper<T> {
+    constructor(
+      nodes: React$Element<T>,
+      root: any,
+      options?: ?Object
+    ): ShallowWrapper<T>,
+    shallow(options?: { context?: Object, ... }): ShallowWrapper<T>,
+    getElement<T = any>(): React$Element<T>,
+    getElements<T = any>(): Array<React$Element<T>>
+  }
+
+  declare function shallow<T>(
+    node: React$Element<T>,
+    options?: {
+      context?: Object,
+      disableLifecycleMethods?: boolean,
+      ...
+    }
+  ): ShallowWrapper<T>;
+
+  declare function mount<T>(
+    node: React$Element<T>,
+    options?: {
+      context?: Object,
+      attachTo?: HTMLElement,
+      childContextTypes?: Object,
+      ...
+    }
+  ): ReactWrapper<T>;
+
+  declare function render(
+    node: React$Node,
+    options?: { context?: Object, ... }
+  ): CheerioWrapper;
+
+  declare module.exports: {
+    configure(options: {
+      Adapter?: any,
+      disableLifecycleMethods?: boolean,
+      ...
+    }): void,
+    render: typeof render,
+    mount: typeof mount,
+    shallow: typeof shallow,
+    ShallowWrapper: typeof ShallowWrapper,
+    ReactWrapper: typeof ReactWrapper,
+    ...
+  };
+}
diff --git a/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/test_enzyme-v3.x.js b/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/test_enzyme-v3.x.js
new file mode 100644
index 0000000000..fcb3b2e042
--- /dev/null
+++ b/definitions/npm/enzyme_v3.x.x/flow_v0.201.x-/test_enzyme-v3.x.js
@@ -0,0 +1,298 @@
+// @flow
+import * as React from "react";
+import {
+  configure,
+  shallow,
+  mount,
+  render,
+  type ShallowWrapper,
+  type ReactWrapper
+} from "enzyme";
+import { describe, it } from 'flow-typed-test';
+
+configure({
+  disableLifecycleMethods: true
+});
+
+describe('render', () => {
+  (render(<div/>, {context: {foo: true}}).text(): string);
+  const A: boolean = render(<div/>, {context: {foo: true}})
+    .find("foo")
+    .is("bla");
+  const B: boolean = render(<div/>, {context: {foo: true}})
+    .update()
+    .filter("bla")
+    .equals(<div/>);
+
+  function opaqueNode(): React$Node {
+    return <span>who knows what I am</span>;
+  }
+  render(opaqueNode());
+
+  // Cheerio
+  render(<div />).contents();
+});
+
+// Tests for functions present in both shallow() and mount()
+describe('Wrapper', () => {
+  class DeepInstance extends React.Component<{ onChange: () => void, ... }> {}
+
+  it('children', () => {
+    // Test against chaining returning `any`
+    // $FlowExpectedError wrong return type
+    (shallow(<div/>).children(): boolean);
+    (shallow(<div/>).children(): ShallowWrapper<'div'>);
+
+    mount(<div><DeepInstance onChange={() => {}}/></div>).children(DeepInstance).instance().props.onChange();
+    // $FlowExpectedError
+    mount(<div><DeepInstance onChange={() => {}}/></div>).children(DeepInstance).instance().props.onChangeX();
+  });
+
+  it('closest', () => {
+    mount(<div><DeepInstance onChange={() => {}}/></div>).closest(DeepInstance).instance().props.onChange();
+    // $FlowExpectedError
+    mount(<div><DeepInstance onChange={() => {}}/></div>).closest(DeepInstance).instance().props.onChangeX();
+  });
+
+  it('contains', () => {
+    (mount(<div/>).contains(<div/>): boolean);
+    (mount(<div/>).contains([<div/>, <div/>]): boolean);
+  });
+
+  it('containsAllMatchingElements', () => {
+    (mount(<div />).containsAllMatchingElements([<div />, <div />]): boolean);
+    // $FlowExpectedError - "nodes should be an Array" (from docs and source code)
+    (mount(<div />).containsAllMatchingElements(<div />));
+  });
+
+  it('containsAnyMatchingElements', () => {
+    (mount(<div />).containsAnyMatchingElements([<div />, <div />]): boolean);
+    // $FlowExpectedError - "nodes should be an Array" (from docs and source code)
+    (mount(<div />).containsAnyMatchingElements(<div />));
+  });
+
+  it('containsMatchingElement', () => {
+    (mount(<div />).containsMatchingElement(<div />): boolean);
+  });
+
+  it('equals', () => {
+    (shallow(<div/>).equals(<div/>): boolean);
+
+    // example from docs
+    const MyComponent = () => <div className="foo bar" />;
+    (shallow(<MyComponent />).equals(<div className="foo bar" />): boolean);
+  });
+
+  it('filter', () => {
+    mount(<div><DeepInstance onChange={() => {}}/></div>).filter(DeepInstance).instance().props.onChange();
+    // $FlowExpectedError
+    mount(<div><DeepInstance onChange={() => {}}/></div>).filter(DeepInstance).instance().props.onChangeX();
+  });
+
+  it('find', () => {
+    // Test selector functionality
+    declare class ClassComponent extends React.Component<any, any> {}
+    const StatelessComponent = () => <div />;
+
+    shallow(<div />).find(ClassComponent);
+    shallow(<div />).find(StatelessComponent);
+    shallow(<div />).find({ a: 1 });
+    // $FlowExpectedError
+    shallow(<div />).find(true);
+    shallow(<div/>).find("someSelector");
+    shallow(<div/>).renderProp("render")(1, "hi").find("SomeSelector");
+
+    // Need to invoke the returned renderProp fn
+    // Can't properly be tested
+    // shallowWrapper
+    //   .renderProp("render")
+    //   .find(123)
+
+    mount(<div><DeepInstance onChange={() => {}}/></div>).find(DeepInstance).instance().props.onChange();
+    // $FlowExpectedError
+    mount(<div><DeepInstance onChange={() => {}}/></div>).find(DeepInstance).instance().props.onChangeX();
+  });
+
+  it('findWhere', () => {
+    // Test PredicateFunction
+    shallow(<div/>).findWhere((x: ShallowWrapper<'div'>) => true);
+  });
+
+  it('get', () => {
+    // example from docs
+    const Foo = () => <div>some text</div>;
+    const MyComponent = () => <Foo foo="bar"/>;
+    (shallow(<MyComponent />).find(Foo).get(0).props.foo: string);
+  });
+
+  it('instance', () => {
+    class TestInstance extends React.Component<any> {
+      method = () => 'test';
+    }
+
+    shallow(<div/>).instance();
+
+    // $FlowExpectedError
+    (shallow(<TestInstance />).instance().method: string);
+    shallow(<TestInstance />).instance().method();
+    (shallow(<TestInstance />).instance().method: () => 'test');
+
+    // $FlowExpectedError
+    (mount(<TestInstance />).instance().method: string);
+    mount(<TestInstance />).instance().method();
+    (mount(<TestInstance />).instance().method: () => 'test');
+  });
+
+  describe('invoke', () => {
+    describe('invoke event handler prop on shallowWrapper', () => {
+      it('test', () => {
+        // This is common use case for triggering event handler for user action
+        const shallowWrapper = shallow(<div onClick={() => {}} />);
+        shallowWrapper.invoke('onClick')();
+      });
+    });
+
+    describe('invoke regular function prop on shallowWrapper', () => {
+      // Less common use case, allowable by enzyime for prop to simply be a function
+
+      it('user uses type refinement', () => {
+        const shallowWrapper = shallow(<div getName={() => {return 'test';}} />);
+        const name = shallowWrapper.invoke('getName')();
+
+        if (typeof name === 'string') {
+          name.substring(0);
+        }
+      });
+
+      it('user does not refine type', () => {
+        const shallowWrapper = shallow(<div getNumber={() => {return 'not a number';}} />);
+        const string = shallowWrapper.invoke('getNumber')();
+
+        // $FlowExpectedError
+        name.toFixed();
+      });
+    });
+  });
+
+  it('length', () => {
+    // not in API docs but in example docs
+    // http://airbnb.io/enzyme/docs/api/
+    // https://github.com/airbnb/enzyme/blob/master/docs/api/shallow.md#shallow-rendering-api
+    (shallow(<div />).length: number);
+  });
+
+  it('map', () => {
+    (mount(<div />).map(node => true): Array<boolean>);
+  });
+
+  it('matchesElement', () => {
+    (mount(<div />).matchesElement(<div />): boolean);
+  });
+
+  it('parents', () => {
+    mount(<div><DeepInstance onChange={() => {}}/></div>).parents(DeepInstance).instance().props.onChange();
+    // $FlowExpectedError
+    mount(<div><DeepInstance onChange={() => {}}/></div>).parents(DeepInstance).instance().props.onChangeX();
+  });
+
+  it('prop', () => {
+    shallow(<div/>).prop("foo");
+  });
+
+  it('props', () => {
+    shallow(<div/>).props().foo;
+  });
+
+  it('reduce', () => {
+    (mount(<div />).reduce((acc: number, node, i) => i + 1): Array<number>);
+    // $FlowExpectedError
+    (mount(<div />).reduce((acc: number, node, i) => i + 1): Array<boolean>);
+    (mount(<div />).reduce((acc, node, i) => i + 1, 0): Array<number>);
+    // $FlowExpectedError
+    (mount(<div />).reduce((acc, node, i) => i + 1, 0): Array<boolean>);
+  });
+
+  it('renderProp', () => {
+    (mount(<div />).renderProp("render")(1, "hi"): ReactWrapper<'div'>);
+  });
+
+  it('slice', () => {
+    shallow(<div/>).slice();
+    shallow(<div/>).slice(0);
+    shallow(<div/>).slice(0, 1);
+  });
+
+  it('simulateError', () => {
+    (mount(<div />).simulateError(new Error('error')): ReactWrapper<'div'>);
+    // $FlowExpectedError
+    (mount(<div />).simulateError('error'): ReactWrapper<'div'>);
+    (shallow(<div />).simulateError(new Error('error')): ShallowWrapper<'div'>);
+    // $FlowExpectedError
+    (shallow(<div />).simulateError('error'): ShallowWrapper<'div'>);
+  });
+
+  it('setProps', () => {
+    (mount(<div />).setProps({}, () => {}): ReactWrapper<'div'>);
+    // $FlowExpectedError
+    (mount(<div />).setProps({}, null): ReactWrapper<'div'>);
+    (mount(<div />).setProps({}): ReactWrapper<'div'>);
+    // $FlowExpectedError
+    (mount(<div />).setProps(): ReactWrapper<'div'>);
+    // $FlowExpectedError
+    (mount(<div />).setProps(null): ReactWrapper<'div'>);
+  });
+});
+
+describe('ShallowWrapper', () => {
+  it('getElement', () => {
+    (shallow(<div/>).getElement(): React$Element<React.ComponentType<{||}>>);
+
+    // example from docs
+    const element = (
+      <div>
+        <span />
+        <span />
+      </div>
+    );
+    function MyComponent() {
+      return element;
+    }
+    (shallow(<MyComponent />).getElement(): typeof element);
+  });
+
+  it('getElements', () => {
+    (shallow(<div/>).getElements(): React$Element<React.ComponentType<{||}>>[]);
+
+    // example from docs
+    const one = <span />;
+    const two = <span />;
+    function Test() {
+      return (
+        <div>
+          {one}
+          {two}
+        </div>
+      );
+    }
+    (shallow(<Test />).find('span').getElements(): Array<typeof one>);
+  });
+
+  it('deprecated methods should not be present', () => {
+    // shallow's getNode(s) was replaced by getElement(s) in enzyme v3
+    // $FlowExpectedError
+    shallow(<div/>).getNode();
+    // $FlowExpectedError
+    shallow(<div/>).getNodes();
+  });
+});
+
+
+describe('mount', () => {
+  it('deprecated methods should not be present', () => {
+    // mount's getNode(s) were removed in enzyme v3
+    // $FlowExpectedError
+    mount(<div />).getNode();
+    // $FlowExpectedError
+    mount(<div />).getNodes();
+  });
+});
diff --git a/definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-/fast-memoize_v2.x.x.js b/definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-v.200.x/fast-memoize_v2.x.x.js
similarity index 100%
rename from definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-/fast-memoize_v2.x.x.js
rename to definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-v.200.x/fast-memoize_v2.x.x.js
diff --git a/definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-/test_fast-memoize.js b/definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-v.200.x/test_fast-memoize.js
similarity index 100%
rename from definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-/test_fast-memoize.js
rename to definitions/npm/fast-memoize_v2.x.x/flow_v0.104.x-v.200.x/test_fast-memoize.js
diff --git a/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/fast-memoize_v2.x.x.js b/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/fast-memoize_v2.x.x.js
new file mode 100644
index 0000000000..c47525e2b2
--- /dev/null
+++ b/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/fast-memoize_v2.x.x.js
@@ -0,0 +1,18 @@
+declare module 'fast-memoize' {
+  declare type Cache<K, V> = {
+    get: (key: K) => V,
+    set: (key: K, value: V) => void,
+    has: (key: K) =>  boolean,
+    ...
+  }
+
+  declare type Options = {
+    cache?: Cache<any, any>,
+    serializer?: (...args: any[]) => any,
+    strategy?: <T>(fn: T, options?: Options) => T,
+    ...
+  }
+
+
+  declare module.exports: <T>(fn: T, options?: Options) => T;
+}
diff --git a/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/test_fast-memoize.js b/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/test_fast-memoize.js
new file mode 100644
index 0000000000..9678d4fda4
--- /dev/null
+++ b/definitions/npm/fast-memoize_v2.x.x/flow_v0.201.x-/test_fast-memoize.js
@@ -0,0 +1,25 @@
+import { describe, it } from 'flow-typed-test';
+import memoize, { type Cache } from 'fast-memoize';
+
+describe('fast-memoize', () => {
+
+  it('should memoize', () => {
+    const fn: string => string = _ => _.trim();
+    const memoizedFn1: string => string = memoize(fn)
+    // $FlowExpectedError
+    const memoizedFn2: number => number = memoize(fn)
+  })
+
+  it('should memoize with external cache', () => {
+    const cache: Cache<string, string> = {
+      get: (key: string) => key,
+      set: (key: string, value: string) => {},
+      has: (key: string) => true
+    };
+    const fn: string => string = _ => _.trim();
+    const memoizedFn1: string => string = memoize(
+      fn,
+      { cache, serializer: () => '' }
+    );
+  })
+})
diff --git a/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-/fetch-ponyfill_v3.x.x.js b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-v.200.x/fetch-ponyfill_v3.x.x.js
similarity index 100%
rename from definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-/fetch-ponyfill_v3.x.x.js
rename to definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-v.200.x/fetch-ponyfill_v3.x.x.js
diff --git a/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-/test_fetch-ponyfill_v3.x.x.js b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-v.200.x/test_fetch-ponyfill_v3.x.x.js
similarity index 100%
rename from definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-/test_fetch-ponyfill_v3.x.x.js
rename to definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.104.x-v.200.x/test_fetch-ponyfill_v3.x.x.js
diff --git a/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/fetch-ponyfill_v3.x.x.js b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/fetch-ponyfill_v3.x.x.js
new file mode 100644
index 0000000000..a6ed2682ab
--- /dev/null
+++ b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/fetch-ponyfill_v3.x.x.js
@@ -0,0 +1,20 @@
+declare module 'fetch-ponyfill' {
+
+  declare type InitOptions = {
+    Promise?: $Subtype<Class<Promise<any>>>,
+    XMLHttpRequest?: $Subtype<Class<XMLHttpRequest>>,
+    ...
+  };
+
+  // The below types are globals defined by Flow itself in bom.js, so we just have to tell it that the fetch export
+  // of this module is equivalent to window.fetch
+  declare type PonyfillExports = {
+    fetch: (input: string | Request, init?: RequestOptions) => Promise<Response>,
+    Request: Request,
+    Response: Response,
+    Headers: Headers,
+    ...
+  };
+
+  declare export default function PonyfillConstructor(options?: InitOptions): PonyfillExports;
+}
diff --git a/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/test_fetch-ponyfill_v3.x.x.js b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/test_fetch-ponyfill_v3.x.x.js
new file mode 100644
index 0000000000..f8acbc21cf
--- /dev/null
+++ b/definitions/npm/fetch-ponyfill_v3.x.x/flow_v0.201.x-/test_fetch-ponyfill_v3.x.x.js
@@ -0,0 +1,39 @@
+import _fetch from 'fetch-ponyfill';
+
+const url = 'https://www.github.com';
+//$FlowExpectedError
+_fetch(url)
+
+import FetchConstructor from 'fetch-ponyfill';
+const {fetch, Request: _Request, Response: _Response, Headers: _Headers} = FetchConstructor();
+(_Request: Request);
+(_Response: Response);
+(_Headers: Headers);
+
+fetch(url);
+
+fetch(url, {
+  headers: {
+    foo: 'bar'
+  },
+  mode: 'cors',
+  method: 'PATCH',
+  cache: 'default',
+})
+.then(function(res: Response) {
+  //$FlowExpectedError
+  res.xml();
+  res.arrayBuffer();
+  res.blob();
+  res.formData();
+  res.text();
+  return res.json();
+})
+.then(function(json: string) {
+  return json.split(',');
+})
+
+
+const _fetch1 = FetchConstructor({Promise, XMLHttpRequest}).fetch;
+//$FlowExpectedError
+const _fetch1 = FetchConstructor({Promise: () => null}).fetch;
diff --git a/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-/fixed-data-table-2_v0.7.x.js b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-v.200.x/fixed-data-table-2_v0.7.x.js
similarity index 100%
rename from definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-/fixed-data-table-2_v0.7.x.js
rename to definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-v.200.x/fixed-data-table-2_v0.7.x.js
diff --git a/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-/test_fixed-data-table-2_v0.7.x.js b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-v.200.x/test_fixed-data-table-2_v0.7.x.js
similarity index 100%
rename from definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-/test_fixed-data-table-2_v0.7.x.js
rename to definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.104.x-v.200.x/test_fixed-data-table-2_v0.7.x.js
diff --git a/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/fixed-data-table-2_v0.7.x.js b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/fixed-data-table-2_v0.7.x.js
new file mode 100644
index 0000000000..680612922a
--- /dev/null
+++ b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/fixed-data-table-2_v0.7.x.js
@@ -0,0 +1,136 @@
+declare module "fixed-data-table-2" {
+  declare type ColumnKey = ?string | number;
+  declare type Align = "left" | "center" | "right";
+  declare type BasicCellProps = {
+    columnKey: ColumnKey,
+    height: number,
+    width: number,
+    ...
+  };
+
+  declare export class Cell extends React$Component<{
+    isScrolling?: ?boolean,
+    align?: ?Align,
+    className?: ?string,
+    highlighted?: ?boolean,
+    width?: ?number,
+    minWidth?: ?number,
+    maxWidth?: ?number,
+    height?: ?number,
+    cell?:
+      | ?string
+      | React$Element<any>
+      | ((props: BasicCellProps & { rowIndex?: ?number, ... }) => React$Element<any>),
+    columnKey?: ?ColumnKey,
+    rowIndex?: ?number,
+    onColumnResize?: ?(
+      left: ?number,
+      width: number,
+      minWidth: ?number,
+      maxWidth: ?number,
+      columnKey: ColumnKey,
+      event: SyntheticEvent<any>
+    ) => void,
+    onColumnReorder?: ?(
+      columnKey: ColumnKey,
+      width: number,
+      left: ?number,
+      event: SyntheticEvent<any>
+    ) => void,
+    left?: ?number,
+    pureRendering?: ?boolean,
+    ...
+  }> {}
+
+  declare export class Column extends React$Component<{
+    align?: ?Align,
+    fixed?: ?boolean,
+    header?:
+      | ?string
+      | React$Element<any>
+      | ((props: BasicCellProps) => React$Element<any>),
+    cell?:
+      | ?string
+      | React$Element<any>
+      | ((props: BasicCellProps & { rowIndex: number, ... }) => React$Element<any>),
+    footer?:
+      | ?string
+      | React$Element<any>
+      | ((props: BasicCellProps) => React$Element<any>),
+    columnKey?: ColumnKey,
+    width: number,
+    minWidth?: ?number,
+    maxWidth?: ?number,
+    flexGrow?: ?number,
+    isResizable?: ?boolean,
+    isReorderable?: ?boolean,
+    allowCellsRecycling?: ?boolean,
+    pureRendering?: boolean,
+    ...
+  }> {}
+
+  declare export class ColumnGroup extends React$Component<{
+    align?: ?Align,
+    fixed?: ?boolean,
+    header?: ?string | React$Element<any>,
+    ...
+  }> {}
+
+  declare export class Table extends React$Component<{
+    width: number,
+    height?: ?number,
+    className?: ?string,
+    maxHeight?: ?number,
+    ownerHeight?: ?number,
+    overflowX?: "auto" | "hidden",
+    overflowY?: "auto" | "hidden",
+    touchScrollEnabled?: ?boolean,
+    showScrollbarX?: ?boolean,
+    showScrollbarY?: ?boolean,
+    onHorizontalScroll?: ?(position: number) => boolean,
+    onVerticalScroll?: ?(position: number) => boolean,
+    rowsCount: number,
+    rowHeight: number,
+    rowHeightGetter?: ?(index: number) => number,
+    rowClassNameGetter?: ?(index: number) => ?string,
+    rowKeyGetter?: ?(index: number) => string,
+    groupHeaderHeight?: ?number,
+    headerHeight: number,
+    footerHeight?: ?number,
+    scrollLeft?: ?number,
+    scrollToColumn?: ?number,
+    scrollTop?: ?number,
+    scrollToRow?: ?number,
+    onScrollStart?: ?(
+      scrollX: number,
+      scrollY: number,
+      firstRowIndex: number
+    ) => void,
+    onScrollEnd?: ?(
+      scrollX: number,
+      scrollY: number,
+      firstRowIndex: number
+    ) => void,
+    stopScrollPropagation?: ?boolean,
+    onContentHeightChange?: ?(contentHeight: number) => void,
+    onRowClick?: ?(event: SyntheticEvent<any>, index: number) => void,
+    onRowDoubleClick?: ?(event: SyntheticEvent<any>, index: number) => void,
+    onRowMouseDown?: ?(event: SyntheticEvent<any>, index: number) => void,
+    onRowMouseEnter?: ?(event: SyntheticEvent<any>, index: number) => void,
+    onRowMouseLeave?: ?(event: SyntheticEvent<any>, index: number) => void,
+    onColumnResizeEndCallback?: ?(
+      newColumnWidth: number,
+      columnKey: ColumnKey
+    ) => void,
+    onColumnReorderEndCallback?: ?(event: {
+      columnBefore: ?string,
+      columnAfter: ?string,
+      reorderColumn: string,
+      ...
+    }) => void,
+    isColumnResizing?: ?boolean,
+    isColumnReordering?: ?boolean,
+    bufferRowCount?: ?number,
+    ...
+  }> {}
+}
diff --git a/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/test_fixed-data-table-2_v0.7.x.js b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/test_fixed-data-table-2_v0.7.x.js
new file mode 100644
index 0000000000..29d9713a9d
--- /dev/null
+++ b/definitions/npm/fixed-data-table-2_v0.7.x/flow_v0.201.x-/test_fixed-data-table-2_v0.7.x.js
@@ -0,0 +1,25 @@
+/* @flow */
+import React from 'react';
+import {Cell, Column, ColumnGroup, Table} from 'fixed-data-table-2';
+
+let cell = <Cell/>;
+cell = <Cell onColumnResize={(left, width, minWidth, maxWidth, columnKey, event) => {event.target;}}/>;
+// $FlowExpectedError
+cell = <Cell onColumnResize={(left, width, minWidth, maxWidth, columnKey, event) => minWidth + maxWidth}/>;
+
+// $FlowExpectedError
+let column = <Column/>;
+column = <Column width={300} minWidth={null}/>;
+
+let columnGroup = <ColumnGroup/>;
+// $FlowExpectedError
+columnGroup = <ColumnGroup align='top'/>;
+
+// $FlowExpectedError
+let table = <Table/>;
+table = <Table
+  width={900}
+  rowsCount={10}
+  rowHeight={50}
+  headerHeight={60}
+/>;
diff --git a/definitions/npm/fluture_v6.x.x/flow_v0.104.x-/fluture_v6.x.x.js b/definitions/npm/fluture_v6.x.x/flow_v0.104.x-v.200.x/fluture_v6.x.x.js
similarity index 100%
rename from definitions/npm/fluture_v6.x.x/flow_v0.104.x-/fluture_v6.x.x.js
rename to definitions/npm/fluture_v6.x.x/flow_v0.104.x-v.200.x/fluture_v6.x.x.js
diff --git a/definitions/npm/fluture_v6.x.x/flow_v0.104.x-/test_fluture_v6.x.x.js b/definitions/npm/fluture_v6.x.x/flow_v0.104.x-v.200.x/test_fluture_v6.x.x.js
similarity index 100%
rename from definitions/npm/fluture_v6.x.x/flow_v0.104.x-/test_fluture_v6.x.x.js
rename to definitions/npm/fluture_v6.x.x/flow_v0.104.x-v.200.x/test_fluture_v6.x.x.js
diff --git a/definitions/npm/fluture_v6.x.x/flow_v0.201.x-/fluture_v6.x.x.js b/definitions/npm/fluture_v6.x.x/flow_v0.201.x-/fluture_v6.x.x.js
new file mode 100644
index 0000000000..2353a4141c
--- /dev/null
+++ b/definitions/npm/fluture_v6.x.x/flow_v0.201.x-/fluture_v6.x.x.js
@@ -0,0 +1,104 @@
+/**
+ * (Incomplete) Type definitions for Fluture
+ */
+
+// helpers
+type $npm$Fluture$Fn1<A, B> = (a: A) => B // a unary function
+
+declare module fluture {
+  declare type Computation<Rej, Res> = (
+    rej: $npm$Fluture$Fn1<Rej, void>,
+    res: $npm$Fluture$Fn1<Res, void>,
+  ) => void
+
+  declare type NodeBack<Rej, Res> = (rej: Rej, res: Res) => void
+
+  // Rej = type of returned rejected value
+  // Res = type of returned resolved value
+  declare class Fluture<Rej, Res> {
+    map: <T>(fn: $npm$Fluture$Fn1<Res, T>) => Fluture<Rej, T>;
+    bimap: <A, B>(
+      left: $npm$Fluture$Fn1<Rej, A>,
+      right: $npm$Fluture$Fn1<Res, B>,
+    ) => Fluture<A, B>;
+    chain: <A, B>(fn: (a: Res) => Fluture<A, B>) => Fluture<A, B>;
+    swap: () => Fluture<Res, Rej>;
+    mapRej: <T>(fn: $npm$Fluture$Fn1<Rej, T>) => Fluture<T, Res>;
+    chainRej: <T>(fn: (a: Rej) => Fluture<T, Res>) => Fluture<T, Res>;
+    // We can't type fold with 2 different types of left and right
+    fold: <T>(
+      left: $npm$Fluture$Fn1<Rej, T>,
+      right: $npm$Fluture$Fn1<Res, T>,
+    ) => Fluture<void, T>;
+    // We can't infer the type of applied Res(B)
+    ap: <A, B>(a: Fluture<A, B>) => Fluture<A, any>;
+    // We can't infer the first reject or resolve
+    and: <A, B>(a: Fluture<A, B>) => Fluture<A, B>;
+    // We can't infer the last reject or resolve
+    or: <A, B>(a: Fluture<A, B>) => Fluture<A, B>;
+
+    finally: (a: Fluture<any, any>) => Fluture<Rej, Res>;
+    lastly: (a: Fluture<any, any>) => Fluture<Rej, Res>;
+
+    fork: (
+      rej: $npm$Fluture$Fn1<Rej, any>,
+      res: $npm$Fluture$Fn1<Res, any>,
+    ) => : () => any;
+    value: (res: $npm$Fluture$Fn1<Res, any>) => : () => any;
+    promise: () => Promise<Res>;
+
+    // We can't infer the first reject or resolve
+    race: <A, B>(a: Fluture<A, B>) => Fluture<A, B>;
+  }
+
+  declare module.exports: {
+    <Rej, Res>(fn: Computation<Rej, Res>): Fluture<Rej, Res>,
+    of: <T>(a: T) => Fluture<any, T>,
+    reject: <T>(a: T) => Fluture<T, any>,
+    after: <T>(a: number, b: T) => Fluture<void, T>,
+    rejectAfter: <T>(a: number, b: T) => Fluture<T, void>,
+    cache: <Rej, Res>(a: Fluture<Rej, Res>) => Fluture<Rej, Res>,
+    do: <T>(() => T) => Fluture<void, T>,
+    go: <T>(() => T) => Fluture<void, T>,
+    try: <T>(() => T) => Fluture<void, T>,
+    tryP: <T>(() => Promise<T>) => Fluture<void, T>,
+    node: <Rej, Res>((done: NodeBack<Rej, Res>) => void) => Fluture<Rej, Res>,
+    encase: <A, B>(fn: (a: A) => B) => (a: A) => Fluture<any, B>,
+    encase2: <A1, A2, B>(
+      fn: (a1: A1, a2: A2) => B,
+    ) => (a1: A1, a2: A2) => Fluture<any, B>,
+    encase3: <A1, A2, A3, B>(
+      fn: (a1: A1, a2: A2, a3: A3) => B,
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<any, B>,
+    encaseP: <A, B>(fn: (a: A) => Promise<B>) => (a: A) => Fluture<any, B>,
+    encaseP2: <A1, A2, B>(
+      fn: (a1: A1, a2: A2) => Promise<B>,
+    ) => (a1: A1, a2: A2) => Fluture<any, B>,
+    encaseP3: <A1, A2, A3, B>(
+      fn: (a1: A1, a2: A2, a3: A3) => Promise<B>,
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<any, B>,
+    encaseN: <A, Rej, Res>(
+      fn: (a: A, done: NodeBack<Rej, Res>) => void,
+    ) => (a: A) => Fluture<Rej, Res>,
+    encaseN2: <A1, A2, Rej, Res>(
+      fn: (a1: A1, a2: A2, done: NodeBack<Rej, Res>) => void,
+    ) => (a1: A1, a2: A2) => Fluture<Rej, Res>,
+    encaseN3: <A1, A2, A3, Rej, Res>(
+      fn: (a1: A1, a2: A2, a3: A3, done: NodeBack<Rej, Res>) => void,
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<Rej, Res>,
+    hook: <A, B, C, D>(
+      f1: Fluture<A, B>,
+      f2: (b: B) => Fluture<A, C>,
+    ) => (f3: (c: B) => Fluture<A, D>) => Fluture<A, D>,
+    both: <A, B>(a: Fluture<A, B>, Fluture<A, B>) => Fluture<A, B>,
+    // We can't infer the combined types of all futures
+    parallel: (a: number, b: Array<Fluture<any, any>>) => Fluture<any, any>,
+    // No idea how to type this
+    Par: any,
+    seq: any,
+    isFuture: (a: any) => boolean,
+    isNever: (a: any) => boolean,
+    never: () => Fluture<void, void>,
+    ...
+  }
+}
diff --git a/definitions/npm/fluture_v8.x.x/flow_v0.104.x-/test_fluture_v8.x.x.js b/definitions/npm/fluture_v6.x.x/flow_v0.201.x-/test_fluture_v6.x.x.js
similarity index 100%
rename from definitions/npm/fluture_v8.x.x/flow_v0.104.x-/test_fluture_v8.x.x.js
rename to definitions/npm/fluture_v6.x.x/flow_v0.201.x-/test_fluture_v6.x.x.js
diff --git a/definitions/npm/fluture_v8.x.x/flow_v0.104.x-/fluture_v8.x.x.js b/definitions/npm/fluture_v8.x.x/flow_v0.104.x-v.200.x/fluture_v8.x.x.js
similarity index 100%
rename from definitions/npm/fluture_v8.x.x/flow_v0.104.x-/fluture_v8.x.x.js
rename to definitions/npm/fluture_v8.x.x/flow_v0.104.x-v.200.x/fluture_v8.x.x.js
diff --git a/definitions/npm/fluture_v8.x.x/flow_v0.104.x-v.200.x/test_fluture_v8.x.x.js b/definitions/npm/fluture_v8.x.x/flow_v0.104.x-v.200.x/test_fluture_v8.x.x.js
new file mode 100644
index 0000000000..b32ba4c8b6
--- /dev/null
+++ b/definitions/npm/fluture_v8.x.x/flow_v0.104.x-v.200.x/test_fluture_v8.x.x.js
@@ -0,0 +1,34 @@
+// @flow
+import Future from 'fluture'
+
+const noop = () => {}
+
+// No error
+Future.of(1)
+  .map(x => x + 1)
+  .chain(Future.of)
+  .fork(noop, noop) 
+
+// $FlowExpectedError when calling unavailable function
+Future.unavailableFunction(123)
+
+// $FlowExpectedError when map over wrong type with Future.of
+Future.of(1).map(x => x.length)
+
+// $FlowExpectedError when map over wrong type with Future()
+Future((rej, res) => res(1)).map(x => x.length)
+
+// $FlowExpectedError when mapRef over wrong type
+Future.reject(1).map(x => x).mapRej(x => x.length)
+
+// No error as rejected type is passed down the chain
+Future.of(1)
+  .mapRej(() => 'string')
+  .map(x => x)
+  .fork(x => x.length, noop)
+
+// $FlowExpectedError when map over wrong type with Future.node
+Future.node(done => done(1, 'string')).map(x => x.length).mapRej(x => x.length)
+
+// $FlowExpectedError when folding back
+Future.reject('123').fold(x => 123, x => '123').map(x => x.length)
diff --git a/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/fluture_v8.x.x.js b/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/fluture_v8.x.x.js
new file mode 100644
index 0000000000..3b8511e9cd
--- /dev/null
+++ b/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/fluture_v8.x.x.js
@@ -0,0 +1,98 @@
+// helpers
+type $npm$Fluture$Fn1<A, B> = (a: A) => B // a unary function
+
+declare module fluture {
+  declare type Computation<Rej, Res> = (
+    rej: $npm$Fluture$Fn1<Rej, void>,
+    res: $npm$Fluture$Fn1<Res, void>
+  ) => void
+
+  declare type NodeBack<Rej, Res> = (rej: Rej, res: Res) => void
+
+  // Rej = type of returned rejected value
+  // Res = type of returned resolved value
+  declare export class Fluture<Rej, Res> {
+    map: <T>(fn: $npm$Fluture$Fn1<Res, T>) => Fluture<Rej, T>,
+    bimap: <A, B>(left: $npm$Fluture$Fn1<Rej, A>, right: $npm$Fluture$Fn1<Res, B>) => Fluture<A, B>,
+    chain: <A, B>(fn: (a: Res) => Fluture<A, B>) => Fluture<A, B>,
+    swap: () => Fluture<Res, Rej>,
+    mapRej: <T>(fn: $npm$Fluture$Fn1<Rej, T>) => Fluture<T, Res>,
+    chainRej: <A, B>(fn: (a: Rej) => Fluture<A, B>) => Fluture<A, B>,
+    // We can't type fold with 2 different types of left and right
+    fold: <T>(left: $npm$Fluture$Fn1<Rej, T>, right: $npm$Fluture$Fn1<Res, T>) => Fluture<void, T>,
+    // We can't infer the type of applied Res(B)
+    ap: <A, B>(a: Fluture<A, B>) => Fluture<A, any>,
+    // We can't infer the first reject or resolve
+    and: <A, B>(a: Fluture<A, B>) => Fluture<A, B>,
+    // We can't infer the last reject or resolve
+    or: <A, B>(a: Fluture<A, B>) => Fluture<A, B>,
+
+    finally: (a: Fluture<any, any>) => Fluture<Rej, Res>,
+    lastly: (a: Fluture<any, any>) => Fluture<Rej, Res>,
+
+    fork: (rej: $npm$Fluture$Fn1<Rej, any>, res: $npm$Fluture$Fn1<Res, any>) => : () => any,
+    value: (res: $npm$Fluture$Fn1<Res, any>) => : () => any,
+    promise: () => Promise<Res>,
+
+    // We can't infer the first reject or resolve
+    race: <A, B>(a: Fluture<A, B>) => Fluture<A, B>
+  }
+
+  declare class Future {
+    of: <L, R>(a: R) => Fluture<L, R>,
+    reject: <L, R>(a: L) => Fluture<L, R>,
+    after: <T>(a: number, b: T) => Fluture<void, T>,
+    rejectAfter: <T>(a: number, b: T) => Fluture<T, void>,
+    cache: <Rej, Res>(a: Fluture<Rej, Res>) => Fluture<Rej, Res>,
+    do: <T>(() => T) => Fluture<void, T>,
+    go: <T>(() => T) => Fluture<void, T>,
+    try: <T>(() => T) => Fluture<void, T>,
+    tryP: <T>(() => Promise<T>) => Fluture<void, T>,
+    node: <Rej, Res>((done: NodeBack<Rej, Res>) => void) => Fluture<Rej, Res>,
+
+    encase: <A, B>(fn: (a: A) => B) => (a: A) => Fluture<any, B>,
+    encase2: <A1, A2, B>(
+      fn: (a1: A1, a2: A2) => B
+    ) => (a1: A1, a2: A2) => Fluture<any, B>,
+    encase3: <A1, A2, A3, B>(
+      fn: (a1: A1, a2: A2, a3: A3) => B
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<any, B>,
+    encaseP: <A, B>(fn: (a: A) => Promise<B>) => (a: A) => Fluture<any, B>,
+    encaseP2: <A1, A2, B>(
+      fn: (a1: A1, a2: A2) => Promise<B>
+    ) => (a1: A1, a2: A2) => Fluture<any, B>,
+    encaseP3: <A1, A2, A3, B>(
+      fn: (a1: A1, a2: A2, a3: A3) => Promise<B>
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<any, B>,
+    encaseN: <A, Rej, Res>(
+      fn: (a: A, done: NodeBack<Rej, Res>) => void
+    ) => (a: A) => Fluture<Rej, Res>,
+    encaseN2: <A1, A2, Rej, Res>(
+      fn: (a1: A1, a2: A2, done: NodeBack<Rej, Res>) => void
+    ) => (a1: A1, a2: A2) => Fluture<Rej, Res>,
+    encaseN3: <A1, A2, A3, Rej, Res>(
+      fn: (a1: A1, a2: A2, a3: A3, done: NodeBack<Rej, Res>) => void
+    ) => (a1: A1, a2: A2, a3: A3) => Fluture<Rej, Res>,
+
+    hook: <A, B, C, D>(
+      f1: Fluture<A, B>,
+      f2: (b: B) => Fluture<A, C>
+    ) => (f3: (c: B) => Fluture<A, D>) => Fluture<A, D>,
+
+    both: <A, B>(a: Fluture<A, B>, Fluture<A, B>) => Fluture<A, B>,
+    // We can't infer the combined types of all futures
+    parallel: (a: number, b: Array<Fluture<any, any>>) => Fluture<any, any>,
+
+    // No idea how to type this
+    Par: any,
+    seq: any,
+
+    isFuture: (a: any) => boolean,
+    isNever: (a: any) => boolean,
+    never: () => Fluture<void, void>,
+
+    <Rej, Res>(fn: Computation<Rej, Res>): Fluture<Rej, Res>
+  }
+
+  declare export default Future
+}
diff --git a/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/test_fluture_v8.x.x.js b/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/test_fluture_v8.x.x.js
new file mode 100644
index 0000000000..b32ba4c8b6
--- /dev/null
+++ b/definitions/npm/fluture_v8.x.x/flow_v0.201.x-/test_fluture_v8.x.x.js
@@ -0,0 +1,34 @@
+// @flow
+import Future from 'fluture'
+
+const noop = () => {}
+
+// No error
+Future.of(1)
+  .map(x => x + 1)
+  .chain(Future.of)
+  .fork(noop, noop) 
+
+// $FlowExpectedError when calling unavailable function
+Future.unavailableFunction(123)
+
+// $FlowExpectedError when map over wrong type with Future.of
+Future.of(1).map(x => x.length)
+
+// $FlowExpectedError when map over wrong type with Future()
+Future((rej, res) => res(1)).map(x => x.length)
+
+// $FlowExpectedError when mapRef over wrong type
+Future.reject(1).map(x => x).mapRej(x => x.length)
+
+// No error as rejected type is passed down the chain
+Future.of(1)
+  .mapRej(() => 'string')
+  .map(x => x)
+  .fork(x => x.length, noop)
+
+// $FlowExpectedError when map over wrong type with Future.node
+Future.node(done => done(1, 'string')).map(x => x.length).mapRej(x => x.length)
+
+// $FlowExpectedError when folding back
+Future.reject('123').fold(x => 123, x => '123').map(x => x.length)
diff --git a/definitions/npm/flyd_v0.x.x/flow_v0.104.x-/flyd_v0.x.x.js b/definitions/npm/flyd_v0.x.x/flow_v0.104.x-v.200.x/flyd_v0.x.x.js
similarity index 100%
rename from definitions/npm/flyd_v0.x.x/flow_v0.104.x-/flyd_v0.x.x.js
rename to definitions/npm/flyd_v0.x.x/flow_v0.104.x-v.200.x/flyd_v0.x.x.js
diff --git a/definitions/npm/flyd_v0.x.x/flow_v0.104.x-/test_flyd_v0.x.x.js b/definitions/npm/flyd_v0.x.x/flow_v0.104.x-v.200.x/test_flyd_v0.x.x.js
similarity index 100%
rename from definitions/npm/flyd_v0.x.x/flow_v0.104.x-/test_flyd_v0.x.x.js
rename to definitions/npm/flyd_v0.x.x/flow_v0.104.x-v.200.x/test_flyd_v0.x.x.js
diff --git a/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/flyd_v0.x.x.js b/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/flyd_v0.x.x.js
new file mode 100644
index 0000000000..0ff4f91c58
--- /dev/null
+++ b/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/flyd_v0.x.x.js
@@ -0,0 +1,143 @@
+declare class flyd$Stream<+T> {
+  static val: T;
+
+  end(boolean): flyd$Stream<boolean>;
+  map<T, V>((T) => V): flyd$Stream<V>;
+  ap<V>(flyd$Stream<V>): flyd$Stream<V>;
+  of<V>(...values: V[]): flyd$Stream<V>;
+
+  (...rest: Array<void>): T;
+  (any): flyd$Stream<any>;
+}
+type Stream = flyd$Stream<any>;
+type CombineFn = (...args: Array<Stream>) => any;
+type MapFn = any => any;
+type ScanFn = (any, any) => any;
+type LiftFn = (...args: Array<any>) => any;
+
+type RegularObj = { [key: string]: any | RegularObj, ... };
+type StreamObj = { [key: string]: Stream | StreamObj, ... };
+
+declare module 'flyd' {
+  declare type Stream = Stream;
+  declare type Flyd$Stream<T> = flyd$Stream<T>;
+
+  declare module.exports: {
+    stream<T>(v: T): flyd$Stream<T>,
+    immediate<T>(s: flyd$Stream<?T>): flyd$Stream<?T>,
+    isStream(s: any): boolean,
+    combine: CurriedFunction2<CombineFn, Array<flyd$Stream<any>>, Stream>,
+    endsOn: CurriedFunction2<Stream, Stream, Stream>,
+    map: CurriedFunction2<MapFn, Stream, Stream>,
+    on: CurriedFunction2<MapFn, Stream, Stream>,
+    scan: CurriedFunction3<ScanFn, any, Stream, Stream>,
+    merge: CurriedFunction2<Stream, Stream, Stream>,
+    transduce: CurriedFunction2<MapFn | Function, Stream, Stream>,
+    curryN(length: number, fn: (...args: Array<any>) => any): Function,
+    ...
+  };
+}
+
+declare module 'flyd/module/aftersilence' {
+  declare module.exports: CurriedFunction2<number, Stream, Stream>;
+}
+
+declare module 'flyd/module/diff' {
+  declare module.exports: CurriedFunction2<ScanFn, Stream, Stream>;
+}
+
+declare module 'flyd/module/droprepeats' {
+  declare module.exports: {
+    dropRepeats: (s: Stream) => Stream,
+    dropRepeatsWith: CurriedFunction2<(any) => boolean, Stream, Stream>,
+    ...
+  };
+}
+
+declare module 'flyd/module/every' {
+  declare module.exports: (number) => Stream;
+}
+
+declare module 'flyd/module/filter' {
+  declare module.exports: CurriedFunction2<(any) => boolean, Stream, Stream>;
+}
+
+declare module 'flyd/module/flatmap' {
+  declare module.exports: CurriedFunction2<MapFn, Stream, Stream>;
+}
+
+declare module 'flyd/module/forwardto' {
+  declare module.exports: CurriedFunction2<Stream, : any => any, Stream>;
+}
+
+declare module 'flyd/module/inlast' {
+  declare module.exports: CurriedFunction2<number, Stream, Stream>;
+}
+
+declare module 'flyd/module/keepwhen' {
+  declare module.exports: CurriedFunction2<Stream, Stream, Stream>;
+}
+
+declare module 'flyd/module/lift' {
+  declare module.exports: (LiftFn, ...args: Array<Stream>) => Stream;
+}
+
+declare module 'flyd/module/mergeall' {
+  declare module.exports: (Array<Stream>) => Stream;
+}
+
+declare module 'flyd/module/obj' {
+  declare module.exports: {
+    streamProps(obj: RegularObj): StreamObj,
+    extractProps(obj: StreamObj): RegularObj,
+    stream(obj: StreamObj): Stream,
+    ...
+  };
+}
+
+declare module 'flyd/module/previous' {
+  declare module.exports: (Stream) => Stream;
+}
+
+declare module 'flyd/module/sampleon' {
+  declare module.exports: CurriedFunction2<Stream, Stream, Stream>;
+}
+
+declare module 'flyd/module/scanmerge' {
+  declare module.exports: CurriedFunction2<Array<[Stream, ScanFn]>, any, Stream>;
+}
+
+declare module 'flyd/module/switchlatest' {
+  declare module.exports: (Stream) => Stream;
+}
+
+declare module 'flyd/module/takeuntil' {
+  declare module.exports: CurriedFunction2<Stream, Stream, Stream>;
+}
+
+// Filename aliases
+declare module 'flyd/flyd' {
+  declare module.exports: $Exports<'flyd'>;
+}
+declare module 'flyd/flyd.js' {
+  declare module.exports: $Exports<'flyd'>;
+}
+declare module 'flyd/lib' {
+  declare module.exports: $Exports<'flyd'>;
+}
+declare module 'flyd/lib/index' {
+  declare module.exports: $Exports<'flyd/lib'>;
+}
+declare module 'flyd/lib/index.js' {
+  declare module.exports: $Exports<'flyd/lib'>;
+}
+
+// copy from ramda because importing won't work...
+type CurriedFunction2<T1, T2, R> =
+  & ((t1: T1, t2: T2) => R)
+  & ((t1: T1, ...rest: Array<void>) => (t2: T2) => R);
+
+declare type CurriedFunction3<T1, T2, T3, R> =
+  & ((t1: T1, t2: T2, t3: T3) => R)
+  & ((t1: T1, t2: T2, ...rest: Array<void>) => (t3: T3) => R)
+  & ((t1: T1, ...rest: Array<void>) => CurriedFunction2<T2, T3, R>)
diff --git a/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/test_flyd_v0.x.x.js b/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/test_flyd_v0.x.x.js
new file mode 100644
index 0000000000..652cb9fb1d
--- /dev/null
+++ b/definitions/npm/flyd_v0.x.x/flow_v0.201.x-/test_flyd_v0.x.x.js
@@ -0,0 +1,91 @@
+// @flow
+import flyd from 'flyd';
+
+const one$ = flyd.stream();
+let one = one$(); // undefined
+one$(1);
+one = one$(); // 1
+
+one$.end(true);
+// $FlowExpectedError
+one$.end(1);
+
+const two$ = flyd.stream(2);
+// $FlowExpectedError
+const err$ = two$.map(2);
+
+const three$ = two$.map(val => val + 1);
+
+// isStream
+const isTrue = flyd.isStream(three$);
+const isFalse = flyd.isStream(2);
+
+// combine
+const n1 = flyd.stream(0);
+const n2 = flyd.stream(0);
+const max = flyd.combine(
+  (n1, n2, self, changed) => {
+    return n1() > n2() ? n1() : n2();
+  },
+  [n1, n2]
+);
+// $FlowExpectedError
+const min = flyd.combine(() => 0, [0, 0]);
+
+// immediate
+const s = flyd.stream();
+const hasItems = flyd.immediate(
+  flyd.combine(
+    s => {
+      return s() !== undefined && s().length > 0;
+    },
+    [s]
+  )
+);
+console.log(hasItems()); // logs `false`. Had `immediate` not been
+// used `hasItems()` would've returned `undefined`
+s([1]);
+console.log(hasItems()); // logs `true`.
+s([]);
+console.log(hasItems()); // logs `false`.
+
+// endsOn
+const n = flyd.stream(1);
+const killer = flyd.stream();
+// `double` ends when `n` ends or when `killer` emits any value
+const double = flyd.endsOn(
+  flyd.merge(n.end, killer),
+  flyd.combine(
+    n => {
+      return 2 * n();
+    },
+    [n]
+  )
+);
+
+// map
+const numbers$ = flyd.stream(0);
+const squaredNumbers$ = flyd.map(n => {
+  return n * n;
+}, numbers$);
+// $FlowExpectedError
+const noNumbers$ = flyd.map(1, numbers$);
+
+// on
+flyd.on(n => {
+  console.log('numbers changed to', n);
+}, numbers$);
+
+// scan
+const acc$ = flyd.scan(
+  (sum, n) => {
+    return sum + n;
+  },
+  0,
+  numbers$
+);
+numbers$(2)(3)(5);
+acc$();
+
+// $FlowExpectedError
+const scanErr = flyd.scan(null, numbers$, 3);
diff --git a/definitions/npm/formik_v0.9.x/flow_v0.104.x-/formik_v0.9.x.js b/definitions/npm/formik_v0.9.x/flow_v0.104.x-v.200.x/formik_v0.9.x.js
similarity index 100%
rename from definitions/npm/formik_v0.9.x/flow_v0.104.x-/formik_v0.9.x.js
rename to definitions/npm/formik_v0.9.x/flow_v0.104.x-v.200.x/formik_v0.9.x.js
diff --git a/definitions/npm/formik_v0.9.x/flow_v0.201.x-/formik_v0.9.x.js b/definitions/npm/formik_v0.9.x/flow_v0.201.x-/formik_v0.9.x.js
new file mode 100644
index 0000000000..a1c7824ede
--- /dev/null
+++ b/definitions/npm/formik_v0.9.x/flow_v0.201.x-/formik_v0.9.x.js
@@ -0,0 +1,228 @@
+declare module "formik" {
+  declare export type FormikErrors = { [field: string]: string, ... };
+
+  declare export type FormikTouched = { [field: string]: boolean, ... };
+
+  declare export type FormikActions<Values> = {
+   /** Manually set top level status. */
+   setStatus: (status?: any) => void,
+   /**
+    * Manually set top level error
+    * @deprecated since 0.8.0
+    */
+   setError: (e: any) => void,
+   /** Manually set errors object */
+   setErrors: (errors: FormikErrors) => void,
+   /** Manually set isSubmitting */
+   setSubmitting: (isSubmitting: boolean) => void,
+   /** Manually set touched object */
+   setTouched: (touched: FormikTouched) => void,
+   /** Manually set values object  */
+   setValues: (values: Values) => void,
+   /** Set value of form field directly */
+   setFieldValue: (field: $Keys<Values>, value: any) => void,
+   /** Set error message of a form field directly */
+   setFieldError: (field: $Keys<Values>, message: string) => void,
+   /** Set whether field has been touched directly */
+   setFieldTouched: (field: $Keys<Values>, isTouched?: boolean) => void,
+   /** Reset form */
+   resetForm: (nextValues?: any) => void,
+   /** Submit the form imperatively */
+   submitForm: () => void,
+   ...
+  };
+
+  declare export type FormikSharedConfig = {
+   /** Tells Formik to validate the form on each input's onChange event */
+   validateOnChange?: boolean,
+   /** Tells Formik to validate the form on each input's onBlur event */
+   validateOnBlur?: boolean,
+   /** Tell Formik if initial form values are valid or not on first render */
+   isInitialValid?: boolean | ((props: {...}) => boolean | void),
+   /** Should Formik reset the form when new initialValues change */
+   enableReinitialize?: boolean,
+   ...
+  };
+
+  declare export type FormikConfig = FormikSharedConfig & {
+   /**
+    * Initial values of the form
+    */
+   initialValues?: {...},
+   /**
+    * Submission handler
+    */
+   onSubmit: (values: Object, formikActions: FormikActions<any>) => any,
+   /**
+    * Form component to render
+    */
+   component?: React$ComponentType<FormikProps<any> | void>,
+   /**
+    * Render prop (works like React router's <Route render={props =>} />)
+    */
+   render?: (props: FormikProps<any>) => React$Node,
+   /**
+    * A Yup Schema or a function that returns a Yup schema
+    */
+   validationSchema?: any | (() => any),
+   /**
+    * Validation function. Must return an error object or promise that
+    * throws an error object where that object keys map to corresponding value.
+    */
+   validate?: (values: any) => void | Object | Promise<any>,
+   /**
+    * React children or child render callback
+    */
+   children?: ((props: FormikProps<any>) => React$Node) | React$Node,
+   ...
+  };
+
+  /**
+   * Formik state tree
+   */
+  declare export type FormikState<Values> = {
+   /** Form values */
+   values: Values,
+   /**
+    * Top level error, in case you need it
+    * @deprecated since 0.8.0
+    */
+   error?: any,
+   /** map of field names to specific error for that field */
+   errors: FormikErrors,
+   /** map of field names to whether the field has been touched */
+   touched: FormikTouched,
+   /** whether the form is currently submitting */
+   isSubmitting: boolean,
+   /** Top level status state, in case you need it */
+   status?: any,
+   ...
+  };
+
+  /**
+   * Formik computed properties. These are read-only.
+   */
+  declare export type FormikComputedProps<Values> = {
+   /** True if any input has been touched. False otherwise. */
+   -dirty: boolean,
+   /** Result of isInitiallyValid on mount, then whether true values pass validation. */
+   -isValid: boolean,
+   /** initialValues */
+   -initialValues: Values,
+   ...
+  };
+
+  /**
+   * Formik form event handlers
+   */
+  declare export type FormikHandlers = {
+   /** Form submit handler */
+   // TODO: React.FormEvent<HTMLFormElement>
+   handleSubmit: (e: Function) => any,
+   /** Classic React change handler, keyed by input name */
+   // TODO: React.ChangeEvent<any>
+   handleChange: (e: Function) => any,
+   /** Mark input as touched */
+   handleBlur: (e: any) => any,
+   /** Change value of form field directly */
+   handleChangeValue: (name: string, value: any) => any,
+   /** Reset form event handler  */
+   handleReset: () => any,
+   ...
+  };
+
+  declare export type FormikProps<Values> = FormikState<Values> &
+    FormikActions<Values> &
+    FormikHandlers &
+    FormikComputedProps<Values>;
+
+  declare export class Formik<
+    Props: FormikConfig = FormikConfig
+  > extends React$Component<Props> {}
+
+  /**
+   * Note: These typings could be more restrictive, but then it would limit the
+   * reusability of custom <Field/> components.
+   *
+   * @example
+   * type MyProps = {
+   *   ...FieldProps,
+   *   ...
+   * }
+   *
+   * export const MyInput = ({
+   *   field,
+   *   form,
+   *   ...props
+   * }: MyProps) =>
+   *   <div>
+   *     <input {...field} {...props}/>
+   *     {form.touched[field.name] && form.errors[field.name]}
+   *   </div>
+   */
+  declare export type FieldProps = {
+   field: {
+    /** Classic React change handler, keyed by input name */
+    // TODO: React.ChangeEvent<any>
+    onChange: (e: any) => any,
+    /** Mark input as touched */
+    onBlur: (e: any) => any,
+    /** Value of the input */
+    value: any,
+    /* name of the input */
+    name?: string,
+    ...
+   },
+   form: FormikProps<any>,
+   ...
+  };
+   
+    /* This is used for HOC with Formik. 
+     * @example
+     * 
+     * import * as React from 'react';
+     * import type {FormikHOC} from 'formik';
+     * // define HOC using withFormik
+     * const formikEnhancer = withFormik({...SOMECODE});
+     * type PropsType = FormikHOC; // defining the type
+     *
+     * @formikEnhancer
+     * export default class MyFormikHoc extends React.PureComponent<PropsType> {
+     *     render() {
+     *       const {setFieldValue, status, errors, dirty} = this.props;     
+     *     }
+     *  }
+     *
+     * 
+     * <MyFormikHoc/> 
+    */
+   declare export type FormikHOC = {
+    dirty?: $PropertyType<FormikComputedProps<any>, 'dirty'>,
+    errors?: FormikErrors,
+    handleBlur?: $PropertyType<FormikHandlers, 'handleBlur'>,
+    handleChange?: $PropertyType<FormikHandlers, 'handleChange'>,
+    handleReset?: $PropertyType<FormikHandlers, 'handleReset'>,
+    handleSubmit?: $PropertyType<FormikHandlers, 'FormikHandlers'>,
+    isValid?: $PropertyType<FormikComputedProps<any>, 'isValid'>,
+    resetForm?: $PropertyType<FormikActions<any>, 'resetForm'>,
+    setErrors?: $PropertyType<FormikActions<any>, 'setErrors'>,
+    setFieldError?: $PropertyType<FormikActions<any>, 'setFieldError'>,
+    setFieldTouched?: $PropertyType<FormikActions<any>, 'setFieldTouched'>,
+    setFieldValue?: $PropertyType<FormikActions<any>, 'setFieldValue'>,
+    setStatus?: $PropertyType<FormikActions<any>, 'setStatus'>,
+    setSubmitting?: $PropertyType<FormikActions<any>, 'setSubmitting'>,
+    setTouched?: $PropertyType<FormikActions<any>, 'setTouched'>,
+    setValues?: $PropertyType<FormikActions<any>, 'setValues'>,
+    status?: $PropertyType<FormikState<any>, 'status'>,
+    touched?: $PropertyType<FormikState<any>, 'touched'>,
+    values?: $PropertyType<FormikState<any>, 'values'>,
+    isSubmitting?: $PropertyType<FormikState<any>, 'isSubmitting'>,
+    ...
+   }
+
+  declare export var Field: React$StatelessFunctionalComponent<any>;
+
+  declare export var Form: React$StatelessFunctionalComponent<any>;
+
+  declare export var withFormik: Function;
+}
diff --git a/definitions/npm/jest_v16.x.x/flow_v0.104.x-/jest_v16.x.x.js b/definitions/npm/jest_v16.x.x/flow_v0.104.x-v.200.x/jest_v16.x.x.js
similarity index 100%
rename from definitions/npm/jest_v16.x.x/flow_v0.104.x-/jest_v16.x.x.js
rename to definitions/npm/jest_v16.x.x/flow_v0.104.x-v.200.x/jest_v16.x.x.js
diff --git a/definitions/npm/jest_v16.x.x/flow_v0.201.x-/jest_v16.x.x.js b/definitions/npm/jest_v16.x.x/flow_v0.201.x-/jest_v16.x.x.js
new file mode 100644
index 0000000000..b2ccaf4157
--- /dev/null
+++ b/definitions/npm/jest_v16.x.x/flow_v0.201.x-/jest_v16.x.x.js
@@ -0,0 +1,132 @@
+type JestMockFn = {
+  (...args: Array<any>): any,
+  mock: {
+    calls: Array<Array<any>>,
+    instances: mixed,
+    ...
+  },
+  mockClear(): Function,
+  mockImplementation(fn: Function): JestMockFn,
+  mockImplementationOnce(fn: Function): JestMockFn,
+  mockReturnThis(): void,
+  mockReturnValue(value: any): JestMockFn,
+  mockReturnValueOnce(value: any): JestMockFn,
+  ...
+};
+
+type JestAsymmetricEqualityType = { asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestExpectType = {
+  not: JestExpectType,
+  lastCalledWith(...args: Array<any>): void,
+  toBe(value: any): void,
+  toBeCalled(): void,
+  toBeCalledWith(...args: Array<any>): void,
+  toBeCloseTo(num: number, delta: any): void,
+  toBeDefined(): void,
+  toBeFalsy(): void,
+  toBeGreaterThan(number: number): void,
+  toBeGreaterThanOrEqual(number: number): void,
+  toBeLessThan(number: number): void,
+  toBeLessThanOrEqual(number: number): void,
+  toBeInstanceOf(cls: Class<any>): void,
+  toBeNull(): void,
+  toBeTruthy(): void,
+  toBeUndefined(): void,
+  toContain(item: any): void,
+  toContainEqual(item: any): void,
+  toEqual(value: any): void,
+  toHaveBeenCalled(): void,
+  toHaveBeenCalledTimes(number: number): void,
+  toHaveBeenCalledWith(...args: Array<any>): void,
+  toMatch(regexp: RegExp): void,
+  toMatchSnapshot(): void,
+  toThrow(message?: string | Error): void,
+  toThrowError(message?: string | Error | RegExp): void,
+  toThrowErrorMatchingSnapshot(): void,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+declare function afterEach(fn: Function): void;
+declare function beforeEach(fn: Function): void;
+declare function afterAll(fn: Function): void;
+declare function beforeAll(fn: Function): void;
+declare function describe(name: string, fn: Function): void;
+declare var it: {
+  (name: string, fn: Function): ?Promise<void>,
+  only(name: string, fn: Function): ?Promise<void>,
+  skip(name: string, fn: Function): ?Promise<void>,
+  concurrent(name: string, fn: Function): ?Promise<void>,
+  ...
+};
+declare function fit(name: string, fn: Function): ?Promise<void>;
+declare var test: typeof it;
+declare var xdescribe: typeof describe;
+declare var fdescribe: typeof describe;
+declare var xit: typeof it;
+declare var xtest: typeof it;
+
+declare function expect(value: any): JestExpectType;
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+declare var jest: {
+  autoMockOff(): void,
+  autoMockOn(): void,
+  clearAllMocks(): void,
+  clearAllTimers(): void,
+  currentTestPath(): void,
+  disableAutomock(): void,
+  doMock(moduleName: string, moduleFactory?: any): void,
+  dontMock(moduleName: string): void,
+  enableAutomock(): void,
+  fn(implementation?: Function): JestMockFn,
+  isMockFunction(fn: Function): boolean,
+  genMockFromModule(moduleName: string): any,
+  mock(moduleName: string, moduleFactory?: any): void,
+  resetModules(): void,
+  runAllTicks(): void,
+  runAllTimers(): void,
+  runTimersToTime(msToRun: number): void,
+  runOnlyPendingTimers(): void,
+  setMock(moduleName: string, moduleExports: any): void,
+  unmock(moduleName: string): void,
+  useFakeTimers(): void,
+  useRealTimers(): void,
+  ...
+};
+
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): void,
+  arrayContaining(value: mixed[]): void,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  objectContaining(value: Object): void,
+  stringMatching(value: string): void,
+  ...
+};
diff --git a/definitions/npm/jest_v17.x.x/flow_v0.104.x-/jest_v17.x.x.js b/definitions/npm/jest_v17.x.x/flow_v0.104.x-v.200.x/jest_v17.x.x.js
similarity index 100%
rename from definitions/npm/jest_v17.x.x/flow_v0.104.x-/jest_v17.x.x.js
rename to definitions/npm/jest_v17.x.x/flow_v0.104.x-v.200.x/jest_v17.x.x.js
diff --git a/definitions/npm/jest_v17.x.x/flow_v0.201.x-/jest_v17.x.x.js b/definitions/npm/jest_v17.x.x/flow_v0.201.x-/jest_v17.x.x.js
new file mode 100644
index 0000000000..8c7d563736
--- /dev/null
+++ b/definitions/npm/jest_v17.x.x/flow_v0.201.x-/jest_v17.x.x.js
@@ -0,0 +1,428 @@
+type JestMockFn = {
+ (...args: Array<any>): any,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<Array<any>>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: mixed,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): Function,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): Function,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(fn: Function): JestMockFn,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(fn: Function): JestMockFn,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: any): JestMockFn,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: any): JestMockFn,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestExpectType = {
+ not: JestExpectType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression.
+  */
+ toMatch(regexp: RegExp): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  */
+ toThrow(message?: string | Error): void,
+ /**
+  * Use .toThrowError to test that a function throws a specific error when it
+  * is called. The argument can be a string for the error message, a class for
+  * the error, or a regex that should match the error.
+  */
+ toThrowError(message?: string | Error | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn(implementation?: Function): JestMockFn,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(fn: Function): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(fn: Function): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(fn: Function): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(fn: Function): void;
+/** A context for grouping tests together */
+declare function describe(name: string, fn: Function): void;
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ (name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Only run this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ only(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Skip running this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ skip(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Run the test concurrently
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ concurrent(name: string, fn?: Function): ?Promise<void>,
+ ...
+};
+declare function fit(name: string, fn: Function): ?Promise<void>;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ objectContaining(value: Object): void,
+ stringMatching(value: string): void,
+ ...
+};
diff --git a/definitions/npm/jest_v18.x.x/flow_v0.104.x-/jest_v18.x.x.js b/definitions/npm/jest_v18.x.x/flow_v0.104.x-v.200.x/jest_v18.x.x.js
similarity index 100%
rename from definitions/npm/jest_v18.x.x/flow_v0.104.x-/jest_v18.x.x.js
rename to definitions/npm/jest_v18.x.x/flow_v0.104.x-v.200.x/jest_v18.x.x.js
diff --git a/definitions/npm/jest_v18.x.x/flow_v0.201.x-/jest_v18.x.x.js b/definitions/npm/jest_v18.x.x/flow_v0.201.x-/jest_v18.x.x.js
new file mode 100644
index 0000000000..57a4b4c162
--- /dev/null
+++ b/definitions/npm/jest_v18.x.x/flow_v0.201.x-/jest_v18.x.x.js
@@ -0,0 +1,450 @@
+type JestMockFn = {
+ (...args: Array<any>): any,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<Array<any>>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: mixed,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): Function,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): Function,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(fn: Function): JestMockFn,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(fn: Function): JestMockFn,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: any): JestMockFn,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: any): JestMockFn,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestExpectType = {
+ not: JestExpectType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  *
+  */
+ toHaveProperty(propPath: string, value?: any): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression.
+  */
+ toMatch(regexp: RegExp): void,
+ /**
+  * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+  */
+ toMatchObject(object: Object): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(name?: string): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  */
+ toThrow(message?: string | Error): void,
+ /**
+  * Use .toThrowError to test that a function throws a specific error when it
+  * is called. The argument can be a string for the error message, a class for
+  * the error, or a regex that should match the error.
+  */
+ toThrowError(message?: string | Error | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn(implementation?: Function): JestMockFn,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(fn: Function): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(fn: Function): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(fn: Function): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(fn: Function): void;
+/** A context for grouping tests together */
+declare function describe(name: string, fn: Function): void;
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ (name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Only run this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ only(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Skip running this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ skip(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Run the test concurrently
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ concurrent(name: string, fn?: Function): ?Promise<void>,
+ ...
+};
+declare function fit(name: string, fn: Function): ?Promise<void>;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ assertions(expectedAssertions: number): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ objectContaining(value: Object): void,
+ stringMatching(value: string | RegExp): void,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): void,
+ stringMatching(value: string): void,
+ ...
+};
diff --git a/definitions/npm/jest_v19.x.x/flow_v0.104.x-/jest_v19.x.x.js b/definitions/npm/jest_v19.x.x/flow_v0.104.x-v.200.x/jest_v19.x.x.js
similarity index 100%
rename from definitions/npm/jest_v19.x.x/flow_v0.104.x-/jest_v19.x.x.js
rename to definitions/npm/jest_v19.x.x/flow_v0.104.x-v.200.x/jest_v19.x.x.js
diff --git a/definitions/npm/jest_v19.x.x/flow_v0.201.x-/jest_v19.x.x.js b/definitions/npm/jest_v19.x.x/flow_v0.201.x-/jest_v19.x.x.js
new file mode 100644
index 0000000000..118f5aaa5b
--- /dev/null
+++ b/definitions/npm/jest_v19.x.x/flow_v0.201.x-/jest_v19.x.x.js
@@ -0,0 +1,469 @@
+type JestMockFn = {
+ (...args: Array<any>): any,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<Array<any>>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: mixed,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): Function,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): Function,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(fn: Function): JestMockFn,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(fn: Function): JestMockFn,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: any): JestMockFn,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: any): JestMockFn,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestExpectType = {
+ not: JestExpectType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * If you have a mock function, you can use .toHaveBeenLastCalledWith to test what
+  * arguments it was last called with.
+  */
+ toHaveBeenLastCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  *
+  */
+ toHaveProperty(propPath: string, value?: any): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression.
+  */
+ toMatch(regexp: RegExp): void,
+ /**
+  * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+  */
+ toMatchObject(object: Object): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(name?: string): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  */
+ toThrow(message?: string | Error): void,
+ /**
+  * Use .toThrowError to test that a function throws a specific error when it
+  * is called. The argument can be a string for the error message, a class for
+  * the error, or a regex that should match the error.
+  */
+ toThrowError(message?: string | Error | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn(implementation?: Function): JestMockFn,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(object: Object, methodName: string): JestMockFn,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(fn: Function): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(fn: Function): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(fn: Function): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(fn: Function): void;
+/** A context for grouping tests together */
+declare function describe(name: string, fn: Function): void;
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ (name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Only run this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ only(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Skip running this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ skip(name: string, fn?: Function): ?Promise<void>,
+ /**
+  * Run the test concurrently
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  */
+ concurrent(name: string, fn?: Function): ?Promise<void>,
+ ...
+};
+declare function fit(name: string, fn: Function): ?Promise<void>;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(serializer: (input: Object) => string): void,
+ assertions(expectedAssertions: number): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ objectContaining(value: Object): void,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): void,
+ stringMatching(value: string | RegExp): void,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): void,
+ stringMatching(value: string): void,
+ ...
+};
diff --git a/definitions/npm/jest_v20.x.x/flow_v0.134.x-/jest_v20.x.x.js b/definitions/npm/jest_v20.x.x/flow_v0.134.x-v.200.x/jest_v20.x.x.js
similarity index 100%
rename from definitions/npm/jest_v20.x.x/flow_v0.134.x-/jest_v20.x.x.js
rename to definitions/npm/jest_v20.x.x/flow_v0.134.x-v.200.x/jest_v20.x.x.js
diff --git a/definitions/npm/jest_v20.x.x/flow_v0.134.x-/test_jest-v20.x.x.js b/definitions/npm/jest_v20.x.x/flow_v0.134.x-v.200.x/test_jest-v20.x.x.js
similarity index 100%
rename from definitions/npm/jest_v20.x.x/flow_v0.134.x-/test_jest-v20.x.x.js
rename to definitions/npm/jest_v20.x.x/flow_v0.134.x-v.200.x/test_jest-v20.x.x.js
diff --git a/definitions/npm/jest_v20.x.x/flow_v0.201.x-/jest_v20.x.x.js b/definitions/npm/jest_v20.x.x/flow_v0.201.x-/jest_v20.x.x.js
new file mode 100644
index 0000000000..877c567236
--- /dev/null
+++ b/definitions/npm/jest_v20.x.x/flow_v0.201.x-/jest_v20.x.x.js
@@ -0,0 +1,627 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn,
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn,
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeEmptyRender(): void,
+ toBePresent(): void,
+ toContainReact(element: React$Element<any>): void,
+ toExist(): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp: ((propKey: string, propValue?: any) => void) &
+   ((props: {...}) => void),
+ toHaveRef(refName: string): void,
+ toHaveState: ((stateKey: string, stateValue?: any) => void) &
+   ((state: {...}) => void),
+ toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+   ((style: {...}) => void),
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toIncludeText(text: string): void,
+ toHaveValue(value: any): void,
+ toMatchElement(element: React$Element<any>): void,
+ toMatchSelector(selector: string): void,
+ ...
+};
+
+// DOM testing library extensions https://github.com/kentcdodds/dom-testing-library#custom-jest-matchers
+type DomTestingLibraryType = {
+ toBeInTheDOM(): void,
+ toHaveTextContent(content: string): void,
+ toHaveAttribute(name: string, expectedValue?: string): void,
+ ...
+};
+
+type JestExpectType = {
+ not: JestExpectType & EnzymeMatchersType & DomTestingLibraryType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+  * with specific arguments.
+  */
+ toHaveBeenLastCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  *
+  */
+ toHaveProperty(propPath: string, value?: any): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression or string.
+  */
+ toMatch(regexpOrString: RegExp | string): void,
+ /**
+  * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+  */
+ toMatchObject(object: Object): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(name?: string): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  * If you want to test that a specific error gets thrown, you can provide an
+  * argument to toThrow. The argument can be a string for the error message,
+  * a class for the error, or a regex that should match the error.
+  *
+  * Alias: .toThrowError
+  */
+ toThrow(message?: string | Error | RegExp): void,
+ toThrowError(message?: string | Error | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn,
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(object: Object, methodName: string): JestMockFn<any, any>,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(fn: (done: () => void) => ?Promise<mixed>, timeout?: number): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(fn: (done: () => void) => ?Promise<mixed>, timeout?: number): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(fn: (done: () => void) => ?Promise<mixed>, timeout?: number): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(fn: (done: () => void) => ?Promise<mixed>, timeout?: number): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: string, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: string, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: string, fn: () => void): void,
+ ...
+};
+
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (name: string, fn?: (done: () => void) => ?Promise<mixed>, timeout?: number): void,
+ /**
+  * Only run this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only(name: string, fn?: (done: () => void) => ?Promise<mixed>, timeout?: number): void,
+ /**
+  * Skip running this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(name: string, fn?: (done: () => void) => ?Promise<mixed>, timeout?: number): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(name: string, fn?: (done: () => void) => ?Promise<mixed>, timeout?: number): void,
+ ...
+};
+declare function fit(
+  name: string,
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number,
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors,
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType & JestPromiseType & EnzymeMatchersType & DomTestingLibraryType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ objectContaining(value: Object): void,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): void,
+ stringMatching(value: string | RegExp): void,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): void,
+ stringMatching(value: string): void,
+ ...
+};
diff --git a/definitions/npm/jest_v20.x.x/flow_v0.201.x-/test_jest-v20.x.x.js b/definitions/npm/jest_v20.x.x/flow_v0.201.x-/test_jest-v20.x.x.js
new file mode 100644
index 0000000000..b207facad5
--- /dev/null
+++ b/definitions/npm/jest_v20.x.x/flow_v0.201.x-/test_jest-v20.x.x.js
@@ -0,0 +1,325 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = { doStuff: string => number, ... };
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  }
+};
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect("jester").toContain("jest");
+expect({ foo: "bar" }).toHaveProperty("foo");
+expect({ foo: "bar" }).toHaveProperty("foo", "bar");
+expect("foo").toMatchSnapshot("snapshot name");
+expect({ foo: "bar" }).toMatchObject({ baz: "qux" });
+expect("foobar").toMatch(/foo/);
+expect("foobar").toMatch("foo");
+
+mockFn("a");
+expect("someVal").toBeCalled();
+expect("someVal").toBeCalledWith("a");
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect("someVal").toHaveBeeenCalledWith("a");
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+describe('name', () => {});
+describe.only('name', () => {});
+describe.skip('name', () => {});
+
+test("test", () => expect("foo").toMatchSnapshot());
+test.only("test", () => expect("foo").toMatchSnapshot());
+test.skip("test", () => expect("foo").toMatchSnapshot());
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[prop-missing] property `pass` not found in object literal
+    return {};
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.spyOn({}, 'foo');
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+expect(wrapper).toBeChecked();
+
+expect(wrapper).toBeDisabled();
+
+expect(wrapper).toBeEmpty();
+
+expect(wrapper).toBeEmptyRender();
+
+expect(wrapper).toBePresent();
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: "test" });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: "test" }, "test");
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: "test" });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: "test" }, "test");
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: "#ccc" });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: "#ccc" }, "test");
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toIncludeText("test");
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toHaveValue("test");
+
+expect(wrapper).toMatchElement(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// dom-testing-library
+{
+  const element = document.createElement('div');
+
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toBeInTheDOM();
+
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  // $FlowExpectedError[incompatible-call]: expected attribute value should be a string
+  expect(element).toHaveAttribute('foo', 1);
+}
diff --git a/definitions/npm/jest_v21.x.x/flow_v0.134.x-/jest_v21.x.x.js b/definitions/npm/jest_v21.x.x/flow_v0.134.x-v.200.x/jest_v21.x.x.js
similarity index 100%
rename from definitions/npm/jest_v21.x.x/flow_v0.134.x-/jest_v21.x.x.js
rename to definitions/npm/jest_v21.x.x/flow_v0.134.x-v.200.x/jest_v21.x.x.js
diff --git a/definitions/npm/jest_v21.x.x/flow_v0.134.x-/test_jest-v21.x.x.js b/definitions/npm/jest_v21.x.x/flow_v0.134.x-v.200.x/test_jest-v21.x.x.js
similarity index 100%
rename from definitions/npm/jest_v21.x.x/flow_v0.134.x-/test_jest-v21.x.x.js
rename to definitions/npm/jest_v21.x.x/flow_v0.134.x-v.200.x/test_jest-v21.x.x.js
diff --git a/definitions/npm/jest_v21.x.x/flow_v0.201.x-/jest_v21.x.x.js b/definitions/npm/jest_v21.x.x/flow_v0.201.x-/jest_v21.x.x.js
new file mode 100644
index 0000000000..1039480c97
--- /dev/null
+++ b/definitions/npm/jest_v21.x.x/flow_v0.201.x-/jest_v21.x.x.js
@@ -0,0 +1,656 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBePresent(): void,
+ toContainReact(element: React$Element<any>): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp(propKey: string, propValue?: any): void,
+ toHaveRef(refName: string): void,
+ toHaveState(stateKey: string, stateValue?: any): void,
+ toHaveStyle(styleKey: string, styleValue?: any): void,
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toIncludeText(text: string): void,
+ toHaveValue(value: any): void,
+ toMatchElement(element: React$Element<any>): void,
+ toMatchSelector(selector: string): void,
+ ...
+};
+
+type JestExpectType = {
+ not: JestExpectType & EnzymeMatchersType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+  * with specific arguments.
+  */
+ toHaveBeenLastCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  *
+  */
+ toHaveProperty(propPath: string, value?: any): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression or string.
+  */
+ toMatch(regexpOrString: RegExp | string): void,
+ /**
+  * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+  */
+ toMatchObject(object: Object | Array<Object>): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(name?: string): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  * If you want to test that a specific error gets thrown, you can provide an
+  * argument to toThrow. The argument can be a string for the error message,
+  * a class for the error, or a regex that should match the error.
+  *
+  * Alias: .toThrowError
+  */
+ toThrow(message?: string | Error | Class<Error> | RegExp): void,
+ toThrowError(message?: string | Error | Class<Error> | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Returns the actual module instead of a mock, bypassing all checks on
+  * whether the module should receive a mock implementation or not.
+  */
+ requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+ /**
+  * Returns a mock module instead of the actual module, bypassing all checks
+  * on whether the module should be required normally or not.
+  */
+ requireMock(moduleName: string): any,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(object: Object, methodName: string): JestMockFn<any, any>,
+ /**
+  * Set the default timeout interval for tests and before/after hooks in milliseconds.
+  * Note: The default timeout interval is 5 seconds if this method is not called.
+  */
+ setTimeout(timeout: number): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: string, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: string, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: string, fn: () => void): void,
+ ...
+};
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (
+   name: string,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Only run this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only(
+   name: string,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Skip running this test
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(
+   name: string,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {string} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(
+   name: string,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ ...
+};
+declare function fit(
+  name: string,
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors,
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType & JestPromiseType & EnzymeMatchersType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ objectContaining(value: Object): void,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): void,
+ stringMatching(value: string | RegExp): void,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): void,
+ arrayContaining(value: Array<mixed>): void,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): void,
+ stringMatching(value: string): void,
+ ...
+};
diff --git a/definitions/npm/jest_v21.x.x/flow_v0.201.x-/test_jest-v21.x.x.js b/definitions/npm/jest_v21.x.x/flow_v0.201.x-/test_jest-v21.x.x.js
new file mode 100644
index 0000000000..4eda067616
--- /dev/null
+++ b/definitions/npm/jest_v21.x.x/flow_v0.201.x-/test_jest-v21.x.x.js
@@ -0,0 +1,301 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = { doStuff: string => number, ... };
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  }
+};
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect("jester").toContain("jest");
+expect({ foo: "bar" }).toHaveProperty("foo");
+expect({ foo: "bar" }).toHaveProperty("foo", "bar");
+expect("foo").toMatchSnapshot("snapshot name");
+expect({ foo: "bar" }).toMatchObject({ baz: "qux" });
+expect("foobar").toMatch(/foo/);
+expect("foobar").toMatch("foo");
+
+mockFn("a");
+expect("someVal").toBeCalled();
+expect("someVal").toBeCalledWith("a");
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect("someVal").toHaveBeeenCalledWith("a");
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+describe('name', () => {});
+describe.only('name', () => {});
+describe.skip('name', () => {});
+
+test("test", () => expect("foo").toMatchSnapshot());
+test.only("test", () => expect("foo").toMatchSnapshot());
+test.skip("test", () => expect("foo").toMatchSnapshot());
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[prop-missing] property `pass` not found in object literal
+    return {};
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.spyOn({}, 'foo');
+
+jest.setTimeout(1000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+expect(wrapper).toBeChecked();
+
+expect(wrapper).toBeDisabled();
+
+expect(wrapper).toBeEmpty();
+
+expect(wrapper).toBePresent();
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toIncludeText("test");
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toHaveValue("test");
+
+expect(wrapper).toMatchElement(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
diff --git a/definitions/npm/jest_v22.x.x/flow_v0.134.x-/jest_v22.x.x.js b/definitions/npm/jest_v22.x.x/flow_v0.134.x-v.200.x/jest_v22.x.x.js
similarity index 100%
rename from definitions/npm/jest_v22.x.x/flow_v0.134.x-/jest_v22.x.x.js
rename to definitions/npm/jest_v22.x.x/flow_v0.134.x-v.200.x/jest_v22.x.x.js
diff --git a/definitions/npm/jest_v22.x.x/flow_v0.134.x-/test_jest-v22.x.x.js b/definitions/npm/jest_v22.x.x/flow_v0.134.x-v.200.x/test_jest-v22.x.x.js
similarity index 100%
rename from definitions/npm/jest_v22.x.x/flow_v0.134.x-/test_jest-v22.x.x.js
rename to definitions/npm/jest_v22.x.x/flow_v0.134.x-v.200.x/test_jest-v22.x.x.js
diff --git a/definitions/npm/jest_v22.x.x/flow_v0.201.x-/jest_v22.x.x.js b/definitions/npm/jest_v22.x.x/flow_v0.201.x-/jest_v22.x.x.js
new file mode 100644
index 0000000000..77a98b9429
--- /dev/null
+++ b/definitions/npm/jest_v22.x.x/flow_v0.201.x-/jest_v22.x.x.js
@@ -0,0 +1,975 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a string to use in test result output in place of "jest.fn()" to
+  * indicate which mock function is being referenced.
+  */
+ mockName(name: string): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Deprecated: use jest.fn(() => value) instead
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) => JestMatcherResult;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeEmptyRender(): void,
+ toBePresent(): void,
+ toContainReact(element: React$Element<any>): void,
+ toExist(): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp: ((propKey: string, propValue?: any) => void) &
+   ((props: {...}) => void),
+ toHaveRef(refName: string): void,
+ toHaveState: ((stateKey: string, stateValue?: any) => void) &
+   ((state: {...}) => void),
+ toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+   ((style: {...}) => void),
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toIncludeText(text: string): void,
+ toHaveValue(value: any): void,
+ toMatchElement(element: React$Element<any>): void,
+ toMatchSelector(selector: string): void,
+ ...
+};
+
+// DOM testing library extensions https://github.com/kentcdodds/dom-testing-library#custom-jest-matchers
+type DomTestingLibraryType = {
+ toBeInTheDOM(): void,
+ toHaveTextContent(content: string): void,
+ toHaveAttribute(name: string, expectedValue?: string): void,
+ ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+ toExist(): void,
+ toHaveLength(len: number): void,
+ toHaveId(id: string): void,
+ toHaveClass(className: string): void,
+ toHaveTag(tag: string): void,
+ toHaveAttr(key: string, val?: any): void,
+ toHaveProp(key: string, val?: any): void,
+ toHaveText(text: string | RegExp): void,
+ toHaveData(key: string, val?: any): void,
+ toHaveValue(val: any): void,
+ toHaveCss(css: { [key: string]: any, ... }): void,
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeHidden(): void,
+ toBeSelected(): void,
+ toBeVisible(): void,
+ toBeFocused(): void,
+ toBeInDom(): void,
+ toBeMatchedBy(sel: string): void,
+ toHaveDescendant(sel: string): void,
+ toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+ ...
+};
+
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+ /**
+    * Note: Currently unimplemented
+    * Passing assertion
+    *
+    * @param {String} message
+    */
+ //  pass(message: string): void;
+
+ /**
+  * Note: Currently unimplemented
+  * Failing assertion
+  *
+  * @param {String} message
+  */
+ //  fail(message: string): void;
+
+ /**
+  * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+  */
+ toBeEmpty(): void,
+ /**
+  * Use .toBeOneOf when checking if a value is a member of a given Array.
+  * @param {Array.<*>} members
+  */
+ toBeOneOf(members: any[]): void,
+ /**
+  * Use `.toBeNil` when checking a value is `null` or `undefined`.
+  */
+ toBeNil(): void,
+ /**
+  * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+  * @param {Function} predicate
+  */
+ toSatisfy(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeArray` when checking if a value is an `Array`.
+  */
+ toBeArray(): void,
+ /**
+  * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+  * @param {Number} x
+  */
+ toBeArrayOfSize(x: number): void,
+ /**
+  * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAllMembers(members: any[]): void,
+ /**
+  * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAnyMembers(members: any[]): void,
+ /**
+  * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+  * @param {Function} predicate
+  */
+ toSatisfyAll(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+  */
+ toBeBoolean(): void,
+ /**
+  * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+  */
+ toBeTrue(): void,
+ /**
+  * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+  */
+ toBeFalse(): void,
+ /**
+  * Use .toBeDate when checking if a value is a Date.
+  */
+ toBeDate(): void,
+ /**
+  * Use `.toBeFunction` when checking if a value is a `Function`.
+  */
+ toBeFunction(): void,
+ /**
+  * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+  *
+  * Note: Required Jest version >22
+  * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+  *
+  * @param {Mock} mock
+  */
+ toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+ /**
+  * Use `.toBeNumber` when checking if a value is a `Number`.
+  */
+ toBeNumber(): void,
+ /**
+  * Use `.toBeNaN` when checking a value is `NaN`.
+  */
+ toBeNaN(): void,
+ /**
+  * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+  */
+ toBeFinite(): void,
+ /**
+  * Use `.toBePositive` when checking if a value is a positive `Number`.
+  */
+ toBePositive(): void,
+ /**
+  * Use `.toBeNegative` when checking if a value is a negative `Number`.
+  */
+ toBeNegative(): void,
+ /**
+  * Use `.toBeEven` when checking if a value is an even `Number`.
+  */
+ toBeEven(): void,
+ /**
+  * Use `.toBeOdd` when checking if a value is an odd `Number`.
+  */
+ toBeOdd(): void,
+ /**
+  * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+  *
+  * @param {Number} start
+  * @param {Number} end
+  */
+ toBeWithin(start: number, end: number): void,
+ /**
+  * Use `.toBeObject` when checking if a value is an `Object`.
+  */
+ toBeObject(): void,
+ /**
+  * Use `.toContainKey` when checking if an object contains the provided key.
+  *
+  * @param {String} key
+  */
+ toContainKey(key: string): void,
+ /**
+  * Use `.toContainKeys` when checking if an object has all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAllKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAnyKeys(keys: string[]): void,
+ /**
+  * Use `.toContainValue` when checking if an object contains the provided value.
+  *
+  * @param {*} value
+  */
+ toContainValue(value: any): void,
+ /**
+  * Use `.toContainValues` when checking if an object contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainValues(values: any[]): void,
+ /**
+  * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAllValues(values: any[]): void,
+ /**
+  * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAnyValues(values: any[]): void,
+ /**
+  * Use `.toContainEntry` when checking if an object contains the provided entry.
+  *
+  * @param {Array.<String, String>} entry
+  */
+ toContainEntry(entry: [string, string]): void,
+ /**
+  * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAllEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAnyEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toBeExtensible` when checking if an object is extensible.
+  */
+ toBeExtensible(): void,
+ /**
+  * Use `.toBeFrozen` when checking if an object is frozen.
+  */
+ toBeFrozen(): void,
+ /**
+  * Use `.toBeSealed` when checking if an object is sealed.
+  */
+ toBeSealed(): void,
+ /**
+  * Use `.toBeString` when checking if a value is a `String`.
+  */
+ toBeString(): void,
+ /**
+  * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+  *
+  * @param {String} string
+  */
+ toEqualCaseInsensitive(string: string): void,
+ /**
+  * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+  *
+  * @param {String} prefix
+  */
+ toStartWith(prefix: string): void,
+ /**
+  * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+  *
+  * @param {String} suffix
+  */
+ toEndWith(suffix: string): void,
+ /**
+  * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+  *
+  * @param {String} substring
+  */
+ toInclude(substring: string): void,
+ /**
+  * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+  *
+  * @param {String} substring
+  * @param {Number} times
+  */
+ toIncludeRepeated(substring: string, times: number): void,
+ /**
+  * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+  *
+  * @param {Array.<String>} substring
+  */
+ toIncludeMultiple(substring: string[]): void,
+ ...
+};
+
+type JestExpectType = {
+ not: JestExpectType & EnzymeMatchersType & DomTestingLibraryType & JestJQueryMatchersType & JestExtendedMatchersType,
+ /**
+  * If you have a mock function, you can use .lastCalledWith to test what
+  * arguments it was last called with.
+  */
+ lastCalledWith(...args: Array<any>): void,
+ /**
+  * toBe just checks that a value is what you expect. It uses === to check
+  * strict equality.
+  */
+ toBe(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toBeCalled(): void,
+ /**
+  * Use .toBeCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toBeCalledWith(...args: Array<any>): void,
+ /**
+  * Using exact equality with floating point numbers is a bad idea. Rounding
+  * means that intuitive things fail.
+  */
+ toBeCloseTo(num: number, delta: any): void,
+ /**
+  * Use .toBeDefined to check that a variable is not undefined.
+  */
+ toBeDefined(): void,
+ /**
+  * Use .toBeFalsy when you don't care what a value is, you just want to
+  * ensure a value is false in a boolean context.
+  */
+ toBeFalsy(): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThan.
+  */
+ toBeGreaterThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+  */
+ toBeGreaterThanOrEqual(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThan.
+  */
+ toBeLessThan(number: number): void,
+ /**
+  * To compare floating point numbers, you can use toBeLessThanOrEqual.
+  */
+ toBeLessThanOrEqual(number: number): void,
+ /**
+  * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+  * class.
+  */
+ toBeInstanceOf(cls: Class<any>): void,
+ /**
+  * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+  * nicer.
+  */
+ toBeNull(): void,
+ /**
+  * Use .toBeTruthy when you don't care what a value is, you just want to
+  * ensure a value is true in a boolean context.
+  */
+ toBeTruthy(): void,
+ /**
+  * Use .toBeUndefined to check that a variable is undefined.
+  */
+ toBeUndefined(): void,
+ /**
+  * Use .toContain when you want to check that an item is in a list. For
+  * testing the items in the list, this uses ===, a strict equality check.
+  */
+ toContain(item: any): void,
+ /**
+  * Use .toContainEqual when you want to check that an item is in a list. For
+  * testing the items in the list, this matcher recursively checks the
+  * equality of all fields, rather than checking for object identity.
+  */
+ toContainEqual(item: any): void,
+ /**
+  * Use .toEqual when you want to check that two objects have the same value.
+  * This matcher recursively checks the equality of all fields, rather than
+  * checking for object identity.
+  */
+ toEqual(value: any): void,
+ /**
+  * Use .toHaveBeenCalled to ensure that a mock function got called.
+  */
+ toHaveBeenCalled(): void,
+ /**
+  * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+  * number of times.
+  */
+ toHaveBeenCalledTimes(number: number): void,
+ /**
+  * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+  * specific arguments.
+  */
+ toHaveBeenCalledWith(...args: Array<any>): void,
+ /**
+  * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+  * with specific arguments.
+  */
+ toHaveBeenLastCalledWith(...args: Array<any>): void,
+ /**
+  * Check that an object has a .length property and it is set to a certain
+  * numeric value.
+  */
+ toHaveLength(number: number): void,
+ /**
+  *
+  */
+ toHaveProperty(propPath: string | Array<string>, value?: any): void,
+ /**
+  * Use .toMatch to check that a string matches a regular expression or string.
+  */
+ toMatch(regexpOrString: RegExp | string): void,
+ /**
+  * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+  */
+ toMatchObject(object: Object | Array<Object>): void,
+ /**
+  * This ensures that a React component matches the most recent snapshot.
+  */
+ toMatchSnapshot(name?: string): void,
+ /**
+  * Use .toThrow to test that a function throws when it is called.
+  * If you want to test that a specific error gets thrown, you can provide an
+  * argument to toThrow. The argument can be a string for the error message,
+  * a class for the error, or a regex that should match the error.
+  *
+  * Alias: .toThrowError
+  */
+ toThrow(message?: string | Error | Class<Error> | RegExp): void,
+ toThrowError(message?: string | Error | Class<Error> | RegExp): void,
+ /**
+  * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+  * matching the most recent snapshot when it is called.
+  */
+ toThrowErrorMatchingSnapshot(): void,
+ ...
+};
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Restores all mocks back to their original value.
+  */
+ restoreAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Returns the actual module instead of a mock, bypassing all checks on
+  * whether the module should receive a mock implementation or not.
+  */
+ requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+ /**
+  * Returns a mock module instead of the actual module, bypassing all checks
+  * on whether the module should be required normally or not.
+  */
+ requireMock(moduleName: string): any,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ advanceTimersByTime(msToRun: number): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  *
+  * Renamed to `advanceTimersByTime`.
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(object: Object, methodName: string, accessType?: "get" | "set"): JestMockFn<any, any>,
+ /**
+  * Set the default timeout interval for tests and before/after hooks in milliseconds.
+  * Note: The default timeout interval is 5 seconds if this method is not called.
+  */
+ setTimeout(timeout: number): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: JestTestName, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: JestTestName, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: JestTestName, fn: () => void): void,
+ ...
+};
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Only run this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only(
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Skip running this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ ...
+};
+declare function fit(
+  name: JestTestName,
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors,
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any): JestExpectType & JestPromiseType & EnzymeMatchersType & DomTestingLibraryType & JestJQueryMatchersType & JestExtendedMatchersType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ objectContaining(value: Object): Object,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): string,
+ stringMatching(value: string | RegExp): string,
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): Object,
+ stringMatching(value: string): string,
+ ...
+};
diff --git a/definitions/npm/jest_v22.x.x/flow_v0.201.x-/test_jest-v22.x.x.js b/definitions/npm/jest_v22.x.x/flow_v0.201.x-/test_jest-v22.x.x.js
new file mode 100644
index 0000000000..12d383388b
--- /dev/null
+++ b/definitions/npm/jest_v22.x.x/flow_v0.201.x-/test_jest-v22.x.x.js
@@ -0,0 +1,503 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = { doStuff: string => number, ... };
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  }
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doStuff = jest.fn().mockName("10");
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect("jester").toContain("jest");
+expect({ foo: "bar" }).toHaveProperty("foo");
+expect({ foo: "bar" }).toHaveProperty("foo", "bar");
+expect("foo").toMatchSnapshot("snapshot name");
+expect({ foo: "bar" }).toMatchObject({ baz: "qux" });
+expect("foobar").toMatch(/foo/);
+expect("foobar").toMatch("foo");
+
+mockFn("a");
+expect("someVal").toBeCalled();
+expect("someVal").toBeCalledWith("a");
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect("someVal").toHaveBeeenCalledWith("a");
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test("test", () => expect("foo").toMatchSnapshot());
+test(AClass, () => expect("foo").toMatchSnapshot());
+test(aFunction, () => expect("foo").toMatchSnapshot());
+test.only("test", () => expect("foo").toMatchSnapshot());
+test.skip("test", () => expect("foo").toMatchSnapshot());
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[prop-missing] property `pass` not found in object literal
+    return {};
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.runTimersToTime(3000);
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+expect(wrapper).toBeChecked();
+
+expect(wrapper).toBeDisabled();
+
+expect(wrapper).toBeEmpty();
+
+expect(wrapper).toBeEmptyRender();
+
+expect(wrapper).toBePresent();
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toBeInTheDOM();
+
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  // $FlowExpectedError[incompatible-call]: expected attribute value should be a string
+  expect(element).toHaveAttribute('foo', 1);
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([['a', 'foo'], ['b', 'bar'], ['c', 'baz']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([['a', 'qux'], ['a', 'foo']]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
diff --git a/definitions/npm/jest_v23.x.x/flow_v0.134.x-/jest_v23.x.x.js b/definitions/npm/jest_v23.x.x/flow_v0.134.x-v.200.x/jest_v23.x.x.js
similarity index 100%
rename from definitions/npm/jest_v23.x.x/flow_v0.134.x-/jest_v23.x.x.js
rename to definitions/npm/jest_v23.x.x/flow_v0.134.x-v.200.x/jest_v23.x.x.js
diff --git a/definitions/npm/jest_v23.x.x/flow_v0.134.x-/test_jest-v23.x.x.js b/definitions/npm/jest_v23.x.x/flow_v0.134.x-v.200.x/test_jest-v23.x.x.js
similarity index 100%
rename from definitions/npm/jest_v23.x.x/flow_v0.134.x-/test_jest-v23.x.x.js
rename to definitions/npm/jest_v23.x.x/flow_v0.134.x-v.200.x/test_jest-v23.x.x.js
diff --git a/definitions/npm/jest_v23.x.x/flow_v0.201.x-/jest_v23.x.x.js b/definitions/npm/jest_v23.x.x/flow_v0.201.x-/jest_v23.x.x.js
new file mode 100644
index 0000000000..7836b7d9f1
--- /dev/null
+++ b/definitions/npm/jest_v23.x.x/flow_v0.201.x-/jest_v23.x.x.js
@@ -0,0 +1,1146 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  /**
+   * An array that contains all the object results that have been
+   * returned by this mock function call
+   */
+  results: Array<{
+   isThrow: boolean,
+   value: TReturn,
+   ...
+  }>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a string to use in test result output in place of "jest.fn()" to
+  * indicate which mock function is being referenced.
+  */
+ mockName(name: string): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Accepts a value that will be returned whenever the mock function is called.
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+  */
+ mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+  */
+ mockResolvedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+  */
+ mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+  */
+ mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (actual: any, expected: any) =>
+  | JestMatcherResult
+  | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+ media?: string,
+ modifier?: string,
+ supports?: string,
+ ...
+}
+
+type JestStyledComponentsMatchersType = { toHaveStyleRule(
+  property: string,
+  value: JestStyledComponentsMatcherValue,
+  options?: JestStyledComponentsMatcherOptions
+): void, ... };
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ // 5.x
+ toBeEmpty(): void,
+ toBePresent(): void,
+ // 6.x
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmptyRender(): void,
+ toContainMatchingElement(selector: string): void,
+ toContainMatchingElements(n: number, selector: string): void,
+ toContainExactlyOneMatchingElement(selector: string): void,
+ toContainReact(element: React$Element<any>): void,
+ toExist(): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp: ((propKey: string, propValue?: any) => void) &
+   ((props: {...}) => void),
+ toHaveRef(refName: string): void,
+ toHaveState: ((stateKey: string, stateValue?: any) => void) &
+   ((state: {...}) => void),
+ toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+   ((style: {...}) => void),
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toHaveValue(value: any): void,
+ toIncludeText(text: string): void,
+ toMatchElement(
+   element: React$Element<any>,
+   options?: {| ignoreProps?: boolean, verbose?: boolean |},
+ ): void,
+ toMatchSelector(selector: string): void,
+ // 7.x
+ toHaveDisplayName(name: string): void,
+ ...
+};
+
+// DOM testing library extensions https://github.com/kentcdodds/dom-testing-library#custom-jest-matchers
+type DomTestingLibraryType = {
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeInTheDocument(): void,
+ toBeVisible(): void,
+ toContainElement(element: HTMLElement | null): void,
+ toContainHTML(htmlText: string): void,
+ toHaveAttribute(name: string, expectedValue?: string): void,
+ toHaveClass(...classNames: string[]): void,
+ toHaveFocus(): void,
+ toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+ toHaveStyle(css: string): void,
+ toHaveTextContent(content: string | RegExp, options?: { normalizeWhitespace: boolean, ... }): void,
+ toBeInTheDOM(): void,
+ ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+ toExist(): void,
+ toHaveLength(len: number): void,
+ toHaveId(id: string): void,
+ toHaveClass(className: string): void,
+ toHaveTag(tag: string): void,
+ toHaveAttr(key: string, val?: any): void,
+ toHaveProp(key: string, val?: any): void,
+ toHaveText(text: string | RegExp): void,
+ toHaveData(key: string, val?: any): void,
+ toHaveValue(val: any): void,
+ toHaveCss(css: { [key: string]: any, ... }): void,
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeHidden(): void,
+ toBeSelected(): void,
+ toBeVisible(): void,
+ toBeFocused(): void,
+ toBeInDom(): void,
+ toBeMatchedBy(sel: string): void,
+ toHaveDescendant(sel: string): void,
+ toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+ ...
+};
+
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+ /**
+    * Note: Currently unimplemented
+    * Passing assertion
+    *
+    * @param {String} message
+    */
+ //  pass(message: string): void;
+
+ /**
+  * Note: Currently unimplemented
+  * Failing assertion
+  *
+  * @param {String} message
+  */
+ //  fail(message: string): void;
+
+ /**
+  * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+  */
+ toBeEmpty(): void,
+ /**
+  * Use .toBeOneOf when checking if a value is a member of a given Array.
+  * @param {Array.<*>} members
+  */
+ toBeOneOf(members: any[]): void,
+ /**
+  * Use `.toBeNil` when checking a value is `null` or `undefined`.
+  */
+ toBeNil(): void,
+ /**
+  * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+  * @param {Function} predicate
+  */
+ toSatisfy(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeArray` when checking if a value is an `Array`.
+  */
+ toBeArray(): void,
+ /**
+  * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+  * @param {Number} x
+  */
+ toBeArrayOfSize(x: number): void,
+ /**
+  * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAllMembers(members: any[]): void,
+ /**
+  * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAnyMembers(members: any[]): void,
+ /**
+  * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+  * @param {Function} predicate
+  */
+ toSatisfyAll(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+  */
+ toBeBoolean(): void,
+ /**
+  * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+  */
+ toBeTrue(): void,
+ /**
+  * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+  */
+ toBeFalse(): void,
+ /**
+  * Use .toBeDate when checking if a value is a Date.
+  */
+ toBeDate(): void,
+ /**
+  * Use `.toBeFunction` when checking if a value is a `Function`.
+  */
+ toBeFunction(): void,
+ /**
+  * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+  *
+  * Note: Required Jest version >22
+  * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+  *
+  * @param {Mock} mock
+  */
+ toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+ /**
+  * Use `.toBeNumber` when checking if a value is a `Number`.
+  */
+ toBeNumber(): void,
+ /**
+  * Use `.toBeNaN` when checking a value is `NaN`.
+  */
+ toBeNaN(): void,
+ /**
+  * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+  */
+ toBeFinite(): void,
+ /**
+  * Use `.toBePositive` when checking if a value is a positive `Number`.
+  */
+ toBePositive(): void,
+ /**
+  * Use `.toBeNegative` when checking if a value is a negative `Number`.
+  */
+ toBeNegative(): void,
+ /**
+  * Use `.toBeEven` when checking if a value is an even `Number`.
+  */
+ toBeEven(): void,
+ /**
+  * Use `.toBeOdd` when checking if a value is an odd `Number`.
+  */
+ toBeOdd(): void,
+ /**
+  * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+  *
+  * @param {Number} start
+  * @param {Number} end
+  */
+ toBeWithin(start: number, end: number): void,
+ /**
+  * Use `.toBeObject` when checking if a value is an `Object`.
+  */
+ toBeObject(): void,
+ /**
+  * Use `.toContainKey` when checking if an object contains the provided key.
+  *
+  * @param {String} key
+  */
+ toContainKey(key: string): void,
+ /**
+  * Use `.toContainKeys` when checking if an object has all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAllKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAnyKeys(keys: string[]): void,
+ /**
+  * Use `.toContainValue` when checking if an object contains the provided value.
+  *
+  * @param {*} value
+  */
+ toContainValue(value: any): void,
+ /**
+  * Use `.toContainValues` when checking if an object contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainValues(values: any[]): void,
+ /**
+  * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAllValues(values: any[]): void,
+ /**
+  * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAnyValues(values: any[]): void,
+ /**
+  * Use `.toContainEntry` when checking if an object contains the provided entry.
+  *
+  * @param {Array.<String, String>} entry
+  */
+ toContainEntry(entry: [string, string]): void,
+ /**
+  * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAllEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAnyEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toBeExtensible` when checking if an object is extensible.
+  */
+ toBeExtensible(): void,
+ /**
+  * Use `.toBeFrozen` when checking if an object is frozen.
+  */
+ toBeFrozen(): void,
+ /**
+  * Use `.toBeSealed` when checking if an object is sealed.
+  */
+ toBeSealed(): void,
+ /**
+  * Use `.toBeString` when checking if a value is a `String`.
+  */
+ toBeString(): void,
+ /**
+  * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+  *
+  * @param {String} string
+  */
+ toEqualCaseInsensitive(string: string): void,
+ /**
+  * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+  *
+  * @param {String} prefix
+  */
+ toStartWith(prefix: string): void,
+ /**
+  * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+  *
+  * @param {String} suffix
+  */
+ toEndWith(suffix: string): void,
+ /**
+  * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+  *
+  * @param {String} substring
+  */
+ toInclude(substring: string): void,
+ /**
+  * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+  *
+  * @param {String} substring
+  * @param {Number} times
+  */
+ toIncludeRepeated(substring: string, times: number): void,
+ /**
+  * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+  *
+  * @param {Array.<String>} substring
+  */
+ toIncludeMultiple(substring: string[]): void,
+ ...
+};
+
+interface JestExpectType {
+  not:
+    & JestExpectType
+    & EnzymeMatchersType
+    & DomTestingLibraryType
+    & JestJQueryMatchersType
+    & JestStyledComponentsMatchersType
+    & JestExtendedMatchersType,
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void,
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void,
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void,
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void,
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void,
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void,
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void,
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void,
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void,
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void,
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void,
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void,
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void,
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void,
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void,
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void,
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void,
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void,
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void,
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void,
+  toBeCalledWith(...args: Array<any>): void,
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void,
+  lastCalledWith(...args: Array<any>): void,
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void,
+  /**
+   *
+   */
+  toHaveProperty(propPath: string, value?: any): void,
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void,
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void,
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void,
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void,
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void,
+
+  toMatchInlineSnapshot(snapshot?: string): void,
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void,
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void,
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void,
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void,
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void,
+}
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Restores all mocks back to their original value.
+  */
+ restoreAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Returns the actual module instead of a mock, bypassing all checks on
+  * whether the module should receive a mock implementation or not.
+  */
+ requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+ /**
+  * Returns a mock module instead of the actual module, bypassing all checks
+  * on whether the module should be required normally or not.
+  */
+ requireMock(moduleName: string): any,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ advanceTimersByTime(msToRun: number): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  *
+  * Renamed to `advanceTimersByTime`.
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(object: Object, methodName: string, accessType?: "get" | "set"): JestMockFn<any, any>,
+ /**
+  * Set the default timeout interval for tests and before/after hooks in milliseconds.
+  * Note: The default timeout interval is 5 seconds if this method is not called.
+  */
+ setTimeout(timeout: number): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+ |};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: JestTestName, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: JestTestName, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: JestTestName, fn: () => void): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Only run this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only: {|
+   (
+     name: JestTestName,
+     fn?: (done: JestDoneFn) => ?Promise<mixed>,
+     timeout?: number
+   ): void,
+   each(
+     ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+   ): (
+     name: JestTestName,
+     fn?: (...args: Array<any>) => ?Promise<mixed>,
+     timeout?: number
+   ) => void
+ |},
+
+ /**
+  * Skip running this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(
+   name: JestTestName,
+   fn?: (done: () => void) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: () => void) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors,
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (value: any):
+   & JestExpectType
+   & JestPromiseType
+   & EnzymeMatchersType
+   & DomTestingLibraryType
+   & JestJQueryMatchersType
+   & JestStyledComponentsMatchersType
+   & JestExtendedMatchersType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ objectContaining(value: Object): Object,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): string,
+ stringMatching(value: string | RegExp): string,
+ not: {
+  arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+  objectContaining: (value: {...}) => Object,
+  stringContaining: (value: string) => string,
+  stringMatching: (value: string | RegExp) => string,
+  ...
+ },
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): Object,
+ stringMatching(value: string): string,
+ ...
+};
diff --git a/definitions/npm/jest_v23.x.x/flow_v0.201.x-/test_jest-v23.x.x.js b/definitions/npm/jest_v23.x.x/flow_v0.201.x-/test_jest-v23.x.x.js
new file mode 100644
index 0000000000..e592da28ee
--- /dev/null
+++ b/definitions/npm/jest_v23.x.x/flow_v0.201.x-/test_jest-v23.x.x.js
@@ -0,0 +1,706 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot({
+  foo: expect.any(Number),
+}, 'snapshot name');
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`,
+);
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1', 2, true], ['arg2', 3, false]])("test", () => expect("foo").toMatchSnapshot());
+describe.each(['arg1', 2, true])("test", () => expect("foo").toMatchSnapshot());
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test("test", () => expect("foo").toMatchSnapshot());
+test(AClass, () => expect("foo").toMatchSnapshot());
+test(aFunction, () => expect("foo").toMatchSnapshot());
+test.each([['arg1', 2, true], ['arg2', 3, false]])("test", () => expect("foo").toMatchSnapshot());
+test.each(['arg1', 2, true])("test", () => expect("foo").toMatchSnapshot());
+test.only.each([['arg1', 2, true], ['arg2', 3, false]])("test", () => expect("foo").toMatchSnapshot());
+test.only.each(['arg1', 2, true])("test", () => expect("foo").toMatchSnapshot());
+test.only("test", () => expect("foo").toMatchSnapshot());
+test.skip("test", () => expect("foo").toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual, expected) {
+    return Promise.resolve({
+      message: () => "blah fail",
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.runTimersToTime(3000);
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule(
+  'color', 'red', {
+    media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  // $FlowExpectedError[incompatible-call]: expected attribute value should be a string
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toBeInTheDOM();
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([['a', 'foo'], ['b', 'bar'], ['c', 'baz']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([['a', 'qux'], ['a', 'foo']]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`(
+  'x=$x, y=$y, and z=$z',
+  ({ x, y, z }) => {
+      // perform tests
+  }
+);
diff --git a/definitions/npm/jest_v24.x.x/flow_v0.134.x-/jest_v24.x.x.js b/definitions/npm/jest_v24.x.x/flow_v0.134.x-v.200.x/jest_v24.x.x.js
similarity index 100%
rename from definitions/npm/jest_v24.x.x/flow_v0.134.x-/jest_v24.x.x.js
rename to definitions/npm/jest_v24.x.x/flow_v0.134.x-v.200.x/jest_v24.x.x.js
diff --git a/definitions/npm/jest_v24.x.x/flow_v0.134.x-/test_jest-v24.x.x.js b/definitions/npm/jest_v24.x.x/flow_v0.134.x-v.200.x/test_jest-v24.x.x.js
similarity index 100%
rename from definitions/npm/jest_v24.x.x/flow_v0.134.x-/test_jest-v24.x.x.js
rename to definitions/npm/jest_v24.x.x/flow_v0.134.x-v.200.x/test_jest-v24.x.x.js
diff --git a/definitions/npm/jest_v24.x.x/flow_v0.201.x-/jest_v24.x.x.js b/definitions/npm/jest_v24.x.x/flow_v0.201.x-/jest_v24.x.x.js
new file mode 100644
index 0000000000..87efe46c8b
--- /dev/null
+++ b/definitions/npm/jest_v24.x.x/flow_v0.201.x-/jest_v24.x.x.js
@@ -0,0 +1,1203 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  /**
+   * An array that contains all the object results that have been
+   * returned by this mock function call
+   */
+  results: Array<{
+   isThrow: boolean,
+   value: TReturn,
+   ...
+  }>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a string to use in test result output in place of "jest.fn()" to
+  * indicate which mock function is being referenced.
+  */
+ mockName(name: string): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Accepts a value that will be returned whenever the mock function is called.
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+  */
+ mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+  */
+ mockResolvedValueOnce(
+   value: TReturn
+ ): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+  */
+ mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+  */
+ mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+ media?: string,
+ modifier?: string,
+ supports?: string,
+ ...
+};
+
+type JestStyledComponentsMatchersType = { toHaveStyleRule(
+  property: string,
+  value: JestStyledComponentsMatcherValue,
+  options?: JestStyledComponentsMatcherOptions
+): void, ... };
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ // 5.x
+ toBeEmpty(): void,
+ toBePresent(): void,
+ // 6.x
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmptyRender(): void,
+ toContainMatchingElement(selector: string): void,
+ toContainMatchingElements(n: number, selector: string): void,
+ toContainExactlyOneMatchingElement(selector: string): void,
+ toContainReact(element: React$Element<any>): void,
+ toExist(): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp: ((propKey: string, propValue?: any) => void) &
+   ((props: {...}) => void),
+ toHaveRef(refName: string): void,
+ toHaveState: ((stateKey: string, stateValue?: any) => void) &
+   ((state: {...}) => void),
+ toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+   ((style: {...}) => void),
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toHaveValue(value: any): void,
+ toIncludeText(text: string): void,
+ toMatchElement(
+   element: React$Element<any>,
+   options?: {| ignoreProps?: boolean, verbose?: boolean |}
+ ): void,
+ toMatchSelector(selector: string): void,
+ // 7.x
+ toHaveDisplayName(name: string): void,
+ ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+ /**
+  * @deprecated
+  */
+ toBeInTheDOM(container?: HTMLElement): void,
+ toBeInTheDocument(): void,
+ toBeVisible(): void,
+ toBeEmpty(): void,
+ toBeDisabled(): void,
+ toBeEnabled(): void,
+ toBeInvalid(): void,
+ toBeRequired(): void,
+ toBeValid(): void,
+ toContainElement(element: HTMLElement | null): void,
+ toContainHTML(htmlText: string): void,
+ toHaveAttribute(attr: string, value?: any): void,
+ toHaveClass(...classNames: string[]): void,
+ toHaveFocus(): void,
+ toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+ toHaveStyle(css: string): void,
+ toHaveTextContent(
+   text: string | RegExp,
+   options?: { normalizeWhitespace: boolean, ... }
+ ): void,
+ toHaveValue(value?: string | string[] | number): void,
+ ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+ toExist(): void,
+ toHaveLength(len: number): void,
+ toHaveId(id: string): void,
+ toHaveClass(className: string): void,
+ toHaveTag(tag: string): void,
+ toHaveAttr(key: string, val?: any): void,
+ toHaveProp(key: string, val?: any): void,
+ toHaveText(text: string | RegExp): void,
+ toHaveData(key: string, val?: any): void,
+ toHaveValue(val: any): void,
+ toHaveCss(css: { [key: string]: any, ... }): void,
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeHidden(): void,
+ toBeSelected(): void,
+ toBeVisible(): void,
+ toBeFocused(): void,
+ toBeInDom(): void,
+ toBeMatchedBy(sel: string): void,
+ toHaveDescendant(sel: string): void,
+ toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+ ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+ /**
+  * Note: Currently unimplemented
+  * Passing assertion
+  *
+  * @param {String} message
+  */
+ //  pass(message: string): void;
+
+ /**
+  * Note: Currently unimplemented
+  * Failing assertion
+  *
+  * @param {String} message
+  */
+ //  fail(message: string): void;
+
+ /**
+  * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+  */
+ toBeEmpty(): void,
+ /**
+  * Use .toBeOneOf when checking if a value is a member of a given Array.
+  * @param {Array.<*>} members
+  */
+ toBeOneOf(members: any[]): void,
+ /**
+  * Use `.toBeNil` when checking a value is `null` or `undefined`.
+  */
+ toBeNil(): void,
+ /**
+  * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+  * @param {Function} predicate
+  */
+ toSatisfy(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeArray` when checking if a value is an `Array`.
+  */
+ toBeArray(): void,
+ /**
+  * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+  * @param {Number} x
+  */
+ toBeArrayOfSize(x: number): void,
+ /**
+  * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAllMembers(members: any[]): void,
+ /**
+  * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAnyMembers(members: any[]): void,
+ /**
+  * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+  * @param {Function} predicate
+  */
+ toSatisfyAll(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+  */
+ toBeBoolean(): void,
+ /**
+  * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+  */
+ toBeTrue(): void,
+ /**
+  * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+  */
+ toBeFalse(): void,
+ /**
+  * Use .toBeDate when checking if a value is a Date.
+  */
+ toBeDate(): void,
+ /**
+  * Use `.toBeFunction` when checking if a value is a `Function`.
+  */
+ toBeFunction(): void,
+ /**
+  * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+  *
+  * Note: Required Jest version >22
+  * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+  *
+  * @param {Mock} mock
+  */
+ toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+ /**
+  * Use `.toBeNumber` when checking if a value is a `Number`.
+  */
+ toBeNumber(): void,
+ /**
+  * Use `.toBeNaN` when checking a value is `NaN`.
+  */
+ toBeNaN(): void,
+ /**
+  * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+  */
+ toBeFinite(): void,
+ /**
+  * Use `.toBePositive` when checking if a value is a positive `Number`.
+  */
+ toBePositive(): void,
+ /**
+  * Use `.toBeNegative` when checking if a value is a negative `Number`.
+  */
+ toBeNegative(): void,
+ /**
+  * Use `.toBeEven` when checking if a value is an even `Number`.
+  */
+ toBeEven(): void,
+ /**
+  * Use `.toBeOdd` when checking if a value is an odd `Number`.
+  */
+ toBeOdd(): void,
+ /**
+  * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+  *
+  * @param {Number} start
+  * @param {Number} end
+  */
+ toBeWithin(start: number, end: number): void,
+ /**
+  * Use `.toBeObject` when checking if a value is an `Object`.
+  */
+ toBeObject(): void,
+ /**
+  * Use `.toContainKey` when checking if an object contains the provided key.
+  *
+  * @param {String} key
+  */
+ toContainKey(key: string): void,
+ /**
+  * Use `.toContainKeys` when checking if an object has all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAllKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAnyKeys(keys: string[]): void,
+ /**
+  * Use `.toContainValue` when checking if an object contains the provided value.
+  *
+  * @param {*} value
+  */
+ toContainValue(value: any): void,
+ /**
+  * Use `.toContainValues` when checking if an object contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainValues(values: any[]): void,
+ /**
+  * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAllValues(values: any[]): void,
+ /**
+  * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAnyValues(values: any[]): void,
+ /**
+  * Use `.toContainEntry` when checking if an object contains the provided entry.
+  *
+  * @param {Array.<String, String>} entry
+  */
+ toContainEntry(entry: [string, string]): void,
+ /**
+  * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAllEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAnyEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toBeExtensible` when checking if an object is extensible.
+  */
+ toBeExtensible(): void,
+ /**
+  * Use `.toBeFrozen` when checking if an object is frozen.
+  */
+ toBeFrozen(): void,
+ /**
+  * Use `.toBeSealed` when checking if an object is sealed.
+  */
+ toBeSealed(): void,
+ /**
+  * Use `.toBeString` when checking if a value is a `String`.
+  */
+ toBeString(): void,
+ /**
+  * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+  *
+  * @param {String} string
+  */
+ toEqualCaseInsensitive(string: string): void,
+ /**
+  * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+  *
+  * @param {String} prefix
+  */
+ toStartWith(prefix: string): void,
+ /**
+  * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+  *
+  * @param {String} suffix
+  */
+ toEndWith(suffix: string): void,
+ /**
+  * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+  *
+  * @param {String} substring
+  */
+ toInclude(substring: string): void,
+ /**
+  * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+  *
+  * @param {String} substring
+  * @param {Number} times
+  */
+ toIncludeRepeated(substring: string, times: number): void,
+ /**
+  * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+  *
+  * @param {Array.<String>} substring
+  */
+ toIncludeMultiple(substring: string[]): void,
+ ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean;
+      colors?: boolean;
+      contextLines?: number;
+      stablePatchmarks?: boolean;
+      aAnnotation?: string;
+      bAnnotation?: string;
+    |},
+    testName?: string
+  ): void,
+  ...
+}
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Restores all mocks back to their original value.
+  */
+ restoreAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * Returns the number of fake timers still left to run.
+  */
+ getTimerCount(): number,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Returns the actual module instead of a mock, bypassing all checks on
+  * whether the module should receive a mock implementation or not.
+  */
+ requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+ /**
+  * Returns a mock module instead of the actual module, bypassing all checks
+  * on whether the module should be required normally or not.
+  */
+ requireMock(moduleName: string): any,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Creates a sandbox registry for the modules that are loaded inside the
+  * callback function. This is useful to isolate specific modules for every
+  * test so that local module state doesn't conflict between tests.
+  */
+ isolateModules(fn: () => void): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ advanceTimersByTime(msToRun: number): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  *
+  * Renamed to `advanceTimersByTime`.
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(
+   object: Object,
+   methodName: string,
+   accessType?: 'get' | 'set'
+ ): JestMockFn<any, any>,
+ /**
+  * Set the default timeout interval for tests and before/after hooks in milliseconds.
+  * Note: The default timeout interval is 5 seconds if this method is not called.
+  */
+ setTimeout(timeout: number): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+ (error?: Error): void,
+ fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: JestTestName, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: JestTestName, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: JestTestName, fn: () => void): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Only run this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only: {|
+   (
+     name: JestTestName,
+     fn?: (done: JestDoneFn) => ?Promise<mixed>,
+     timeout?: number
+   ): void,
+   each(
+     ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+   ): (
+     name: JestTestName,
+     fn?: (...args: Array<any>) => ?Promise<mixed>,
+     timeout?: number
+   ) => void
+ |},
+ /**
+  * Skip running this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Highlight planned tests in the summary output
+  *
+  * @param {String} Name of Test to do
+  */
+ todo(name: string): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (
+   value: any
+ ): JestExpectType &
+   JestPromiseType &
+   EnzymeMatchersType &
+   DomTestingLibraryType &
+   JestJQueryMatchersType &
+   JestStyledComponentsMatchersType &
+   JestExtendedMatchersType &
+   SnapshotDiffType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ objectContaining(value: Object): Object,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): string,
+ stringMatching(value: string | RegExp): string,
+ not: {
+  arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+  objectContaining: (value: {...}) => Object,
+  stringContaining: (value: string) => string,
+  stringMatching: (value: string | RegExp) => string,
+  ...
+ },
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): Object,
+ stringMatching(value: string): string,
+ ...
+};
diff --git a/definitions/npm/jest_v24.x.x/flow_v0.201.x-/test_jest-v24.x.x.js b/definitions/npm/jest_v24.x.x/flow_v0.201.x-/test_jest-v24.x.x.js
new file mode 100644
index 0000000000..90cd1e976e
--- /dev/null
+++ b/definitions/npm/jest_v24.x.x/flow_v0.201.x-/test_jest-v24.x.x.js
@@ -0,0 +1,754 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name')
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name')
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot('foobar', undefined, 'snapshot difference between two strings');
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) =>
+  expect(a).toMatchSnapshot()
+);
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([['arg1', 'arg2'], ['arg2', 'arg3']])('test', (a, b) =>
+  expect(a).toMatchDiffSnapshot(b)
+);
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([['arg1', 2, true], ['arg2', 3, false]])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([['arg1', 2, true], ['arg2', 3, false]])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done("foo");
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.runTimersToTime(3000);
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toBeInTheDOM();
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([['a', 'foo'], ['b', 'bar'], ['c', 'baz']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([['a', 'qux'], ['a', 'foo']]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`(
+  'x=$x, y=$y, and z=$z',
+  ({ x, y, z }) => {
+      // perform tests
+  }
+);
diff --git a/definitions/npm/jest_v25.x.x/flow_v0.134.x-/jest_v25.x.x.js b/definitions/npm/jest_v25.x.x/flow_v0.134.x-v.200.x/jest_v25.x.x.js
similarity index 100%
rename from definitions/npm/jest_v25.x.x/flow_v0.134.x-/jest_v25.x.x.js
rename to definitions/npm/jest_v25.x.x/flow_v0.134.x-v.200.x/jest_v25.x.x.js
diff --git a/definitions/npm/jest_v25.x.x/flow_v0.134.x-/test_jest-v25.x.x.js b/definitions/npm/jest_v25.x.x/flow_v0.134.x-v.200.x/test_jest-v25.x.x.js
similarity index 100%
rename from definitions/npm/jest_v25.x.x/flow_v0.134.x-/test_jest-v25.x.x.js
rename to definitions/npm/jest_v25.x.x/flow_v0.134.x-v.200.x/test_jest-v25.x.x.js
diff --git a/definitions/npm/jest_v25.x.x/flow_v0.201.x-/jest_v25.x.x.js b/definitions/npm/jest_v25.x.x/flow_v0.201.x-/jest_v25.x.x.js
new file mode 100644
index 0000000000..aa8bde3589
--- /dev/null
+++ b/definitions/npm/jest_v25.x.x/flow_v0.201.x-/jest_v25.x.x.js
@@ -0,0 +1,1209 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+ (...args: TArguments): TReturn,
+ /**
+  * An object for introspecting mock calls
+  */
+ mock: {
+  /**
+   * An array that represents all calls that have been made into this mock
+   * function. Each call is represented by an array of arguments that were
+   * passed during the call.
+   */
+  calls: Array<TArguments>,
+  /**
+   * An array that contains all the object instances that have been
+   * instantiated from this mock function.
+   */
+  instances: Array<TReturn>,
+  /**
+   * An array that contains all the object results that have been
+   * returned by this mock function call
+   */
+  results: Array<{
+   isThrow: boolean,
+   value: TReturn,
+   ...
+  }>,
+  ...
+ },
+ /**
+  * Resets all information stored in the mockFn.mock.calls and
+  * mockFn.mock.instances arrays. Often this is useful when you want to clean
+  * up a mock's usage data between two assertions.
+  */
+ mockClear(): void,
+ /**
+  * Resets all information stored in the mock. This is useful when you want to
+  * completely restore a mock back to its initial state.
+  */
+ mockReset(): void,
+ /**
+  * Removes the mock and restores the initial implementation. This is useful
+  * when you want to mock functions in certain test cases and restore the
+  * original implementation in others. Beware that mockFn.mockRestore only
+  * works when mock was created with jest.spyOn. Thus you have to take care of
+  * restoration yourself when manually assigning jest.fn().
+  */
+ mockRestore(): void,
+ /**
+  * Accepts a function that should be used as the implementation of the mock.
+  * The mock itself will still record all calls that go into and instances
+  * that come from itself -- the only difference is that the implementation
+  * will also be executed when the mock is called.
+  */
+ mockImplementation(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a function that will be used as an implementation of the mock for
+  * one call to the mocked function. Can be chained so that multiple function
+  * calls produce different results.
+  */
+ mockImplementationOnce(
+   fn: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Accepts a string to use in test result output in place of "jest.fn()" to
+  * indicate which mock function is being referenced.
+  */
+ mockName(name: string): JestMockFn<TArguments, TReturn>,
+ /**
+  * Just a simple sugar function for returning `this`
+  */
+ mockReturnThis(): void,
+ /**
+  * Accepts a value that will be returned whenever the mock function is called.
+  */
+ mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for only returning a value once inside your mock
+  */
+ mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+  */
+ mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+  */
+ mockResolvedValueOnce(
+   value: TReturn
+ ): JestMockFn<TArguments, Promise<TReturn>>,
+ /**
+  * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+  */
+ mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ /**
+  * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+  */
+ mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+ ...
+};
+
+type JestAsymmetricEqualityType = { /**
+ * A custom Jasmine equality tester
+ */
+asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+ allArgs(): mixed,
+ all(): mixed,
+ any(): boolean,
+ count(): number,
+ first(): mixed,
+ mostRecent(): mixed,
+ reset(): void,
+ ...
+};
+
+type JestClockType = {
+ install(): void,
+ mockDate(date: Date): void,
+ tick(milliseconds?: number): void,
+ uninstall(): void,
+ ...
+};
+
+type JestMatcherResult = {
+ message?: string | (() => string),
+ pass: boolean,
+ ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+ /**
+  * Use rejects to unwrap the reason of a rejected promise so any other
+  * matcher can be chained. If the promise is fulfilled the assertion fails.
+  */
+ rejects: JestExpectType,
+ /**
+  * Use resolves to unwrap the value of a fulfilled promise so any other
+  * matcher can be chained. If the promise is rejected the assertion fails.
+  */
+ resolves: JestExpectType,
+ ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+ media?: string,
+ modifier?: string,
+ supports?: string,
+ ...
+};
+
+type JestStyledComponentsMatchersType = { toHaveStyleRule(
+  property: string,
+  value: JestStyledComponentsMatcherValue,
+  options?: JestStyledComponentsMatcherOptions
+): void, ... };
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+ // 5.x
+ toBeEmpty(): void,
+ toBePresent(): void,
+ // 6.x
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmptyRender(): void,
+ toContainMatchingElement(selector: string): void,
+ toContainMatchingElements(n: number, selector: string): void,
+ toContainExactlyOneMatchingElement(selector: string): void,
+ toContainReact(element: React$Element<any>): void,
+ toExist(): void,
+ toHaveClassName(className: string): void,
+ toHaveHTML(html: string): void,
+ toHaveProp: ((propKey: string, propValue?: any) => void) &
+   ((props: {...}) => void),
+ toHaveRef(refName: string): void,
+ toHaveState: ((stateKey: string, stateValue?: any) => void) &
+   ((state: {...}) => void),
+ toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+   ((style: {...}) => void),
+ toHaveTagName(tagName: string): void,
+ toHaveText(text: string): void,
+ toHaveValue(value: any): void,
+ toIncludeText(text: string): void,
+ toMatchElement(
+   element: React$Element<any>,
+   options?: {| ignoreProps?: boolean, verbose?: boolean |}
+ ): void,
+ toMatchSelector(selector: string): void,
+ // 7.x
+ toHaveDisplayName(name: string): void,
+ ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+ /**
+  * @deprecated
+  */
+ toBeInTheDOM(container?: HTMLElement): void,
+
+ // 4.x
+ toBeInTheDocument(): void,
+ toBeVisible(): void,
+ toBeEmpty(): void,
+ toBeDisabled(): void,
+ toBeEnabled(): void,
+ toBeInvalid(): void,
+ toBeRequired(): void,
+ toBeValid(): void,
+ toContainElement(element: HTMLElement | null): void,
+ toContainHTML(htmlText: string): void,
+ toHaveAttribute(attr: string, value?: any): void,
+ toHaveClass(...classNames: string[]): void,
+ toHaveFocus(): void,
+ toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+ toHaveStyle(css: string | { [name: string]: any, ... }): void,
+ toHaveTextContent(
+   text: string | RegExp,
+   options?: {| normalizeWhitespace: boolean |}
+ ): void,
+ toHaveValue(value?: string | string[] | number): void,
+
+ // 5.x
+ toHaveDisplayValue(value: string | string[]): void,
+ toBeChecked(): void,
+ ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+ toExist(): void,
+ toHaveLength(len: number): void,
+ toHaveId(id: string): void,
+ toHaveClass(className: string): void,
+ toHaveTag(tag: string): void,
+ toHaveAttr(key: string, val?: any): void,
+ toHaveProp(key: string, val?: any): void,
+ toHaveText(text: string | RegExp): void,
+ toHaveData(key: string, val?: any): void,
+ toHaveValue(val: any): void,
+ toHaveCss(css: { [key: string]: any, ... }): void,
+ toBeChecked(): void,
+ toBeDisabled(): void,
+ toBeEmpty(): void,
+ toBeHidden(): void,
+ toBeSelected(): void,
+ toBeVisible(): void,
+ toBeFocused(): void,
+ toBeInDom(): void,
+ toBeMatchedBy(sel: string): void,
+ toHaveDescendant(sel: string): void,
+ toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+ ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+ /**
+  * Note: Currently unimplemented
+  * Passing assertion
+  *
+  * @param {String} message
+  */
+ //  pass(message: string): void;
+
+ /**
+  * Note: Currently unimplemented
+  * Failing assertion
+  *
+  * @param {String} message
+  */
+ //  fail(message: string): void;
+
+ /**
+  * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+  */
+ toBeEmpty(): void,
+ /**
+  * Use .toBeOneOf when checking if a value is a member of a given Array.
+  * @param {Array.<*>} members
+  */
+ toBeOneOf(members: any[]): void,
+ /**
+  * Use `.toBeNil` when checking a value is `null` or `undefined`.
+  */
+ toBeNil(): void,
+ /**
+  * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+  * @param {Function} predicate
+  */
+ toSatisfy(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeArray` when checking if a value is an `Array`.
+  */
+ toBeArray(): void,
+ /**
+  * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+  * @param {Number} x
+  */
+ toBeArrayOfSize(x: number): void,
+ /**
+  * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAllMembers(members: any[]): void,
+ /**
+  * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+  * @param {Array.<*>} members
+  */
+ toIncludeAnyMembers(members: any[]): void,
+ /**
+  * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+  * @param {Function} predicate
+  */
+ toSatisfyAll(predicate: (n: any) => boolean): void,
+ /**
+  * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+  */
+ toBeBoolean(): void,
+ /**
+  * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+  */
+ toBeTrue(): void,
+ /**
+  * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+  */
+ toBeFalse(): void,
+ /**
+  * Use .toBeDate when checking if a value is a Date.
+  */
+ toBeDate(): void,
+ /**
+  * Use `.toBeFunction` when checking if a value is a `Function`.
+  */
+ toBeFunction(): void,
+ /**
+  * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+  *
+  * Note: Required Jest version >22
+  * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+  *
+  * @param {Mock} mock
+  */
+ toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+ /**
+  * Use `.toBeNumber` when checking if a value is a `Number`.
+  */
+ toBeNumber(): void,
+ /**
+  * Use `.toBeNaN` when checking a value is `NaN`.
+  */
+ toBeNaN(): void,
+ /**
+  * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+  */
+ toBeFinite(): void,
+ /**
+  * Use `.toBePositive` when checking if a value is a positive `Number`.
+  */
+ toBePositive(): void,
+ /**
+  * Use `.toBeNegative` when checking if a value is a negative `Number`.
+  */
+ toBeNegative(): void,
+ /**
+  * Use `.toBeEven` when checking if a value is an even `Number`.
+  */
+ toBeEven(): void,
+ /**
+  * Use `.toBeOdd` when checking if a value is an odd `Number`.
+  */
+ toBeOdd(): void,
+ /**
+  * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+  *
+  * @param {Number} start
+  * @param {Number} end
+  */
+ toBeWithin(start: number, end: number): void,
+ /**
+  * Use `.toBeObject` when checking if a value is an `Object`.
+  */
+ toBeObject(): void,
+ /**
+  * Use `.toContainKey` when checking if an object contains the provided key.
+  *
+  * @param {String} key
+  */
+ toContainKey(key: string): void,
+ /**
+  * Use `.toContainKeys` when checking if an object has all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAllKeys(keys: string[]): void,
+ /**
+  * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+  *
+  * @param {Array.<String>} keys
+  */
+ toContainAnyKeys(keys: string[]): void,
+ /**
+  * Use `.toContainValue` when checking if an object contains the provided value.
+  *
+  * @param {*} value
+  */
+ toContainValue(value: any): void,
+ /**
+  * Use `.toContainValues` when checking if an object contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainValues(values: any[]): void,
+ /**
+  * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAllValues(values: any[]): void,
+ /**
+  * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+  *
+  * @param {Array.<*>} values
+  */
+ toContainAnyValues(values: any[]): void,
+ /**
+  * Use `.toContainEntry` when checking if an object contains the provided entry.
+  *
+  * @param {Array.<String, String>} entry
+  */
+ toContainEntry(entry: [string, string]): void,
+ /**
+  * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAllEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+  *
+  * @param {Array.<Array.<String, String>>} entries
+  */
+ toContainAnyEntries(entries: [string, string][]): void,
+ /**
+  * Use `.toBeExtensible` when checking if an object is extensible.
+  */
+ toBeExtensible(): void,
+ /**
+  * Use `.toBeFrozen` when checking if an object is frozen.
+  */
+ toBeFrozen(): void,
+ /**
+  * Use `.toBeSealed` when checking if an object is sealed.
+  */
+ toBeSealed(): void,
+ /**
+  * Use `.toBeString` when checking if a value is a `String`.
+  */
+ toBeString(): void,
+ /**
+  * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+  *
+  * @param {String} string
+  */
+ toEqualCaseInsensitive(string: string): void,
+ /**
+  * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+  *
+  * @param {String} prefix
+  */
+ toStartWith(prefix: string): void,
+ /**
+  * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+  *
+  * @param {String} suffix
+  */
+ toEndWith(suffix: string): void,
+ /**
+  * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+  *
+  * @param {String} substring
+  */
+ toInclude(substring: string): void,
+ /**
+  * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+  *
+  * @param {String} substring
+  * @param {Number} times
+  */
+ toIncludeRepeated(substring: string, times: number): void,
+ /**
+  * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+  *
+  * @param {Array.<String>} substring
+  */
+ toIncludeMultiple(substring: string[]): void,
+ ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean;
+      colors?: boolean;
+      contextLines?: number;
+      stablePatchmarks?: boolean;
+      aAnnotation?: string;
+      bAnnotation?: string;
+    |},
+    testName?: string
+  ): void,
+  ...
+}
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+ /**
+  *  Disables automatic mocking in the module loader.
+  *
+  *  After this method is called, all `require()`s will return the real
+  *  versions of each module (rather than a mocked version).
+  */
+ disableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of disableAutomock
+  */
+ autoMockOff(): JestObjectType,
+ /**
+  * Enables automatic mocking in the module loader.
+  */
+ enableAutomock(): JestObjectType,
+ /**
+  * An un-hoisted version of enableAutomock
+  */
+ autoMockOn(): JestObjectType,
+ /**
+  * Clears the mock.calls and mock.instances properties of all mocks.
+  * Equivalent to calling .mockClear() on every mocked function.
+  */
+ clearAllMocks(): JestObjectType,
+ /**
+  * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+  * mocked function.
+  */
+ resetAllMocks(): JestObjectType,
+ /**
+  * Restores all mocks back to their original value.
+  */
+ restoreAllMocks(): JestObjectType,
+ /**
+  * Removes any pending timers from the timer system.
+  */
+ clearAllTimers(): void,
+ /**
+  * Returns the number of fake timers still left to run.
+  */
+ getTimerCount(): number,
+ /**
+  * The same as `mock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+ /**
+  * The same as `unmock` but not moved to the top of the expectation by
+  * babel-jest.
+  */
+ dontMock(moduleName: string): JestObjectType,
+ /**
+  * Returns a new, unused mock function. Optionally takes a mock
+  * implementation.
+  */
+ fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+   implementation?: (...args: TArguments) => TReturn
+ ): JestMockFn<TArguments, TReturn>,
+ /**
+  * Determines if the given function is a mocked function.
+  */
+ isMockFunction(fn: Function): boolean,
+ /**
+  * Given the name of a module, use the automatic mocking system to generate a
+  * mocked version of the module for you.
+  */
+ genMockFromModule(moduleName: string): any,
+ /**
+  * Mocks a module with an auto-mocked version when it is being required.
+  *
+  * The second argument can be used to specify an explicit module factory that
+  * is being run instead of using Jest's automocking feature.
+  *
+  * The third argument can be used to create virtual mocks -- mocks of modules
+  * that don't exist anywhere in the system.
+  */
+ mock(
+   moduleName: string,
+   moduleFactory?: any,
+   options?: Object
+ ): JestObjectType,
+ /**
+  * Returns the actual module instead of a mock, bypassing all checks on
+  * whether the module should receive a mock implementation or not.
+  */
+ requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+ /**
+  * Returns a mock module instead of the actual module, bypassing all checks
+  * on whether the module should be required normally or not.
+  */
+ requireMock(moduleName: string): any,
+ /**
+  * Resets the module registry - the cache of all required modules. This is
+  * useful to isolate modules where local state might conflict between tests.
+  */
+ resetModules(): JestObjectType,
+ /**
+  * Creates a sandbox registry for the modules that are loaded inside the
+  * callback function. This is useful to isolate specific modules for every
+  * test so that local module state doesn't conflict between tests.
+  */
+ isolateModules(fn: () => void): JestObjectType,
+ /**
+  * Exhausts the micro-task queue (usually interfaced in node via
+  * process.nextTick).
+  */
+ runAllTicks(): void,
+ /**
+  * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+  * setInterval(), and setImmediate()).
+  */
+ runAllTimers(): void,
+ /**
+  * Exhausts all tasks queued by setImmediate().
+  */
+ runAllImmediates(): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  */
+ advanceTimersByTime(msToRun: number): void,
+ /**
+  * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+  * or setInterval() and setImmediate()).
+  *
+  * Renamed to `advanceTimersByTime`.
+  */
+ runTimersToTime(msToRun: number): void,
+ /**
+  * Executes only the macro-tasks that are currently pending (i.e., only the
+  * tasks that have been queued by setTimeout() or setInterval() up to this
+  * point)
+  */
+ runOnlyPendingTimers(): void,
+ /**
+  * Explicitly supplies the mock object that the module system should return
+  * for the specified module. Note: It is recommended to use jest.mock()
+  * instead.
+  */
+ setMock(moduleName: string, moduleExports: any): JestObjectType,
+ /**
+  * Indicates that the module system should never return a mocked version of
+  * the specified module from require() (e.g. that it should always return the
+  * real module).
+  */
+ unmock(moduleName: string): JestObjectType,
+ /**
+  * Instructs Jest to use fake versions of the standard timer functions
+  * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+  * setImmediate and clearImmediate).
+  */
+ useFakeTimers(): JestObjectType,
+ /**
+  * Instructs Jest to use the real versions of the standard timer functions.
+  */
+ useRealTimers(): JestObjectType,
+ /**
+  * Creates a mock function similar to jest.fn but also tracks calls to
+  * object[methodName].
+  */
+ spyOn(
+   object: Object,
+   methodName: string,
+   accessType?: 'get' | 'set'
+ ): JestMockFn<any, any>,
+ /**
+  * Set the default timeout interval for tests and before/after hooks in milliseconds.
+  * Note: The default timeout interval is 5 seconds if this method is not called.
+  */
+ setTimeout(timeout: number): JestObjectType,
+ ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+ /**
+  * Creates a block that groups together several related tests in one "test suite"
+  */
+ (name: JestTestName, fn: () => void): void,
+ /**
+  * Only run this describe block
+  */
+ only(name: JestTestName, fn: () => void): void,
+ /**
+  * Skip running this describe block
+  */
+ skip(name: JestTestName, fn: () => void): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+/** An individual test unit */
+declare var it: {
+ /**
+  * An individual test unit
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ (
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Only run this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ only: {|
+   (
+     name: JestTestName,
+     fn?: (done: JestDoneFn) => ?Promise<mixed>,
+     timeout?: number
+   ): void,
+   each(
+     ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+   ): (
+     name: JestTestName,
+     fn?: (...args: Array<any>) => ?Promise<mixed>,
+     timeout?: number
+   ) => void
+ |},
+ /**
+  * Skip running this test
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ skip(
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * Highlight planned tests in the summary output
+  *
+  * @param {String} Name of Test to do
+  */
+ todo(name: string): void,
+ /**
+  * Run the test concurrently
+  *
+  * @param {JestTestName} Name of Test
+  * @param {Function} Test
+  * @param {number} Timeout for the test, in milliseconds.
+  */
+ concurrent(
+   name: JestTestName,
+   fn?: (done: JestDoneFn) => ?Promise<mixed>,
+   timeout?: number
+ ): void,
+ /**
+  * each runs this test against array of argument arrays per each run
+  *
+  * @param {table} table of Test
+  */
+ each(
+   ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+ ): (
+   name: JestTestName,
+   fn?: (...args: Array<any>) => ?Promise<mixed>,
+   timeout?: number
+ ) => void,
+ ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+ comment: {
+  close: string,
+  open: string,
+  ...
+ },
+ content: {
+  close: string,
+  open: string,
+  ...
+ },
+ prop: {
+  close: string,
+  open: string,
+  ...
+ },
+ tag: {
+  close: string,
+  open: string,
+  ...
+ },
+ value: {
+  close: string,
+  open: string,
+  ...
+ },
+ ...
+};
+
+type JestPrettyFormatIndent = string => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = any => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+ print: (
+   val: any,
+   serialize: JestPrettyFormatPrint,
+   indent: JestPrettyFormatIndent,
+   opts: JestPrettyFormatOptions,
+   colors: JestPrettyFormatColors
+ ) => string,
+ test: any => boolean,
+ ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+ /** The object that you want to make assertions against */
+ (
+   value: any
+ ): JestExpectType &
+   JestPromiseType &
+   EnzymeMatchersType &
+   DomTestingLibraryType &
+   JestJQueryMatchersType &
+   JestStyledComponentsMatchersType &
+   JestExtendedMatchersType &
+   SnapshotDiffType,
+ /** Add additional Jasmine matchers to Jest's roster */
+ extend(matchers: { [name: string]: JestMatcher, ... }): void,
+ /** Add a module that formats application-specific data structures. */
+ addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+ assertions(expectedAssertions: number): void,
+ hasAssertions(): void,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ objectContaining(value: Object): Object,
+ /** Matches any received string that contains the exact expected string. */
+ stringContaining(value: string): string,
+ stringMatching(value: string | RegExp): string,
+ not: {
+  arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+  objectContaining: (value: {...}) => Object,
+  stringContaining: (value: string) => string,
+  stringMatching: (value: string | RegExp) => string,
+  ...
+ },
+ ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+ DEFAULT_TIMEOUT_INTERVAL: number,
+ any(value: mixed): JestAsymmetricEqualityType,
+ anything(): any,
+ arrayContaining(value: Array<mixed>): Array<mixed>,
+ clock(): JestClockType,
+ createSpy(name: string): JestSpyType,
+ createSpyObj(
+   baseName: string,
+   methodNames: Array<string>
+ ): { [methodName: string]: JestSpyType, ... },
+ objectContaining(value: Object): Object,
+ stringMatching(value: string): string,
+ ...
+};
diff --git a/definitions/npm/jest_v25.x.x/flow_v0.201.x-/test_jest-v25.x.x.js b/definitions/npm/jest_v25.x.x/flow_v0.201.x-/test_jest-v25.x.x.js
new file mode 100644
index 0000000000..9dc4735b0d
--- /dev/null
+++ b/definitions/npm/jest_v25.x.x/flow_v0.201.x-/test_jest-v25.x.x.js
@@ -0,0 +1,760 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name')
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name')
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot('foobar', undefined, 'snapshot difference between two strings');
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) =>
+  expect(a).toMatchSnapshot()
+);
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([['arg1', 'arg2'], ['arg2', 'arg3']])('test', (a, b) =>
+  expect(a).toMatchDiffSnapshot(b)
+);
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([['arg1', 2, true], ['arg2', 3, false]])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([['arg1', 2, true], ['arg2', 3, false]])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done("foo");
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.runTimersToTime(3000);
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  // Deprecated
+  expect(element).toBeInTheDOM();
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  expect(element).toHaveStyle('color: blue');
+  expect(element).toHaveStyle({ color: 'blue' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+  expect(element).toHaveDisplayValue('test');
+  expect(element).toHaveDisplayValue(['foo', 'bar']);
+  expect(element).toBeChecked();
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([['a', 'foo'], ['b', 'bar'], ['c', 'baz']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([['a', 'qux'], ['a', 'foo']]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`(
+  'x=$x, y=$y, and z=$z',
+  ({ x, y, z }) => {
+      // perform tests
+  }
+);
diff --git a/definitions/npm/jest_v26.x.x/flow_v0.134.x-/jest_v26.x.x.js b/definitions/npm/jest_v26.x.x/flow_v0.134.x-v.200.x/jest_v26.x.x.js
similarity index 100%
rename from definitions/npm/jest_v26.x.x/flow_v0.134.x-/jest_v26.x.x.js
rename to definitions/npm/jest_v26.x.x/flow_v0.134.x-v.200.x/jest_v26.x.x.js
diff --git a/definitions/npm/jest_v26.x.x/flow_v0.134.x-/test_jest-v26.x.x.js b/definitions/npm/jest_v26.x.x/flow_v0.134.x-v.200.x/test_jest-v26.x.x.js
similarity index 100%
rename from definitions/npm/jest_v26.x.x/flow_v0.134.x-/test_jest-v26.x.x.js
rename to definitions/npm/jest_v26.x.x/flow_v0.134.x-v.200.x/test_jest-v26.x.x.js
diff --git a/definitions/npm/jest_v26.x.x/flow_v0.201.x-/jest_v26.x.x.js b/definitions/npm/jest_v26.x.x/flow_v0.201.x-/jest_v26.x.x.js
new file mode 100644
index 0000000000..ab84555b58
--- /dev/null
+++ b/definitions/npm/jest_v26.x.x/flow_v0.201.x-/jest_v26.x.x.js
@@ -0,0 +1,1239 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+  (...args: TArguments): TReturn,
+  /**
+   * An object for introspecting mock calls
+   */
+  mock: {
+    /**
+     * An array that represents all calls that have been made into this mock
+     * function. Each call is represented by an array of arguments that were
+     * passed during the call.
+     */
+    calls: Array<TArguments>,
+    /**
+     * An array that contains all the object instances that have been
+     * instantiated from this mock function.
+     */
+    instances: Array<TReturn>,
+    /**
+     * An array that contains all the object results that have been
+     * returned by this mock function call
+     */
+    results: Array<{
+      isThrow: boolean,
+      value: TReturn,
+      ...
+    }>,
+    ...
+  },
+  /**
+   * Resets all information stored in the mockFn.mock.calls and
+   * mockFn.mock.instances arrays. Often this is useful when you want to clean
+   * up a mock's usage data between two assertions.
+   */
+  mockClear(): void,
+  /**
+   * Resets all information stored in the mock. This is useful when you want to
+   * completely restore a mock back to its initial state.
+   */
+  mockReset(): void,
+  /**
+   * Removes the mock and restores the initial implementation. This is useful
+   * when you want to mock functions in certain test cases and restore the
+   * original implementation in others. Beware that mockFn.mockRestore only
+   * works when mock was created with jest.spyOn. Thus you have to take care of
+   * restoration yourself when manually assigning jest.fn().
+   */
+  mockRestore(): void,
+  /**
+   * Accepts a function that should be used as the implementation of the mock.
+   * The mock itself will still record all calls that go into and instances
+   * that come from itself -- the only difference is that the implementation
+   * will also be executed when the mock is called.
+   */
+  mockImplementation(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a function that will be used as an implementation of the mock for
+   * one call to the mocked function. Can be chained so that multiple function
+   * calls produce different results.
+   */
+  mockImplementationOnce(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a string to use in test result output in place of "jest.fn()" to
+   * indicate which mock function is being referenced.
+   */
+  mockName(name: string): JestMockFn<TArguments, TReturn>,
+  /**
+   * Just a simple sugar function for returning `this`
+   */
+  mockReturnThis(): void,
+  /**
+   * Accepts a value that will be returned whenever the mock function is called.
+   */
+  mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for only returning a value once inside your mock
+   */
+  mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+   */
+  mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+   */
+  mockResolvedValueOnce(
+    value: TReturn
+  ): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+   */
+  mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+   */
+  mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  ...
+};
+
+type JestAsymmetricEqualityType = {
+  /**
+   * A custom Jasmine equality tester
+   */
+  asymmetricMatch(value: mixed): boolean,
+  ...
+};
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestMatcherResult = {
+  message?: string | (() => string),
+  pass: boolean,
+  ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+  /**
+   * Use rejects to unwrap the reason of a rejected promise so any other
+   * matcher can be chained. If the promise is fulfilled the assertion fails.
+   */
+  rejects: JestExpectType,
+  /**
+   * Use resolves to unwrap the value of a fulfilled promise so any other
+   * matcher can be chained. If the promise is rejected the assertion fails.
+   */
+  resolves: JestExpectType,
+  ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+  media?: string,
+  modifier?: string,
+  supports?: string,
+  ...
+};
+
+type JestStyledComponentsMatchersType = {
+  toHaveStyleRule(
+    property: string,
+    value: JestStyledComponentsMatcherValue,
+    options?: JestStyledComponentsMatcherOptions
+  ): void,
+  ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+  // 5.x
+  toBeEmpty(): void,
+  toBePresent(): void,
+  // 6.x
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmptyRender(): void,
+  toContainMatchingElement(selector: string): void,
+  toContainMatchingElements(n: number, selector: string): void,
+  toContainExactlyOneMatchingElement(selector: string): void,
+  toContainReact(element: React$Element<any>): void,
+  toExist(): void,
+  toHaveClassName(className: string): void,
+  toHaveHTML(html: string): void,
+  toHaveProp: ((propKey: string, propValue?: any) => void) &
+    ((props: { ... }) => void),
+  toHaveRef(refName: string): void,
+  toHaveState: ((stateKey: string, stateValue?: any) => void) &
+    ((state: { ... }) => void),
+  toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+    ((style: { ... }) => void),
+  toHaveTagName(tagName: string): void,
+  toHaveText(text: string): void,
+  toHaveValue(value: any): void,
+  toIncludeText(text: string): void,
+  toMatchElement(
+    element: React$Element<any>,
+    options?: {| ignoreProps?: boolean, verbose?: boolean |}
+  ): void,
+  toMatchSelector(selector: string): void,
+  // 7.x
+  toHaveDisplayName(name: string): void,
+  ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+  /**
+   * @deprecated
+   */
+  toBeInTheDOM(container?: HTMLElement): void,
+
+  // 4.x
+  toBeInTheDocument(): void,
+  toBeVisible(): void,
+  toBeEmpty(): void,
+  toBeDisabled(): void,
+  toBeEnabled(): void,
+  toBeInvalid(): void,
+  toBeRequired(): void,
+  toBeValid(): void,
+  toContainElement(element: HTMLElement | null): void,
+  toContainHTML(htmlText: string): void,
+  toHaveAttribute(attr: string, value?: any): void,
+  toHaveClass(...classNames: string[]): void,
+  toHaveFocus(): void,
+  toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+  toHaveStyle(css: string | { [name: string]: any, ... }): void,
+  toHaveTextContent(
+    text: string | RegExp,
+    options?: {| normalizeWhitespace: boolean |}
+  ): void,
+  toHaveValue(value?: string | string[] | number): void,
+
+  // 5.x
+  toHaveDisplayValue(value: string | string[]): void,
+  toBeChecked(): void,
+  toBeEmptyDOMElement(): void,
+  toBePartiallyChecked(): void,
+  toHaveDescription(text: string | RegExp): void,
+  ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+  toExist(): void,
+  toHaveLength(len: number): void,
+  toHaveId(id: string): void,
+  toHaveClass(className: string): void,
+  toHaveTag(tag: string): void,
+  toHaveAttr(key: string, val?: any): void,
+  toHaveProp(key: string, val?: any): void,
+  toHaveText(text: string | RegExp): void,
+  toHaveData(key: string, val?: any): void,
+  toHaveValue(val: any): void,
+  toHaveCss(css: { [key: string]: any, ... }): void,
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmpty(): void,
+  toBeHidden(): void,
+  toBeSelected(): void,
+  toBeVisible(): void,
+  toBeFocused(): void,
+  toBeInDom(): void,
+  toBeMatchedBy(sel: string): void,
+  toHaveDescendant(sel: string): void,
+  toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+  ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+  /**
+   * Note: Currently unimplemented
+   * Passing assertion
+   *
+   * @param {String} message
+   */
+  //  pass(message: string): void;
+
+  /**
+   * Note: Currently unimplemented
+   * Failing assertion
+   *
+   * @param {String} message
+   */
+  //  fail(message: string): void;
+
+  /**
+   * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+   */
+  toBeEmpty(): void,
+  /**
+   * Use .toBeOneOf when checking if a value is a member of a given Array.
+   * @param {Array.<*>} members
+   */
+  toBeOneOf(members: any[]): void,
+  /**
+   * Use `.toBeNil` when checking a value is `null` or `undefined`.
+   */
+  toBeNil(): void,
+  /**
+   * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+   * @param {Function} predicate
+   */
+  toSatisfy(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeArray` when checking if a value is an `Array`.
+   */
+  toBeArray(): void,
+  /**
+   * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+   * @param {Number} x
+   */
+  toBeArrayOfSize(x: number): void,
+  /**
+   * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAllMembers(members: any[]): void,
+  /**
+   * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAnyMembers(members: any[]): void,
+  /**
+   * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+   * @param {Function} predicate
+   */
+  toSatisfyAll(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+   */
+  toBeBoolean(): void,
+  /**
+   * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+   */
+  toBeTrue(): void,
+  /**
+   * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+   */
+  toBeFalse(): void,
+  /**
+   * Use .toBeDate when checking if a value is a Date.
+   */
+  toBeDate(): void,
+  /**
+   * Use `.toBeFunction` when checking if a value is a `Function`.
+   */
+  toBeFunction(): void,
+  /**
+   * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+   *
+   * Note: Required Jest version >22
+   * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+   *
+   * @param {Mock} mock
+   */
+  toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+  /**
+   * Use `.toBeNumber` when checking if a value is a `Number`.
+   */
+  toBeNumber(): void,
+  /**
+   * Use `.toBeNaN` when checking a value is `NaN`.
+   */
+  toBeNaN(): void,
+  /**
+   * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+   */
+  toBeFinite(): void,
+  /**
+   * Use `.toBePositive` when checking if a value is a positive `Number`.
+   */
+  toBePositive(): void,
+  /**
+   * Use `.toBeNegative` when checking if a value is a negative `Number`.
+   */
+  toBeNegative(): void,
+  /**
+   * Use `.toBeEven` when checking if a value is an even `Number`.
+   */
+  toBeEven(): void,
+  /**
+   * Use `.toBeOdd` when checking if a value is an odd `Number`.
+   */
+  toBeOdd(): void,
+  /**
+   * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+   *
+   * @param {Number} start
+   * @param {Number} end
+   */
+  toBeWithin(start: number, end: number): void,
+  /**
+   * Use `.toBeObject` when checking if a value is an `Object`.
+   */
+  toBeObject(): void,
+  /**
+   * Use `.toContainKey` when checking if an object contains the provided key.
+   *
+   * @param {String} key
+   */
+  toContainKey(key: string): void,
+  /**
+   * Use `.toContainKeys` when checking if an object has all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAllKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAnyKeys(keys: string[]): void,
+  /**
+   * Use `.toContainValue` when checking if an object contains the provided value.
+   *
+   * @param {*} value
+   */
+  toContainValue(value: any): void,
+  /**
+   * Use `.toContainValues` when checking if an object contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainValues(values: any[]): void,
+  /**
+   * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAllValues(values: any[]): void,
+  /**
+   * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAnyValues(values: any[]): void,
+  /**
+   * Use `.toContainEntry` when checking if an object contains the provided entry.
+   *
+   * @param {Array.<String, String>} entry
+   */
+  toContainEntry(entry: [string, string]): void,
+  /**
+   * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAllEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAnyEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toBeExtensible` when checking if an object is extensible.
+   */
+  toBeExtensible(): void,
+  /**
+   * Use `.toBeFrozen` when checking if an object is frozen.
+   */
+  toBeFrozen(): void,
+  /**
+   * Use `.toBeSealed` when checking if an object is sealed.
+   */
+  toBeSealed(): void,
+  /**
+   * Use `.toBeString` when checking if a value is a `String`.
+   */
+  toBeString(): void,
+  /**
+   * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+   *
+   * @param {String} string
+   */
+  toEqualCaseInsensitive(string: string): void,
+  /**
+   * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+   *
+   * @param {String} prefix
+   */
+  toStartWith(prefix: string): void,
+  /**
+   * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+   *
+   * @param {String} suffix
+   */
+  toEndWith(suffix: string): void,
+  /**
+   * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+   *
+   * @param {String} substring
+   */
+  toInclude(substring: string): void,
+  /**
+   * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+   *
+   * @param {String} substring
+   * @param {Number} times
+   */
+  toIncludeRepeated(substring: string, times: number): void,
+  /**
+   * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+   *
+   * @param {Array.<String>} substring
+   */
+  toIncludeMultiple(substring: string[]): void,
+  ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean,
+      colors?: boolean,
+      contextLines?: number,
+      stablePatchmarks?: boolean,
+      aAnnotation?: string,
+      bAnnotation?: string,
+    |},
+    testName?: string
+  ): void,
+  ...
+};
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+  /**
+   *  Disables automatic mocking in the module loader.
+   *
+   *  After this method is called, all `require()`s will return the real
+   *  versions of each module (rather than a mocked version).
+   */
+  disableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of disableAutomock
+   */
+  autoMockOff(): JestObjectType,
+  /**
+   * Enables automatic mocking in the module loader.
+   */
+  enableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of enableAutomock
+   */
+  autoMockOn(): JestObjectType,
+  /**
+   * Clears the mock.calls and mock.instances properties of all mocks.
+   * Equivalent to calling .mockClear() on every mocked function.
+   */
+  clearAllMocks(): JestObjectType,
+  /**
+   * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+   * mocked function.
+   */
+  resetAllMocks(): JestObjectType,
+  /**
+   * Restores all mocks back to their original value.
+   */
+  restoreAllMocks(): JestObjectType,
+  /**
+   * Removes any pending timers from the timer system.
+   */
+  clearAllTimers(): void,
+  /**
+   * Returns the number of fake timers still left to run.
+   */
+  getTimerCount(): number,
+  /**
+   * Set the current system time used by fake timers.
+   * Simulates a user changing the system clock while your program is running.
+   * It affects the current time but it does not in itself cause
+   * e.g. timers to fire; they will fire exactly as they would have done
+   * without the call to jest.setSystemTime().
+   */
+  setSystemTime(now?: number | Date): void,
+  /**
+   * The same as `mock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+  /**
+   * The same as `unmock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  dontMock(moduleName: string): JestObjectType,
+  /**
+   * Returns a new, unused mock function. Optionally takes a mock
+   * implementation.
+   */
+  fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+    implementation?: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Determines if the given function is a mocked function.
+   */
+  isMockFunction(fn: Function): boolean,
+  /**
+   * Alias of `createMockFromModule`.
+   */
+  genMockFromModule(moduleName: string): any,
+  /**
+   * Given the name of a module, use the automatic mocking system to generate a
+   * mocked version of the module for you.
+   */
+  createMockFromModule(moduleName: string): any,
+  /**
+   * Mocks a module with an auto-mocked version when it is being required.
+   *
+   * The second argument can be used to specify an explicit module factory that
+   * is being run instead of using Jest's automocking feature.
+   *
+   * The third argument can be used to create virtual mocks -- mocks of modules
+   * that don't exist anywhere in the system.
+   */
+  mock(
+    moduleName: string,
+    moduleFactory?: any,
+    options?: Object
+  ): JestObjectType,
+  /**
+   * Returns the actual module instead of a mock, bypassing all checks on
+   * whether the module should receive a mock implementation or not.
+   */
+  requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+  /**
+   * Returns a mock module instead of the actual module, bypassing all checks
+   * on whether the module should be required normally or not.
+   */
+  requireMock(moduleName: string): any,
+  /**
+   * Resets the module registry - the cache of all required modules. This is
+   * useful to isolate modules where local state might conflict between tests.
+   */
+  resetModules(): JestObjectType,
+  /**
+   * Creates a sandbox registry for the modules that are loaded inside the
+   * callback function. This is useful to isolate specific modules for every
+   * test so that local module state doesn't conflict between tests.
+   */
+  isolateModules(fn: () => void): JestObjectType,
+  /**
+   * Exhausts the micro-task queue (usually interfaced in node via
+   * process.nextTick).
+   */
+  runAllTicks(): void,
+  /**
+   * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+   * setInterval(), and setImmediate()).
+   */
+  runAllTimers(): void,
+  /**
+   * Exhausts all tasks queued by setImmediate().
+   */
+  runAllImmediates(): void,
+  /**
+   * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+   * or setInterval() and setImmediate()).
+   */
+  advanceTimersByTime(msToRun: number): void,
+  /**
+   * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+   * or setInterval() and setImmediate()).
+   *
+   * Renamed to `advanceTimersByTime`.
+   */
+  runTimersToTime(msToRun: number): void,
+  /**
+   * Executes only the macro-tasks that are currently pending (i.e., only the
+   * tasks that have been queued by setTimeout() or setInterval() up to this
+   * point)
+   */
+  runOnlyPendingTimers(): void,
+  /**
+   * Explicitly supplies the mock object that the module system should return
+   * for the specified module. Note: It is recommended to use jest.mock()
+   * instead.
+   */
+  setMock(moduleName: string, moduleExports: any): JestObjectType,
+  /**
+   * Indicates that the module system should never return a mocked version of
+   * the specified module from require() (e.g. that it should always return the
+   * real module).
+   */
+  unmock(moduleName: string): JestObjectType,
+  /**
+   * Instructs Jest to use fake versions of the standard timer functions
+   * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+   * setImmediate and clearImmediate).
+   */
+  useFakeTimers(mode?: 'modern' | 'legacy'): JestObjectType,
+  /**
+   * Instructs Jest to use the real versions of the standard timer functions.
+   */
+  useRealTimers(): JestObjectType,
+  /**
+   * Creates a mock function similar to jest.fn but also tracks calls to
+   * object[methodName].
+   */
+  spyOn(
+    object: Object,
+    methodName: string,
+    accessType?: 'get' | 'set'
+  ): JestMockFn<any, any>,
+  /**
+   * Set the default timeout interval for tests and before/after hooks in milliseconds.
+   * Note: The default timeout interval is 5 seconds if this method is not called.
+   */
+  setTimeout(timeout: number): JestObjectType,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+  /**
+   * Creates a block that groups together several related tests in one "test suite"
+   */
+  (name: JestTestName, fn: () => void): void,
+  /**
+   * Only run this describe block
+   */
+  only(name: JestTestName, fn: () => void): void,
+  /**
+   * Skip running this describe block
+   */
+  skip(name: JestTestName, fn: () => void): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+/** An individual test unit */
+declare var it: {
+  /**
+   * An individual test unit
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  (
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * Only run this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  only: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Skip running this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  skip: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Highlight planned tests in the summary output
+   *
+   * @param {String} Name of Test to do
+   */
+  todo(name: string): void,
+  /**
+   * Run the test concurrently
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  concurrent(
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+  comment: {
+    close: string,
+    open: string,
+    ...
+  },
+  content: {
+    close: string,
+    open: string,
+    ...
+  },
+  prop: {
+    close: string,
+    open: string,
+    ...
+  },
+  tag: {
+    close: string,
+    open: string,
+    ...
+  },
+  value: {
+    close: string,
+    open: string,
+    ...
+  },
+  ...
+};
+
+type JestPrettyFormatIndent = (string) => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = (any) => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+  print: (
+    val: any,
+    serialize: JestPrettyFormatPrint,
+    indent: JestPrettyFormatIndent,
+    opts: JestPrettyFormatOptions,
+    colors: JestPrettyFormatColors
+  ) => string,
+  test: (any) => boolean,
+  ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+  /** The object that you want to make assertions against */
+  (
+    value: any
+  ): JestExpectType &
+    JestPromiseType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType,
+  /** Add additional Jasmine matchers to Jest's roster */
+  extend(matchers: { [name: string]: JestMatcher, ... }): void,
+  /** Add a module that formats application-specific data structures. */
+  addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+  assertions(expectedAssertions: number): void,
+  hasAssertions(): void,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  objectContaining(value: Object): Object,
+  /** Matches any received string that contains the exact expected string. */
+  stringContaining(value: string): string,
+  stringMatching(value: string | RegExp): string,
+  not: {
+    arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+    objectContaining: (value: { ... }) => Object,
+    stringContaining: (value: string) => string,
+    stringMatching: (value: string | RegExp) => string,
+    ...
+  },
+  ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  createSpyObj(
+    baseName: string,
+    methodNames: Array<string>
+  ): { [methodName: string]: JestSpyType, ... },
+  objectContaining(value: Object): Object,
+  stringMatching(value: string): string,
+  ...
+};
diff --git a/definitions/npm/jest_v26.x.x/flow_v0.201.x-/test_jest-v26.x.x.js b/definitions/npm/jest_v26.x.x/flow_v0.201.x-/test_jest-v26.x.x.js
new file mode 100644
index 0000000000..9948d6cc45
--- /dev/null
+++ b/definitions/npm/jest_v26.x.x/flow_v0.201.x-/test_jest-v26.x.x.js
@@ -0,0 +1,802 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name');
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name');
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot(
+  'foobar',
+  undefined,
+  'snapshot difference between two strings'
+);
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) => expect(a).toMatchSnapshot());
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([
+  ['arg1', 'arg2'],
+  ['arg2', 'arg3'],
+])('test', (a, b) => expect(a).toMatchDiffSnapshot(b));
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+test.skip.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done("foo");
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+jest.setSystemTime();
+jest.setSystemTime(123);
+jest.setSystemTime(new Date());
+// $FlowExpectedError[incompatible-call]
+jest.setSystemTime('');
+
+jest.genMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.genMockFromModule(1);
+
+jest.createMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.createMockFromModule(1);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.runTimersToTime(3000);
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  expect(element).toHaveStyle('color: blue');
+  expect(element).toHaveStyle({ color: 'blue' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toHaveDisplayValue('test');
+  expect(element).toHaveDisplayValue(['foo', 'bar']);
+  expect(element).toBeChecked();
+  expect(element).toBeEmptyDOMElement();
+  expect(element).toBePartiallyChecked();
+
+  // $FlowExpectedError[incompatible-call]: expected description should be present
+  expect(element).toHaveDescription();
+  expect(element).toHaveDescription('foo');
+  expect(element).toHaveDescription(/[0-9]/);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveDescription(true);
+
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([
+      ['a', 'foo'],
+      ['b', 'bar'],
+      ['c', 'baz'],
+    ]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([
+      ['a', 'qux'],
+      ['a', 'foo'],
+    ]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`(
+  'x=$x, y=$y, and z=$z',
+  ({ x, y, z }) => {
+      // perform tests
+  }
+);
diff --git a/definitions/npm/jest_v27.x.x/flow_v0.134.x-/jest_v27.x.x.js b/definitions/npm/jest_v27.x.x/flow_v0.134.x-v.200.x/jest_v27.x.x.js
similarity index 100%
rename from definitions/npm/jest_v27.x.x/flow_v0.134.x-/jest_v27.x.x.js
rename to definitions/npm/jest_v27.x.x/flow_v0.134.x-v.200.x/jest_v27.x.x.js
diff --git a/definitions/npm/jest_v27.x.x/flow_v0.134.x-/test_jest-v27.x.x.js b/definitions/npm/jest_v27.x.x/flow_v0.134.x-v.200.x/test_jest-v27.x.x.js
similarity index 100%
rename from definitions/npm/jest_v27.x.x/flow_v0.134.x-/test_jest-v27.x.x.js
rename to definitions/npm/jest_v27.x.x/flow_v0.134.x-v.200.x/test_jest-v27.x.x.js
diff --git a/definitions/npm/jest_v27.x.x/flow_v0.201.x-/jest_v27.x.x.js b/definitions/npm/jest_v27.x.x/flow_v0.201.x-/jest_v27.x.x.js
new file mode 100644
index 0000000000..895ed53bc3
--- /dev/null
+++ b/definitions/npm/jest_v27.x.x/flow_v0.201.x-/jest_v27.x.x.js
@@ -0,0 +1,1232 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+  (...args: TArguments): TReturn,
+  /**
+   * An object for introspecting mock calls
+   */
+  mock: {
+    /**
+     * An array that represents all calls that have been made into this mock
+     * function. Each call is represented by an array of arguments that were
+     * passed during the call.
+     */
+    calls: Array<TArguments>,
+    /**
+     * An array that contains all the object instances that have been
+     * instantiated from this mock function.
+     */
+    instances: Array<TReturn>,
+    /**
+     * An array that contains all the object results that have been
+     * returned by this mock function call
+     */
+    results: Array<{
+      isThrow: boolean,
+      value: TReturn,
+      ...
+    }>,
+    ...
+  },
+  /**
+   * Resets all information stored in the mockFn.mock.calls and
+   * mockFn.mock.instances arrays. Often this is useful when you want to clean
+   * up a mock's usage data between two assertions.
+   */
+  mockClear(): void,
+  /**
+   * Resets all information stored in the mock. This is useful when you want to
+   * completely restore a mock back to its initial state.
+   */
+  mockReset(): void,
+  /**
+   * Removes the mock and restores the initial implementation. This is useful
+   * when you want to mock functions in certain test cases and restore the
+   * original implementation in others. Beware that mockFn.mockRestore only
+   * works when mock was created with jest.spyOn. Thus you have to take care of
+   * restoration yourself when manually assigning jest.fn().
+   */
+  mockRestore(): void,
+  /**
+   * Accepts a function that should be used as the implementation of the mock.
+   * The mock itself will still record all calls that go into and instances
+   * that come from itself -- the only difference is that the implementation
+   * will also be executed when the mock is called.
+   */
+  mockImplementation(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a function that will be used as an implementation of the mock for
+   * one call to the mocked function. Can be chained so that multiple function
+   * calls produce different results.
+   */
+  mockImplementationOnce(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a string to use in test result output in place of "jest.fn()" to
+   * indicate which mock function is being referenced.
+   */
+  mockName(name: string): JestMockFn<TArguments, TReturn>,
+  /**
+   * Just a simple sugar function for returning `this`
+   */
+  mockReturnThis(): void,
+  /**
+   * Accepts a value that will be returned whenever the mock function is called.
+   */
+  mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for only returning a value once inside your mock
+   */
+  mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+   */
+  mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+   */
+  mockResolvedValueOnce(
+    value: TReturn
+  ): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+   */
+  mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+   */
+  mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  ...
+};
+
+type JestAsymmetricEqualityType = {
+  /**
+   * A custom Jasmine equality tester
+   */
+  asymmetricMatch(value: mixed): boolean,
+  ...
+};
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestMatcherResult = {
+  message?: string | (() => string),
+  pass: boolean,
+  ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+  /**
+   * Use rejects to unwrap the reason of a rejected promise so any other
+   * matcher can be chained. If the promise is fulfilled the assertion fails.
+   */
+  rejects: JestExpectType,
+  /**
+   * Use resolves to unwrap the value of a fulfilled promise so any other
+   * matcher can be chained. If the promise is rejected the assertion fails.
+   */
+  resolves: JestExpectType,
+  ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+  media?: string,
+  modifier?: string,
+  supports?: string,
+  ...
+};
+
+type JestStyledComponentsMatchersType = {
+  toHaveStyleRule(
+    property: string,
+    value: JestStyledComponentsMatcherValue,
+    options?: JestStyledComponentsMatcherOptions
+  ): void,
+  ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+  // 5.x
+  toBeEmpty(): void,
+  toBePresent(): void,
+  // 6.x
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmptyRender(): void,
+  toContainMatchingElement(selector: string): void,
+  toContainMatchingElements(n: number, selector: string): void,
+  toContainExactlyOneMatchingElement(selector: string): void,
+  toContainReact(element: React$Element<any>): void,
+  toExist(): void,
+  toHaveClassName(className: string): void,
+  toHaveHTML(html: string): void,
+  toHaveProp: ((propKey: string, propValue?: any) => void) &
+    ((props: { ... }) => void),
+  toHaveRef(refName: string): void,
+  toHaveState: ((stateKey: string, stateValue?: any) => void) &
+    ((state: { ... }) => void),
+  toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+    ((style: { ... }) => void),
+  toHaveTagName(tagName: string): void,
+  toHaveText(text: string): void,
+  toHaveValue(value: any): void,
+  toIncludeText(text: string): void,
+  toMatchElement(
+    element: React$Element<any>,
+    options?: {| ignoreProps?: boolean, verbose?: boolean |}
+  ): void,
+  toMatchSelector(selector: string): void,
+  // 7.x
+  toHaveDisplayName(name: string): void,
+  ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+  /**
+   * @deprecated
+   */
+  toBeInTheDOM(container?: HTMLElement): void,
+
+  // 4.x
+  toBeInTheDocument(): void,
+  toBeVisible(): void,
+  toBeEmpty(): void,
+  toBeDisabled(): void,
+  toBeEnabled(): void,
+  toBeInvalid(): void,
+  toBeRequired(): void,
+  toBeValid(): void,
+  toContainElement(element: HTMLElement | null): void,
+  toContainHTML(htmlText: string): void,
+  toHaveAttribute(attr: string, value?: any): void,
+  toHaveClass(...classNames: string[]): void,
+  toHaveFocus(): void,
+  toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+  toHaveStyle(css: string | { [name: string]: any, ... }): void,
+  toHaveTextContent(
+    text: string | RegExp,
+    options?: {| normalizeWhitespace: boolean |}
+  ): void,
+  toHaveValue(value?: string | string[] | number): void,
+
+  // 5.x
+  toHaveDisplayValue(value: string | string[]): void,
+  toBeChecked(): void,
+  toBeEmptyDOMElement(): void,
+  toBePartiallyChecked(): void,
+  toHaveDescription(text: string | RegExp): void,
+  ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+  toExist(): void,
+  toHaveLength(len: number): void,
+  toHaveId(id: string): void,
+  toHaveClass(className: string): void,
+  toHaveTag(tag: string): void,
+  toHaveAttr(key: string, val?: any): void,
+  toHaveProp(key: string, val?: any): void,
+  toHaveText(text: string | RegExp): void,
+  toHaveData(key: string, val?: any): void,
+  toHaveValue(val: any): void,
+  toHaveCss(css: { [key: string]: any, ... }): void,
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmpty(): void,
+  toBeHidden(): void,
+  toBeSelected(): void,
+  toBeVisible(): void,
+  toBeFocused(): void,
+  toBeInDom(): void,
+  toBeMatchedBy(sel: string): void,
+  toHaveDescendant(sel: string): void,
+  toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+  ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+  /**
+   * Note: Currently unimplemented
+   * Passing assertion
+   *
+   * @param {String} message
+   */
+  //  pass(message: string): void;
+
+  /**
+   * Note: Currently unimplemented
+   * Failing assertion
+   *
+   * @param {String} message
+   */
+  //  fail(message: string): void;
+
+  /**
+   * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+   */
+  toBeEmpty(): void,
+  /**
+   * Use .toBeOneOf when checking if a value is a member of a given Array.
+   * @param {Array.<*>} members
+   */
+  toBeOneOf(members: any[]): void,
+  /**
+   * Use `.toBeNil` when checking a value is `null` or `undefined`.
+   */
+  toBeNil(): void,
+  /**
+   * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+   * @param {Function} predicate
+   */
+  toSatisfy(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeArray` when checking if a value is an `Array`.
+   */
+  toBeArray(): void,
+  /**
+   * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+   * @param {Number} x
+   */
+  toBeArrayOfSize(x: number): void,
+  /**
+   * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAllMembers(members: any[]): void,
+  /**
+   * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAnyMembers(members: any[]): void,
+  /**
+   * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+   * @param {Function} predicate
+   */
+  toSatisfyAll(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+   */
+  toBeBoolean(): void,
+  /**
+   * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+   */
+  toBeTrue(): void,
+  /**
+   * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+   */
+  toBeFalse(): void,
+  /**
+   * Use .toBeDate when checking if a value is a Date.
+   */
+  toBeDate(): void,
+  /**
+   * Use `.toBeFunction` when checking if a value is a `Function`.
+   */
+  toBeFunction(): void,
+  /**
+   * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+   *
+   * Note: Required Jest version >22
+   * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+   *
+   * @param {Mock} mock
+   */
+  toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+  /**
+   * Use `.toBeNumber` when checking if a value is a `Number`.
+   */
+  toBeNumber(): void,
+  /**
+   * Use `.toBeNaN` when checking a value is `NaN`.
+   */
+  toBeNaN(): void,
+  /**
+   * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+   */
+  toBeFinite(): void,
+  /**
+   * Use `.toBePositive` when checking if a value is a positive `Number`.
+   */
+  toBePositive(): void,
+  /**
+   * Use `.toBeNegative` when checking if a value is a negative `Number`.
+   */
+  toBeNegative(): void,
+  /**
+   * Use `.toBeEven` when checking if a value is an even `Number`.
+   */
+  toBeEven(): void,
+  /**
+   * Use `.toBeOdd` when checking if a value is an odd `Number`.
+   */
+  toBeOdd(): void,
+  /**
+   * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+   *
+   * @param {Number} start
+   * @param {Number} end
+   */
+  toBeWithin(start: number, end: number): void,
+  /**
+   * Use `.toBeObject` when checking if a value is an `Object`.
+   */
+  toBeObject(): void,
+  /**
+   * Use `.toContainKey` when checking if an object contains the provided key.
+   *
+   * @param {String} key
+   */
+  toContainKey(key: string): void,
+  /**
+   * Use `.toContainKeys` when checking if an object has all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAllKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAnyKeys(keys: string[]): void,
+  /**
+   * Use `.toContainValue` when checking if an object contains the provided value.
+   *
+   * @param {*} value
+   */
+  toContainValue(value: any): void,
+  /**
+   * Use `.toContainValues` when checking if an object contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainValues(values: any[]): void,
+  /**
+   * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAllValues(values: any[]): void,
+  /**
+   * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAnyValues(values: any[]): void,
+  /**
+   * Use `.toContainEntry` when checking if an object contains the provided entry.
+   *
+   * @param {Array.<String, String>} entry
+   */
+  toContainEntry(entry: [string, string]): void,
+  /**
+   * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAllEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAnyEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toBeExtensible` when checking if an object is extensible.
+   */
+  toBeExtensible(): void,
+  /**
+   * Use `.toBeFrozen` when checking if an object is frozen.
+   */
+  toBeFrozen(): void,
+  /**
+   * Use `.toBeSealed` when checking if an object is sealed.
+   */
+  toBeSealed(): void,
+  /**
+   * Use `.toBeString` when checking if a value is a `String`.
+   */
+  toBeString(): void,
+  /**
+   * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+   *
+   * @param {String} string
+   */
+  toEqualCaseInsensitive(string: string): void,
+  /**
+   * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+   *
+   * @param {String} prefix
+   */
+  toStartWith(prefix: string): void,
+  /**
+   * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+   *
+   * @param {String} suffix
+   */
+  toEndWith(suffix: string): void,
+  /**
+   * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+   *
+   * @param {String} substring
+   */
+  toInclude(substring: string): void,
+  /**
+   * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+   *
+   * @param {String} substring
+   * @param {Number} times
+   */
+  toIncludeRepeated(substring: string, times: number): void,
+  /**
+   * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+   *
+   * @param {Array.<String>} substring
+   */
+  toIncludeMultiple(substring: string[]): void,
+  ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean,
+      colors?: boolean,
+      contextLines?: number,
+      stablePatchmarks?: boolean,
+      aAnnotation?: string,
+      bAnnotation?: string,
+    |},
+    testName?: string
+  ): void,
+  ...
+};
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+  /**
+   *  Disables automatic mocking in the module loader.
+   *
+   *  After this method is called, all `require()`s will return the real
+   *  versions of each module (rather than a mocked version).
+   */
+  disableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of disableAutomock
+   */
+  autoMockOff(): JestObjectType,
+  /**
+   * Enables automatic mocking in the module loader.
+   */
+  enableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of enableAutomock
+   */
+  autoMockOn(): JestObjectType,
+  /**
+   * Clears the mock.calls and mock.instances properties of all mocks.
+   * Equivalent to calling .mockClear() on every mocked function.
+   */
+  clearAllMocks(): JestObjectType,
+  /**
+   * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+   * mocked function.
+   */
+  resetAllMocks(): JestObjectType,
+  /**
+   * Restores all mocks back to their original value.
+   */
+  restoreAllMocks(): JestObjectType,
+  /**
+   * Removes any pending timers from the timer system.
+   */
+  clearAllTimers(): void,
+  /**
+   * Returns the number of fake timers still left to run.
+   */
+  getTimerCount(): number,
+  /**
+   * Set the current system time used by fake timers.
+   * Simulates a user changing the system clock while your program is running.
+   * It affects the current time but it does not in itself cause
+   * e.g. timers to fire; they will fire exactly as they would have done
+   * without the call to jest.setSystemTime().
+   */
+  setSystemTime(now?: number | Date): void,
+  /**
+   * The same as `mock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+  /**
+   * The same as `unmock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  dontMock(moduleName: string): JestObjectType,
+  /**
+   * Returns a new, unused mock function. Optionally takes a mock
+   * implementation.
+   */
+  fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+    implementation?: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Determines if the given function is a mocked function.
+   */
+  isMockFunction(fn: Function): boolean,
+  /**
+   * Alias of `createMockFromModule`.
+   */
+  genMockFromModule(moduleName: string): any,
+  /**
+   * Given the name of a module, use the automatic mocking system to generate a
+   * mocked version of the module for you.
+   */
+  createMockFromModule(moduleName: string): any,
+  /**
+   * Mocks a module with an auto-mocked version when it is being required.
+   *
+   * The second argument can be used to specify an explicit module factory that
+   * is being run instead of using Jest's automocking feature.
+   *
+   * The third argument can be used to create virtual mocks -- mocks of modules
+   * that don't exist anywhere in the system.
+   */
+  mock(
+    moduleName: string,
+    moduleFactory?: any,
+    options?: Object
+  ): JestObjectType,
+  /**
+   * Returns the actual module instead of a mock, bypassing all checks on
+   * whether the module should receive a mock implementation or not.
+   */
+  requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+  /**
+   * Returns a mock module instead of the actual module, bypassing all checks
+   * on whether the module should be required normally or not.
+   */
+  requireMock(moduleName: string): any,
+  /**
+   * Resets the module registry - the cache of all required modules. This is
+   * useful to isolate modules where local state might conflict between tests.
+   */
+  resetModules(): JestObjectType,
+  /**
+   * Creates a sandbox registry for the modules that are loaded inside the
+   * callback function. This is useful to isolate specific modules for every
+   * test so that local module state doesn't conflict between tests.
+   */
+  isolateModules(fn: () => void): JestObjectType,
+  /**
+   * Exhausts the micro-task queue (usually interfaced in node via
+   * process.nextTick).
+   */
+  runAllTicks(): void,
+  /**
+   * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+   * setInterval(), and setImmediate()).
+   */
+  runAllTimers(): void,
+  /**
+   * Exhausts all tasks queued by setImmediate().
+   */
+  runAllImmediates(): void,
+  /**
+   * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+   * or setInterval() and setImmediate()).
+   */
+  advanceTimersByTime(msToRun: number): void,
+  /**
+   * Executes only the macro-tasks that are currently pending (i.e., only the
+   * tasks that have been queued by setTimeout() or setInterval() up to this
+   * point)
+   */
+  runOnlyPendingTimers(): void,
+  /**
+   * Explicitly supplies the mock object that the module system should return
+   * for the specified module. Note: It is recommended to use jest.mock()
+   * instead.
+   */
+  setMock(moduleName: string, moduleExports: any): JestObjectType,
+  /**
+   * Indicates that the module system should never return a mocked version of
+   * the specified module from require() (e.g. that it should always return the
+   * real module).
+   */
+  unmock(moduleName: string): JestObjectType,
+  /**
+   * Instructs Jest to use fake versions of the standard timer functions
+   * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+   * setImmediate and clearImmediate).
+   */
+  useFakeTimers(mode?: 'modern' | 'legacy'): JestObjectType,
+  /**
+   * Instructs Jest to use the real versions of the standard timer functions.
+   */
+  useRealTimers(): JestObjectType,
+  /**
+   * Creates a mock function similar to jest.fn but also tracks calls to
+   * object[methodName].
+   */
+  spyOn(
+    object: Object,
+    methodName: string,
+    accessType?: 'get' | 'set'
+  ): JestMockFn<any, any>,
+  /**
+   * Set the default timeout interval for tests and before/after hooks in milliseconds.
+   * Note: The default timeout interval is 5 seconds if this method is not called.
+   */
+  setTimeout(timeout: number): JestObjectType,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+  /**
+   * Creates a block that groups together several related tests in one "test suite"
+   */
+  (name: JestTestName, fn: () => void): void,
+  /**
+   * Only run this describe block
+   */
+  only(name: JestTestName, fn: () => void): void,
+  /**
+   * Skip running this describe block
+   */
+  skip(name: JestTestName, fn: () => void): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+/** An individual test unit */
+declare var it: {
+  /**
+   * An individual test unit
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  (
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * Only run this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  only: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Skip running this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  skip: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Highlight planned tests in the summary output
+   *
+   * @param {String} Name of Test to do
+   */
+  todo(name: string): void,
+  /**
+   * Run the test concurrently
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  concurrent(
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+  comment: {
+    close: string,
+    open: string,
+    ...
+  },
+  content: {
+    close: string,
+    open: string,
+    ...
+  },
+  prop: {
+    close: string,
+    open: string,
+    ...
+  },
+  tag: {
+    close: string,
+    open: string,
+    ...
+  },
+  value: {
+    close: string,
+    open: string,
+    ...
+  },
+  ...
+};
+
+type JestPrettyFormatIndent = (string) => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = (any) => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+  print: (
+    val: any,
+    serialize: JestPrettyFormatPrint,
+    indent: JestPrettyFormatIndent,
+    opts: JestPrettyFormatOptions,
+    colors: JestPrettyFormatColors
+  ) => string,
+  test: (any) => boolean,
+  ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+  /** The object that you want to make assertions against */
+  (
+    value: any
+  ): JestExpectType &
+    JestPromiseType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType,
+  /** Add additional Jasmine matchers to Jest's roster */
+  extend(matchers: { [name: string]: JestMatcher, ... }): void,
+  /** Add a module that formats application-specific data structures. */
+  addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+  assertions(expectedAssertions: number): void,
+  hasAssertions(): void,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  objectContaining(value: Object): Object,
+  /** Matches any received string that contains the exact expected string. */
+  stringContaining(value: string): string,
+  stringMatching(value: string | RegExp): string,
+  not: {
+    arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+    objectContaining: (value: { ... }) => Object,
+    stringContaining: (value: string) => string,
+    stringMatching: (value: string | RegExp) => string,
+    ...
+  },
+  ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  createSpyObj(
+    baseName: string,
+    methodNames: Array<string>
+  ): { [methodName: string]: JestSpyType, ... },
+  objectContaining(value: Object): Object,
+  stringMatching(value: string): string,
+  ...
+};
diff --git a/definitions/npm/jest_v27.x.x/flow_v0.201.x-/test_jest-v27.x.x.js b/definitions/npm/jest_v27.x.x/flow_v0.201.x-/test_jest-v27.x.x.js
new file mode 100644
index 0000000000..22c7ddeb54
--- /dev/null
+++ b/definitions/npm/jest_v27.x.x/flow_v0.201.x-/test_jest-v27.x.x.js
@@ -0,0 +1,800 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name');
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name');
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot(
+  'foobar',
+  undefined,
+  'snapshot difference between two strings'
+);
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) => expect(a).toMatchSnapshot());
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([
+  ['arg1', 'arg2'],
+  ['arg2', 'arg3'],
+])('test', (a, b) => expect(a).toMatchDiffSnapshot(b));
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+test.skip.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done('foo');
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+jest.setSystemTime();
+jest.setSystemTime(123);
+jest.setSystemTime(new Date());
+// $FlowExpectedError[incompatible-call]
+jest.setSystemTime('');
+
+jest.genMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.genMockFromModule(1);
+
+jest.createMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.createMockFromModule(1);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  expect(element).toHaveStyle('color: blue');
+  expect(element).toHaveStyle({ color: 'blue' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toHaveDisplayValue('test');
+  expect(element).toHaveDisplayValue(['foo', 'bar']);
+  expect(element).toBeChecked();
+  expect(element).toBeEmptyDOMElement();
+  expect(element).toBePartiallyChecked();
+
+  // $FlowExpectedError[incompatible-call]: expected description should be present
+  expect(element).toHaveDescription();
+  expect(element).toHaveDescription('foo');
+  expect(element).toHaveDescription(/[0-9]/);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveDescription(true);
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([
+      ['a', 'foo'],
+      ['b', 'bar'],
+      ['c', 'baz'],
+    ]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([
+      ['a', 'qux'],
+      ['a', 'foo'],
+    ]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`(
+  'x=$x, y=$y, and z=$z',
+  ({ x, y, z }) => {
+      // perform tests
+  }
+);
diff --git a/definitions/npm/jest_v28.x.x/flow_v0.134.x-/jest_v28.x.x.js b/definitions/npm/jest_v28.x.x/flow_v0.134.x-v.200.x/jest_v28.x.x.js
similarity index 100%
rename from definitions/npm/jest_v28.x.x/flow_v0.134.x-/jest_v28.x.x.js
rename to definitions/npm/jest_v28.x.x/flow_v0.134.x-v.200.x/jest_v28.x.x.js
diff --git a/definitions/npm/jest_v28.x.x/flow_v0.134.x-/test_jest_v28.x.x.js b/definitions/npm/jest_v28.x.x/flow_v0.134.x-v.200.x/test_jest_v28.x.x.js
similarity index 100%
rename from definitions/npm/jest_v28.x.x/flow_v0.134.x-/test_jest_v28.x.x.js
rename to definitions/npm/jest_v28.x.x/flow_v0.134.x-v.200.x/test_jest_v28.x.x.js
diff --git a/definitions/npm/jest_v28.x.x/flow_v0.201.x-/jest_v28.x.x.js b/definitions/npm/jest_v28.x.x/flow_v0.201.x-/jest_v28.x.x.js
new file mode 100644
index 0000000000..e94146f28e
--- /dev/null
+++ b/definitions/npm/jest_v28.x.x/flow_v0.201.x-/jest_v28.x.x.js
@@ -0,0 +1,1264 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+  (...args: TArguments): TReturn,
+  /**
+   * An object for introspecting mock calls
+   */
+  mock: {
+    /**
+     * An array that represents all calls that have been made into this mock
+     * function. Each call is represented by an array of arguments that were
+     * passed during the call.
+     */
+    calls: Array<TArguments>,
+    /**
+     * An array containing the call arguments of the last call that was made
+     * to this mock function. If the function was not called, it will return
+     * undefined.
+     */
+    lastCall: TArguments,
+    /**
+     * An array that contains all the object instances that have been
+     * instantiated from this mock function.
+     */
+    instances: Array<TReturn>,
+    /**
+     * An array that contains all the object results that have been
+     * returned by this mock function call
+     */
+    results: Array<{
+      isThrow: boolean,
+      value: TReturn,
+      ...
+    }>,
+    ...
+  },
+  /**
+   * Resets all information stored in the mockFn.mock.calls and
+   * mockFn.mock.instances arrays. Often this is useful when you want to clean
+   * up a mock's usage data between two assertions.
+   */
+  mockClear(): void,
+  /**
+   * Resets all information stored in the mock. This is useful when you want to
+   * completely restore a mock back to its initial state.
+   */
+  mockReset(): void,
+  /**
+   * Removes the mock and restores the initial implementation. This is useful
+   * when you want to mock functions in certain test cases and restore the
+   * original implementation in others. Beware that mockFn.mockRestore only
+   * works when mock was created with jest.spyOn. Thus you have to take care of
+   * restoration yourself when manually assigning jest.fn().
+   */
+  mockRestore(): void,
+  /**
+   * Accepts a function that should be used as the implementation of the mock.
+   * The mock itself will still record all calls that go into and instances
+   * that come from itself -- the only difference is that the implementation
+   * will also be executed when the mock is called.
+   */
+  mockImplementation(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a function that will be used as an implementation of the mock for
+   * one call to the mocked function. Can be chained so that multiple function
+   * calls produce different results.
+   */
+  mockImplementationOnce(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a string to use in test result output in place of "jest.fn()" to
+   * indicate which mock function is being referenced.
+   */
+  mockName(name: string): JestMockFn<TArguments, TReturn>,
+  /**
+   * Just a simple sugar function for returning `this`
+   */
+  mockReturnThis(): void,
+  /**
+   * Accepts a value that will be returned whenever the mock function is called.
+   */
+  mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for only returning a value once inside your mock
+   */
+  mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+   */
+  mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+   */
+  mockResolvedValueOnce(
+    value: TReturn
+  ): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+   */
+  mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+   */
+  mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  ...
+};
+
+type JestAsymmetricEqualityType = {
+  /**
+   * A custom Jasmine equality tester
+   */
+  asymmetricMatch(value: mixed): boolean,
+  ...
+};
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestMatcherResult = {
+  message?: string | (() => string),
+  pass: boolean,
+  ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+  /**
+   * Use rejects to unwrap the reason of a rejected promise so any other
+   * matcher can be chained. If the promise is fulfilled the assertion fails.
+   */
+  rejects: JestExpectType,
+  /**
+   * Use resolves to unwrap the value of a fulfilled promise so any other
+   * matcher can be chained. If the promise is rejected the assertion fails.
+   */
+  resolves: JestExpectType,
+  ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+type FakeableAPI =
+  | 'Date'
+  | 'hrtime'
+  | 'nextTick'
+  | 'performance'
+  | 'queueMicrotask'
+  | 'requestAnimationFrame'
+  | 'cancelAnimationFrame'
+  | 'requestIdleCallback'
+  | 'cancelIdleCallback'
+  | 'setImmediate'
+  | 'clearImmediate'
+  | 'setInterval'
+  | 'clearInterval'
+  | 'setTimeout'
+  | 'clearTimeout';
+
+type FakeTimersConfig = {
+  advanceTimers?: boolean | number,
+  doNotFake?: Array<FakeableAPI>,
+  now?: number | Date,
+  timerLimit?: number,
+  legacyFakeTimers?: boolean,
+  ...
+};
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+  media?: string,
+  modifier?: string,
+  supports?: string,
+  ...
+};
+
+type JestStyledComponentsMatchersType = {
+  toHaveStyleRule(
+    property: string,
+    value: JestStyledComponentsMatcherValue,
+    options?: JestStyledComponentsMatcherOptions
+  ): void,
+  ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+  // 5.x
+  toBeEmpty(): void,
+  toBePresent(): void,
+  // 6.x
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmptyRender(): void,
+  toContainMatchingElement(selector: string): void,
+  toContainMatchingElements(n: number, selector: string): void,
+  toContainExactlyOneMatchingElement(selector: string): void,
+  toContainReact(element: React$Element<any>): void,
+  toExist(): void,
+  toHaveClassName(className: string): void,
+  toHaveHTML(html: string): void,
+  toHaveProp: ((propKey: string, propValue?: any) => void) &
+    ((props: { ... }) => void),
+  toHaveRef(refName: string): void,
+  toHaveState: ((stateKey: string, stateValue?: any) => void) &
+    ((state: { ... }) => void),
+  toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+    ((style: { ... }) => void),
+  toHaveTagName(tagName: string): void,
+  toHaveText(text: string): void,
+  toHaveValue(value: any): void,
+  toIncludeText(text: string): void,
+  toMatchElement(
+    element: React$Element<any>,
+    options?: {| ignoreProps?: boolean, verbose?: boolean |}
+  ): void,
+  toMatchSelector(selector: string): void,
+  // 7.x
+  toHaveDisplayName(name: string): void,
+  ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+  /**
+   * @deprecated
+   */
+  toBeInTheDOM(container?: HTMLElement): void,
+
+  // 4.x
+  toBeInTheDocument(): void,
+  toBeVisible(): void,
+  toBeEmpty(): void,
+  toBeDisabled(): void,
+  toBeEnabled(): void,
+  toBeInvalid(): void,
+  toBeRequired(): void,
+  toBeValid(): void,
+  toContainElement(element: HTMLElement | null): void,
+  toContainHTML(htmlText: string): void,
+  toHaveAttribute(attr: string, value?: any): void,
+  toHaveClass(...classNames: string[]): void,
+  toHaveFocus(): void,
+  toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+  toHaveStyle(css: string | { [name: string]: any, ... }): void,
+  toHaveTextContent(
+    text: string | RegExp,
+    options?: {| normalizeWhitespace: boolean |}
+  ): void,
+  toHaveValue(value?: string | string[] | number): void,
+
+  // 5.x
+  toHaveDisplayValue(value: string | string[]): void,
+  toBeChecked(): void,
+  toBeEmptyDOMElement(): void,
+  toBePartiallyChecked(): void,
+  toHaveDescription(text: string | RegExp): void,
+  ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+  toExist(): void,
+  toHaveLength(len: number): void,
+  toHaveId(id: string): void,
+  toHaveClass(className: string): void,
+  toHaveTag(tag: string): void,
+  toHaveAttr(key: string, val?: any): void,
+  toHaveProp(key: string, val?: any): void,
+  toHaveText(text: string | RegExp): void,
+  toHaveData(key: string, val?: any): void,
+  toHaveValue(val: any): void,
+  toHaveCss(css: { [key: string]: any, ... }): void,
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmpty(): void,
+  toBeHidden(): void,
+  toBeSelected(): void,
+  toBeVisible(): void,
+  toBeFocused(): void,
+  toBeInDom(): void,
+  toBeMatchedBy(sel: string): void,
+  toHaveDescendant(sel: string): void,
+  toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+  ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+  /**
+   * Note: Currently unimplemented
+   * Passing assertion
+   *
+   * @param {String} message
+   */
+  //  pass(message: string): void;
+
+  /**
+   * Note: Currently unimplemented
+   * Failing assertion
+   *
+   * @param {String} message
+   */
+  //  fail(message: string): void;
+
+  /**
+   * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+   */
+  toBeEmpty(): void,
+  /**
+   * Use .toBeOneOf when checking if a value is a member of a given Array.
+   * @param {Array.<*>} members
+   */
+  toBeOneOf(members: any[]): void,
+  /**
+   * Use `.toBeNil` when checking a value is `null` or `undefined`.
+   */
+  toBeNil(): void,
+  /**
+   * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+   * @param {Function} predicate
+   */
+  toSatisfy(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeArray` when checking if a value is an `Array`.
+   */
+  toBeArray(): void,
+  /**
+   * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+   * @param {Number} x
+   */
+  toBeArrayOfSize(x: number): void,
+  /**
+   * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAllMembers(members: any[]): void,
+  /**
+   * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAnyMembers(members: any[]): void,
+  /**
+   * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+   * @param {Function} predicate
+   */
+  toSatisfyAll(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+   */
+  toBeBoolean(): void,
+  /**
+   * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+   */
+  toBeTrue(): void,
+  /**
+   * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+   */
+  toBeFalse(): void,
+  /**
+   * Use .toBeDate when checking if a value is a Date.
+   */
+  toBeDate(): void,
+  /**
+   * Use `.toBeFunction` when checking if a value is a `Function`.
+   */
+  toBeFunction(): void,
+  /**
+   * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+   *
+   * Note: Required Jest version >22
+   * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+   *
+   * @param {Mock} mock
+   */
+  toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+  /**
+   * Use `.toBeNumber` when checking if a value is a `Number`.
+   */
+  toBeNumber(): void,
+  /**
+   * Use `.toBeNaN` when checking a value is `NaN`.
+   */
+  toBeNaN(): void,
+  /**
+   * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+   */
+  toBeFinite(): void,
+  /**
+   * Use `.toBePositive` when checking if a value is a positive `Number`.
+   */
+  toBePositive(): void,
+  /**
+   * Use `.toBeNegative` when checking if a value is a negative `Number`.
+   */
+  toBeNegative(): void,
+  /**
+   * Use `.toBeEven` when checking if a value is an even `Number`.
+   */
+  toBeEven(): void,
+  /**
+   * Use `.toBeOdd` when checking if a value is an odd `Number`.
+   */
+  toBeOdd(): void,
+  /**
+   * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+   *
+   * @param {Number} start
+   * @param {Number} end
+   */
+  toBeWithin(start: number, end: number): void,
+  /**
+   * Use `.toBeObject` when checking if a value is an `Object`.
+   */
+  toBeObject(): void,
+  /**
+   * Use `.toContainKey` when checking if an object contains the provided key.
+   *
+   * @param {String} key
+   */
+  toContainKey(key: string): void,
+  /**
+   * Use `.toContainKeys` when checking if an object has all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAllKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAnyKeys(keys: string[]): void,
+  /**
+   * Use `.toContainValue` when checking if an object contains the provided value.
+   *
+   * @param {*} value
+   */
+  toContainValue(value: any): void,
+  /**
+   * Use `.toContainValues` when checking if an object contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainValues(values: any[]): void,
+  /**
+   * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAllValues(values: any[]): void,
+  /**
+   * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAnyValues(values: any[]): void,
+  /**
+   * Use `.toContainEntry` when checking if an object contains the provided entry.
+   *
+   * @param {Array.<String, String>} entry
+   */
+  toContainEntry(entry: [string, string]): void,
+  /**
+   * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAllEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAnyEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toBeExtensible` when checking if an object is extensible.
+   */
+  toBeExtensible(): void,
+  /**
+   * Use `.toBeFrozen` when checking if an object is frozen.
+   */
+  toBeFrozen(): void,
+  /**
+   * Use `.toBeSealed` when checking if an object is sealed.
+   */
+  toBeSealed(): void,
+  /**
+   * Use `.toBeString` when checking if a value is a `String`.
+   */
+  toBeString(): void,
+  /**
+   * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+   *
+   * @param {String} string
+   */
+  toEqualCaseInsensitive(string: string): void,
+  /**
+   * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+   *
+   * @param {String} prefix
+   */
+  toStartWith(prefix: string): void,
+  /**
+   * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+   *
+   * @param {String} suffix
+   */
+  toEndWith(suffix: string): void,
+  /**
+   * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+   *
+   * @param {String} substring
+   */
+  toInclude(substring: string): void,
+  /**
+   * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+   *
+   * @param {String} substring
+   * @param {Number} times
+   */
+  toIncludeRepeated(substring: string, times: number): void,
+  /**
+   * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+   *
+   * @param {Array.<String>} substring
+   */
+  toIncludeMultiple(substring: string[]): void,
+  ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean,
+      colors?: boolean,
+      contextLines?: number,
+      stablePatchmarks?: boolean,
+      aAnnotation?: string,
+      bAnnotation?: string,
+    |},
+    testName?: string
+  ): void,
+  ...
+};
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+  /**
+   *  Disables automatic mocking in the module loader.
+   *
+   *  After this method is called, all `require()`s will return the real
+   *  versions of each module (rather than a mocked version).
+   */
+  disableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of disableAutomock
+   */
+  autoMockOff(): JestObjectType,
+  /**
+   * Enables automatic mocking in the module loader.
+   */
+  enableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of enableAutomock
+   */
+  autoMockOn(): JestObjectType,
+  /**
+   * Clears the mock.calls and mock.instances properties of all mocks.
+   * Equivalent to calling .mockClear() on every mocked function.
+   */
+  clearAllMocks(): JestObjectType,
+  /**
+   * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+   * mocked function.
+   */
+  resetAllMocks(): JestObjectType,
+  /**
+   * Restores all mocks back to their original value.
+   */
+  restoreAllMocks(): JestObjectType,
+  /**
+   * Removes any pending timers from the timer system.
+   */
+  clearAllTimers(): void,
+  /**
+   * Returns the number of fake timers still left to run.
+   */
+  getTimerCount(): number,
+  /**
+   * Set the current system time used by fake timers.
+   * Simulates a user changing the system clock while your program is running.
+   * It affects the current time but it does not in itself cause
+   * e.g. timers to fire; they will fire exactly as they would have done
+   * without the call to jest.setSystemTime().
+   */
+  setSystemTime(now?: number | Date): void,
+  /**
+   * The same as `mock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+  /**
+   * The same as `unmock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  dontMock(moduleName: string): JestObjectType,
+  /**
+   * Returns a new, unused mock function. Optionally takes a mock
+   * implementation.
+   */
+  fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+    implementation?: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Determines if the given function is a mocked function.
+   */
+  isMockFunction(fn: Function): boolean,
+  /**
+   * Alias of `createMockFromModule`.
+   */
+  genMockFromModule(moduleName: string): any,
+  /**
+   * Given the name of a module, use the automatic mocking system to generate a
+   * mocked version of the module for you.
+   */
+  createMockFromModule(moduleName: string): any,
+  /**
+   * Mocks a module with an auto-mocked version when it is being required.
+   *
+   * The second argument can be used to specify an explicit module factory that
+   * is being run instead of using Jest's automocking feature.
+   *
+   * The third argument can be used to create virtual mocks -- mocks of modules
+   * that don't exist anywhere in the system.
+   */
+  mock(
+    moduleName: string,
+    moduleFactory?: any,
+    options?: Object
+  ): JestObjectType,
+  /**
+   * Returns the actual module instead of a mock, bypassing all checks on
+   * whether the module should receive a mock implementation or not.
+   */
+  requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+  /**
+   * Returns a mock module instead of the actual module, bypassing all checks
+   * on whether the module should be required normally or not.
+   */
+  requireMock(moduleName: string): any,
+  /**
+   * Resets the module registry - the cache of all required modules. This is
+   * useful to isolate modules where local state might conflict between tests.
+   */
+  resetModules(): JestObjectType,
+  /**
+   * Creates a sandbox registry for the modules that are loaded inside the
+   * callback function. This is useful to isolate specific modules for every
+   * test so that local module state doesn't conflict between tests.
+   */
+  isolateModules(fn: () => void): JestObjectType,
+  /**
+   * Exhausts the micro-task queue (usually interfaced in node via
+   * process.nextTick).
+   */
+  runAllTicks(): void,
+  /**
+   * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+   * setInterval(), and setImmediate()).
+   */
+  runAllTimers(): void,
+  /**
+   * Exhausts all tasks queued by setImmediate().
+   */
+  runAllImmediates(): void,
+  /**
+   * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+   * or setInterval() and setImmediate()).
+   */
+  advanceTimersByTime(msToRun: number): void,
+  /**
+   * Executes only the macro-tasks that are currently pending (i.e., only the
+   * tasks that have been queued by setTimeout() or setInterval() up to this
+   * point)
+   */
+  runOnlyPendingTimers(): void,
+  /**
+   * Explicitly supplies the mock object that the module system should return
+   * for the specified module. Note: It is recommended to use jest.mock()
+   * instead.
+   */
+  setMock(moduleName: string, moduleExports: any): JestObjectType,
+  /**
+   * Indicates that the module system should never return a mocked version of
+   * the specified module from require() (e.g. that it should always return the
+   * real module).
+   */
+  unmock(moduleName: string): JestObjectType,
+  /**
+   * Instructs Jest to use fake versions of the standard timer functions
+   * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+   * setImmediate and clearImmediate).
+   */
+  useFakeTimers(fakeTimersConfig?: FakeTimersConfig): JestObjectType,
+  /**
+   * Instructs Jest to use the real versions of the standard timer functions.
+   */
+  useRealTimers(): JestObjectType,
+  /**
+   * Creates a mock function similar to jest.fn but also tracks calls to
+   * object[methodName].
+   */
+  spyOn(
+    object: Object,
+    methodName: string,
+    accessType?: 'get' | 'set'
+  ): JestMockFn<any, any>,
+  /**
+   * Set the default timeout interval for tests and before/after hooks in milliseconds.
+   * Note: The default timeout interval is 5 seconds if this method is not called.
+   */
+  setTimeout(timeout: number): JestObjectType,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+  /**
+   * Creates a block that groups together several related tests in one "test suite"
+   */
+  (name: JestTestName, fn: () => void): void,
+  /**
+   * Only run this describe block
+   */
+  only(name: JestTestName, fn: () => void): void,
+  /**
+   * Skip running this describe block
+   */
+  skip(name: JestTestName, fn: () => void): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+/** An individual test unit */
+declare var it: {
+  /**
+   * An individual test unit
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  (
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * Only run this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  only: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Skip running this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  skip: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Highlight planned tests in the summary output
+   *
+   * @param {String} Name of Test to do
+   */
+  todo(name: string): void,
+  /**
+   * Run the test concurrently
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  concurrent(
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+  comment: {
+    close: string,
+    open: string,
+    ...
+  },
+  content: {
+    close: string,
+    open: string,
+    ...
+  },
+  prop: {
+    close: string,
+    open: string,
+    ...
+  },
+  tag: {
+    close: string,
+    open: string,
+    ...
+  },
+  value: {
+    close: string,
+    open: string,
+    ...
+  },
+  ...
+};
+
+type JestPrettyFormatIndent = (string) => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = (any) => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+  print: (
+    val: any,
+    serialize: JestPrettyFormatPrint,
+    indent: JestPrettyFormatIndent,
+    opts: JestPrettyFormatOptions,
+    colors: JestPrettyFormatColors
+  ) => string,
+  test: (any) => boolean,
+  ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+  /** The object that you want to make assertions against */
+  (
+    value: any
+  ): JestExpectType &
+    JestPromiseType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType,
+  /** Add additional Jasmine matchers to Jest's roster */
+  extend(matchers: { [name: string]: JestMatcher, ... }): void,
+  /** Add a module that formats application-specific data structures. */
+  addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+  assertions(expectedAssertions: number): void,
+  hasAssertions(): void,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  objectContaining(value: Object): Object,
+  /** Matches any received string that contains the exact expected string. */
+  stringContaining(value: string): string,
+  stringMatching(value: string | RegExp): string,
+  not: {
+    arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+    objectContaining: (value: { ... }) => Object,
+    stringContaining: (value: string) => string,
+    stringMatching: (value: string | RegExp) => string,
+    ...
+  },
+  ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  createSpyObj(
+    baseName: string,
+    methodNames: Array<string>
+  ): { [methodName: string]: JestSpyType, ... },
+  objectContaining(value: Object): Object,
+  stringMatching(value: string): string,
+  ...
+};
diff --git a/definitions/npm/jest_v29.x.x/flow_v0.134.x-/test_jest_v29.x.x.js b/definitions/npm/jest_v28.x.x/flow_v0.201.x-/test_jest_v28.x.x.js
similarity index 100%
rename from definitions/npm/jest_v29.x.x/flow_v0.134.x-/test_jest_v29.x.x.js
rename to definitions/npm/jest_v28.x.x/flow_v0.201.x-/test_jest_v28.x.x.js
diff --git a/definitions/npm/jest_v29.x.x/flow_v0.134.x-/jest_v29.x.x.js b/definitions/npm/jest_v29.x.x/flow_v0.134.x-v.200.x/jest_v29.x.x.js
similarity index 100%
rename from definitions/npm/jest_v29.x.x/flow_v0.134.x-/jest_v29.x.x.js
rename to definitions/npm/jest_v29.x.x/flow_v0.134.x-v.200.x/jest_v29.x.x.js
diff --git a/definitions/npm/jest_v29.x.x/flow_v0.134.x-v.200.x/test_jest_v29.x.x.js b/definitions/npm/jest_v29.x.x/flow_v0.134.x-v.200.x/test_jest_v29.x.x.js
new file mode 100644
index 0000000000..60b2993731
--- /dev/null
+++ b/definitions/npm/jest_v29.x.x/flow_v0.134.x-v.200.x/test_jest_v29.x.x.js
@@ -0,0 +1,803 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.useFakeTimers({ legacyFakeTimers: true });
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.lastCall[0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.lastCall[0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name');
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name');
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot(
+  'foobar',
+  undefined,
+  'snapshot difference between two strings'
+);
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) => expect(a).toMatchSnapshot());
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([
+  ['arg1', 'arg2'],
+  ['arg2', 'arg3'],
+])('test', (a, b) => expect(a).toMatchDiffSnapshot(b));
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+test.skip.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done('foo');
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+jest.setSystemTime();
+jest.setSystemTime(123);
+jest.setSystemTime(new Date());
+// $FlowExpectedError[incompatible-call]
+jest.setSystemTime('');
+
+jest.genMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.genMockFromModule(1);
+
+jest.createMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.createMockFromModule(1);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  expect(element).toHaveStyle('color: blue');
+  expect(element).toHaveStyle({ color: 'blue' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toHaveDisplayValue('test');
+  expect(element).toHaveDisplayValue(['foo', 'bar']);
+  expect(element).toBeChecked();
+  expect(element).toBeEmptyDOMElement();
+  expect(element).toBePartiallyChecked();
+
+  // $FlowExpectedError[incompatible-call]: expected description should be present
+  expect(element).toHaveDescription();
+  expect(element).toHaveDescription('foo');
+  expect(element).toHaveDescription(/[0-9]/);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveDescription(true);
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([
+      ['a', 'foo'],
+      ['b', 'bar'],
+      ['c', 'baz'],
+    ]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([
+      ['a', 'qux'],
+      ['a', 'foo'],
+    ]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`('x=$x, y=$y, and z=$z', ({ x, y, z }) => {
+  // perform tests
+});
diff --git a/definitions/npm/jest_v29.x.x/flow_v0.201.x-/jest_v29.x.x.js b/definitions/npm/jest_v29.x.x/flow_v0.201.x-/jest_v29.x.x.js
new file mode 100644
index 0000000000..e94146f28e
--- /dev/null
+++ b/definitions/npm/jest_v29.x.x/flow_v0.201.x-/jest_v29.x.x.js
@@ -0,0 +1,1264 @@
+type JestMockFn<TArguments: $ReadOnlyArray<any>, TReturn> = {
+  (...args: TArguments): TReturn,
+  /**
+   * An object for introspecting mock calls
+   */
+  mock: {
+    /**
+     * An array that represents all calls that have been made into this mock
+     * function. Each call is represented by an array of arguments that were
+     * passed during the call.
+     */
+    calls: Array<TArguments>,
+    /**
+     * An array containing the call arguments of the last call that was made
+     * to this mock function. If the function was not called, it will return
+     * undefined.
+     */
+    lastCall: TArguments,
+    /**
+     * An array that contains all the object instances that have been
+     * instantiated from this mock function.
+     */
+    instances: Array<TReturn>,
+    /**
+     * An array that contains all the object results that have been
+     * returned by this mock function call
+     */
+    results: Array<{
+      isThrow: boolean,
+      value: TReturn,
+      ...
+    }>,
+    ...
+  },
+  /**
+   * Resets all information stored in the mockFn.mock.calls and
+   * mockFn.mock.instances arrays. Often this is useful when you want to clean
+   * up a mock's usage data between two assertions.
+   */
+  mockClear(): void,
+  /**
+   * Resets all information stored in the mock. This is useful when you want to
+   * completely restore a mock back to its initial state.
+   */
+  mockReset(): void,
+  /**
+   * Removes the mock and restores the initial implementation. This is useful
+   * when you want to mock functions in certain test cases and restore the
+   * original implementation in others. Beware that mockFn.mockRestore only
+   * works when mock was created with jest.spyOn. Thus you have to take care of
+   * restoration yourself when manually assigning jest.fn().
+   */
+  mockRestore(): void,
+  /**
+   * Accepts a function that should be used as the implementation of the mock.
+   * The mock itself will still record all calls that go into and instances
+   * that come from itself -- the only difference is that the implementation
+   * will also be executed when the mock is called.
+   */
+  mockImplementation(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a function that will be used as an implementation of the mock for
+   * one call to the mocked function. Can be chained so that multiple function
+   * calls produce different results.
+   */
+  mockImplementationOnce(
+    fn: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Accepts a string to use in test result output in place of "jest.fn()" to
+   * indicate which mock function is being referenced.
+   */
+  mockName(name: string): JestMockFn<TArguments, TReturn>,
+  /**
+   * Just a simple sugar function for returning `this`
+   */
+  mockReturnThis(): void,
+  /**
+   * Accepts a value that will be returned whenever the mock function is called.
+   */
+  mockReturnValue(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for only returning a value once inside your mock
+   */
+  mockReturnValueOnce(value: TReturn): JestMockFn<TArguments, TReturn>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.resolve(value))
+   */
+  mockResolvedValue(value: TReturn): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.resolve(value))
+   */
+  mockResolvedValueOnce(
+    value: TReturn
+  ): JestMockFn<TArguments, Promise<TReturn>>,
+  /**
+   * Sugar for jest.fn().mockImplementation(() => Promise.reject(value))
+   */
+  mockRejectedValue(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  /**
+   * Sugar for jest.fn().mockImplementationOnce(() => Promise.reject(value))
+   */
+  mockRejectedValueOnce(value: TReturn): JestMockFn<TArguments, Promise<any>>,
+  ...
+};
+
+type JestAsymmetricEqualityType = {
+  /**
+   * A custom Jasmine equality tester
+   */
+  asymmetricMatch(value: mixed): boolean,
+  ...
+};
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestMatcherResult = {
+  message?: string | (() => string),
+  pass: boolean,
+  ...
+};
+
+type JestMatcher = (
+  received: any,
+  ...actual: Array<any>
+) => JestMatcherResult | Promise<JestMatcherResult>;
+
+type JestPromiseType = {
+  /**
+   * Use rejects to unwrap the reason of a rejected promise so any other
+   * matcher can be chained. If the promise is fulfilled the assertion fails.
+   */
+  rejects: JestExpectType,
+  /**
+   * Use resolves to unwrap the value of a fulfilled promise so any other
+   * matcher can be chained. If the promise is rejected the assertion fails.
+   */
+  resolves: JestExpectType,
+  ...
+};
+
+/**
+ * Jest allows functions and classes to be used as test names in test() and
+ * describe()
+ */
+type JestTestName = string | Function;
+
+type FakeableAPI =
+  | 'Date'
+  | 'hrtime'
+  | 'nextTick'
+  | 'performance'
+  | 'queueMicrotask'
+  | 'requestAnimationFrame'
+  | 'cancelAnimationFrame'
+  | 'requestIdleCallback'
+  | 'cancelIdleCallback'
+  | 'setImmediate'
+  | 'clearImmediate'
+  | 'setInterval'
+  | 'clearInterval'
+  | 'setTimeout'
+  | 'clearTimeout';
+
+type FakeTimersConfig = {
+  advanceTimers?: boolean | number,
+  doNotFake?: Array<FakeableAPI>,
+  now?: number | Date,
+  timerLimit?: number,
+  legacyFakeTimers?: boolean,
+  ...
+};
+
+/**
+ *  Plugin: jest-styled-components
+ */
+
+type JestStyledComponentsMatcherValue =
+  | string
+  | JestAsymmetricEqualityType
+  | RegExp
+  | typeof undefined;
+
+type JestStyledComponentsMatcherOptions = {
+  media?: string,
+  modifier?: string,
+  supports?: string,
+  ...
+};
+
+type JestStyledComponentsMatchersType = {
+  toHaveStyleRule(
+    property: string,
+    value: JestStyledComponentsMatcherValue,
+    options?: JestStyledComponentsMatcherOptions
+  ): void,
+  ...
+};
+
+/**
+ *  Plugin: jest-enzyme
+ */
+type EnzymeMatchersType = {
+  // 5.x
+  toBeEmpty(): void,
+  toBePresent(): void,
+  // 6.x
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmptyRender(): void,
+  toContainMatchingElement(selector: string): void,
+  toContainMatchingElements(n: number, selector: string): void,
+  toContainExactlyOneMatchingElement(selector: string): void,
+  toContainReact(element: React$Element<any>): void,
+  toExist(): void,
+  toHaveClassName(className: string): void,
+  toHaveHTML(html: string): void,
+  toHaveProp: ((propKey: string, propValue?: any) => void) &
+    ((props: { ... }) => void),
+  toHaveRef(refName: string): void,
+  toHaveState: ((stateKey: string, stateValue?: any) => void) &
+    ((state: { ... }) => void),
+  toHaveStyle: ((styleKey: string, styleValue?: any) => void) &
+    ((style: { ... }) => void),
+  toHaveTagName(tagName: string): void,
+  toHaveText(text: string): void,
+  toHaveValue(value: any): void,
+  toIncludeText(text: string): void,
+  toMatchElement(
+    element: React$Element<any>,
+    options?: {| ignoreProps?: boolean, verbose?: boolean |}
+  ): void,
+  toMatchSelector(selector: string): void,
+  // 7.x
+  toHaveDisplayName(name: string): void,
+  ...
+};
+
+// DOM testing library extensions (jest-dom)
+// https://github.com/testing-library/jest-dom
+type DomTestingLibraryType = {
+  /**
+   * @deprecated
+   */
+  toBeInTheDOM(container?: HTMLElement): void,
+
+  // 4.x
+  toBeInTheDocument(): void,
+  toBeVisible(): void,
+  toBeEmpty(): void,
+  toBeDisabled(): void,
+  toBeEnabled(): void,
+  toBeInvalid(): void,
+  toBeRequired(): void,
+  toBeValid(): void,
+  toContainElement(element: HTMLElement | null): void,
+  toContainHTML(htmlText: string): void,
+  toHaveAttribute(attr: string, value?: any): void,
+  toHaveClass(...classNames: string[]): void,
+  toHaveFocus(): void,
+  toHaveFormValues(expectedValues: { [name: string]: any, ... }): void,
+  toHaveStyle(css: string | { [name: string]: any, ... }): void,
+  toHaveTextContent(
+    text: string | RegExp,
+    options?: {| normalizeWhitespace: boolean |}
+  ): void,
+  toHaveValue(value?: string | string[] | number): void,
+
+  // 5.x
+  toHaveDisplayValue(value: string | string[]): void,
+  toBeChecked(): void,
+  toBeEmptyDOMElement(): void,
+  toBePartiallyChecked(): void,
+  toHaveDescription(text: string | RegExp): void,
+  ...
+};
+
+// Jest JQuery Matchers: https://github.com/unindented/custom-jquery-matchers
+type JestJQueryMatchersType = {
+  toExist(): void,
+  toHaveLength(len: number): void,
+  toHaveId(id: string): void,
+  toHaveClass(className: string): void,
+  toHaveTag(tag: string): void,
+  toHaveAttr(key: string, val?: any): void,
+  toHaveProp(key: string, val?: any): void,
+  toHaveText(text: string | RegExp): void,
+  toHaveData(key: string, val?: any): void,
+  toHaveValue(val: any): void,
+  toHaveCss(css: { [key: string]: any, ... }): void,
+  toBeChecked(): void,
+  toBeDisabled(): void,
+  toBeEmpty(): void,
+  toBeHidden(): void,
+  toBeSelected(): void,
+  toBeVisible(): void,
+  toBeFocused(): void,
+  toBeInDom(): void,
+  toBeMatchedBy(sel: string): void,
+  toHaveDescendant(sel: string): void,
+  toHaveDescendantWithText(sel: string, text: string | RegExp): void,
+  ...
+};
+
+// Jest Extended Matchers: https://github.com/jest-community/jest-extended
+type JestExtendedMatchersType = {
+  /**
+   * Note: Currently unimplemented
+   * Passing assertion
+   *
+   * @param {String} message
+   */
+  //  pass(message: string): void;
+
+  /**
+   * Note: Currently unimplemented
+   * Failing assertion
+   *
+   * @param {String} message
+   */
+  //  fail(message: string): void;
+
+  /**
+   * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty.
+   */
+  toBeEmpty(): void,
+  /**
+   * Use .toBeOneOf when checking if a value is a member of a given Array.
+   * @param {Array.<*>} members
+   */
+  toBeOneOf(members: any[]): void,
+  /**
+   * Use `.toBeNil` when checking a value is `null` or `undefined`.
+   */
+  toBeNil(): void,
+  /**
+   * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`.
+   * @param {Function} predicate
+   */
+  toSatisfy(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeArray` when checking if a value is an `Array`.
+   */
+  toBeArray(): void,
+  /**
+   * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x.
+   * @param {Number} x
+   */
+  toBeArrayOfSize(x: number): void,
+  /**
+   * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAllMembers(members: any[]): void,
+  /**
+   * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set.
+   * @param {Array.<*>} members
+   */
+  toIncludeAnyMembers(members: any[]): void,
+  /**
+   * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array.
+   * @param {Function} predicate
+   */
+  toSatisfyAll(predicate: (n: any) => boolean): void,
+  /**
+   * Use `.toBeBoolean` when checking if a value is a `Boolean`.
+   */
+  toBeBoolean(): void,
+  /**
+   * Use `.toBeTrue` when checking a value is equal (===) to `true`.
+   */
+  toBeTrue(): void,
+  /**
+   * Use `.toBeFalse` when checking a value is equal (===) to `false`.
+   */
+  toBeFalse(): void,
+  /**
+   * Use .toBeDate when checking if a value is a Date.
+   */
+  toBeDate(): void,
+  /**
+   * Use `.toBeFunction` when checking if a value is a `Function`.
+   */
+  toBeFunction(): void,
+  /**
+   * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`.
+   *
+   * Note: Required Jest version >22
+   * Note: Your mock functions will have to be asynchronous to cause the timestamps inside of Jest to occur in a differentJS event loop, otherwise the mock timestamps will all be the same
+   *
+   * @param {Mock} mock
+   */
+  toHaveBeenCalledBefore(mock: JestMockFn<any, any>): void,
+  /**
+   * Use `.toBeNumber` when checking if a value is a `Number`.
+   */
+  toBeNumber(): void,
+  /**
+   * Use `.toBeNaN` when checking a value is `NaN`.
+   */
+  toBeNaN(): void,
+  /**
+   * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`.
+   */
+  toBeFinite(): void,
+  /**
+   * Use `.toBePositive` when checking if a value is a positive `Number`.
+   */
+  toBePositive(): void,
+  /**
+   * Use `.toBeNegative` when checking if a value is a negative `Number`.
+   */
+  toBeNegative(): void,
+  /**
+   * Use `.toBeEven` when checking if a value is an even `Number`.
+   */
+  toBeEven(): void,
+  /**
+   * Use `.toBeOdd` when checking if a value is an odd `Number`.
+   */
+  toBeOdd(): void,
+  /**
+   * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).
+   *
+   * @param {Number} start
+   * @param {Number} end
+   */
+  toBeWithin(start: number, end: number): void,
+  /**
+   * Use `.toBeObject` when checking if a value is an `Object`.
+   */
+  toBeObject(): void,
+  /**
+   * Use `.toContainKey` when checking if an object contains the provided key.
+   *
+   * @param {String} key
+   */
+  toContainKey(key: string): void,
+  /**
+   * Use `.toContainKeys` when checking if an object has all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAllKeys(keys: string[]): void,
+  /**
+   * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys.
+   *
+   * @param {Array.<String>} keys
+   */
+  toContainAnyKeys(keys: string[]): void,
+  /**
+   * Use `.toContainValue` when checking if an object contains the provided value.
+   *
+   * @param {*} value
+   */
+  toContainValue(value: any): void,
+  /**
+   * Use `.toContainValues` when checking if an object contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainValues(values: any[]): void,
+  /**
+   * Use `.toContainAllValues` when checking if an object only contains all of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAllValues(values: any[]): void,
+  /**
+   * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values.
+   *
+   * @param {Array.<*>} values
+   */
+  toContainAnyValues(values: any[]): void,
+  /**
+   * Use `.toContainEntry` when checking if an object contains the provided entry.
+   *
+   * @param {Array.<String, String>} entry
+   */
+  toContainEntry(entry: [string, string]): void,
+  /**
+   * Use `.toContainEntries` when checking if an object contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAllEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries.
+   *
+   * @param {Array.<Array.<String, String>>} entries
+   */
+  toContainAnyEntries(entries: [string, string][]): void,
+  /**
+   * Use `.toBeExtensible` when checking if an object is extensible.
+   */
+  toBeExtensible(): void,
+  /**
+   * Use `.toBeFrozen` when checking if an object is frozen.
+   */
+  toBeFrozen(): void,
+  /**
+   * Use `.toBeSealed` when checking if an object is sealed.
+   */
+  toBeSealed(): void,
+  /**
+   * Use `.toBeString` when checking if a value is a `String`.
+   */
+  toBeString(): void,
+  /**
+   * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings.
+   *
+   * @param {String} string
+   */
+  toEqualCaseInsensitive(string: string): void,
+  /**
+   * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix.
+   *
+   * @param {String} prefix
+   */
+  toStartWith(prefix: string): void,
+  /**
+   * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix.
+   *
+   * @param {String} suffix
+   */
+  toEndWith(suffix: string): void,
+  /**
+   * Use `.toInclude` when checking if a `String` includes the given `String` substring.
+   *
+   * @param {String} substring
+   */
+  toInclude(substring: string): void,
+  /**
+   * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times.
+   *
+   * @param {String} substring
+   * @param {Number} times
+   */
+  toIncludeRepeated(substring: string, times: number): void,
+  /**
+   * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings.
+   *
+   * @param {Array.<String>} substring
+   */
+  toIncludeMultiple(substring: string[]): void,
+  ...
+};
+
+// Diffing snapshot utility for Jest (snapshot-diff)
+// https://github.com/jest-community/snapshot-diff
+type SnapshotDiffType = {
+  /**
+   * Compare the difference between the actual in the `expect()`
+   * vs the object inside `valueB` with some extra options.
+   */
+  toMatchDiffSnapshot(
+    valueB: any,
+    options?: {|
+      expand?: boolean,
+      colors?: boolean,
+      contextLines?: number,
+      stablePatchmarks?: boolean,
+      aAnnotation?: string,
+      bAnnotation?: string,
+    |},
+    testName?: string
+  ): void,
+  ...
+};
+
+interface JestExpectType {
+  not: JestExpectType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType;
+  /**
+   * If you have a mock function, you can use .lastCalledWith to test what
+   * arguments it was last called with.
+   */
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * toBe just checks that a value is what you expect. It uses === to check
+   * strict equality.
+   */
+  toBe(value: any): void;
+  /**
+   * Use .toBeCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Using exact equality with floating point numbers is a bad idea. Rounding
+   * means that intuitive things fail.
+   */
+  toBeCloseTo(num: number, delta: any): void;
+  /**
+   * Use .toBeDefined to check that a variable is not undefined.
+   */
+  toBeDefined(): void;
+  /**
+   * Use .toBeFalsy when you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   */
+  toBeFalsy(): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThan.
+   */
+  toBeGreaterThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeGreaterThanOrEqual.
+   */
+  toBeGreaterThanOrEqual(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThan.
+   */
+  toBeLessThan(number: number): void;
+  /**
+   * To compare floating point numbers, you can use toBeLessThanOrEqual.
+   */
+  toBeLessThanOrEqual(number: number): void;
+  /**
+   * Use .toBeInstanceOf(Class) to check that an object is an instance of a
+   * class.
+   */
+  toBeInstanceOf(cls: Class<any>): void;
+  /**
+   * .toBeNull() is the same as .toBe(null) but the error messages are a bit
+   * nicer.
+   */
+  toBeNull(): void;
+  /**
+   * Use .toBeTruthy when you don't care what a value is, you just want to
+   * ensure a value is true in a boolean context.
+   */
+  toBeTruthy(): void;
+  /**
+   * Use .toBeUndefined to check that a variable is undefined.
+   */
+  toBeUndefined(): void;
+  /**
+   * Use .toContain when you want to check that an item is in a list. For
+   * testing the items in the list, this uses ===, a strict equality check.
+   */
+  toContain(item: any): void;
+  /**
+   * Use .toContainEqual when you want to check that an item is in a list. For
+   * testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   */
+  toContainEqual(item: any): void;
+  /**
+   * Use .toEqual when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than
+   * checking for object identity.
+   */
+  toEqual(value: any): void;
+  /**
+   * Use .toHaveBeenCalled to ensure that a mock function got called.
+   */
+  toHaveBeenCalled(): void;
+  toBeCalled(): void;
+  /**
+   * Use .toHaveBeenCalledTimes to ensure that a mock function got called exact
+   * number of times.
+   */
+  toHaveBeenCalledTimes(number: number): void;
+  toBeCalledTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveBeenNthCalledWith(nthCall: number, ...args: Array<any>): void;
+  nthCalledWith(nthCall: number, ...args: Array<any>): void;
+  /**
+   *
+   */
+  toHaveReturned(): void;
+  toReturn(): void;
+  /**
+   *
+   */
+  toHaveReturnedTimes(number: number): void;
+  toReturnTimes(number: number): void;
+  /**
+   *
+   */
+  toHaveReturnedWith(value: any): void;
+  toReturnWith(value: any): void;
+  /**
+   *
+   */
+  toHaveLastReturnedWith(value: any): void;
+  lastReturnedWith(value: any): void;
+  /**
+   *
+   */
+  toHaveNthReturnedWith(nthCall: number, value: any): void;
+  nthReturnedWith(nthCall: number, value: any): void;
+  /**
+   * Use .toHaveBeenCalledWith to ensure that a mock function was called with
+   * specific arguments.
+   */
+  toHaveBeenCalledWith(...args: Array<any>): void;
+  toBeCalledWith(...args: Array<any>): void;
+  /**
+   * Use .toHaveBeenLastCalledWith to ensure that a mock function was last called
+   * with specific arguments.
+   */
+  toHaveBeenLastCalledWith(...args: Array<any>): void;
+  lastCalledWith(...args: Array<any>): void;
+  /**
+   * Check that an object has a .length property and it is set to a certain
+   * numeric value.
+   */
+  toHaveLength(number: number): void;
+  /**
+   *
+   */
+  toHaveProperty(propPath: string | $ReadOnlyArray<string>, value?: any): void;
+  /**
+   * Use .toMatch to check that a string matches a regular expression or string.
+   */
+  toMatch(regexpOrString: RegExp | string): void;
+  /**
+   * Use .toMatchObject to check that a javascript object matches a subset of the properties of an object.
+   */
+  toMatchObject(object: Object | Array<Object>): void;
+  /**
+   * Use .toStrictEqual to check that a javascript object matches a subset of the properties of an object.
+   */
+  toStrictEqual(value: any): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(propertyMatchers?: any, name?: string): void;
+  /**
+   * This ensures that an Object matches the most recent snapshot.
+   */
+  toMatchSnapshot(name: string): void;
+
+  toMatchInlineSnapshot(snapshot?: string): void;
+  toMatchInlineSnapshot(propertyMatchers?: any, snapshot?: string): void;
+  /**
+   * Use .toThrow to test that a function throws when it is called.
+   * If you want to test that a specific error gets thrown, you can provide an
+   * argument to toThrow. The argument can be a string for the error message,
+   * a class for the error, or a regex that should match the error.
+   *
+   * Alias: .toThrowError
+   */
+  toThrow(message?: string | Error | Class<Error> | RegExp): void;
+  toThrowError(message?: string | Error | Class<Error> | RegExp): void;
+  /**
+   * Use .toThrowErrorMatchingSnapshot to test that a function throws a error
+   * matching the most recent snapshot when it is called.
+   */
+  toThrowErrorMatchingSnapshot(): void;
+  toThrowErrorMatchingInlineSnapshot(snapshot?: string): void;
+}
+
+type JestObjectType = {
+  /**
+   *  Disables automatic mocking in the module loader.
+   *
+   *  After this method is called, all `require()`s will return the real
+   *  versions of each module (rather than a mocked version).
+   */
+  disableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of disableAutomock
+   */
+  autoMockOff(): JestObjectType,
+  /**
+   * Enables automatic mocking in the module loader.
+   */
+  enableAutomock(): JestObjectType,
+  /**
+   * An un-hoisted version of enableAutomock
+   */
+  autoMockOn(): JestObjectType,
+  /**
+   * Clears the mock.calls and mock.instances properties of all mocks.
+   * Equivalent to calling .mockClear() on every mocked function.
+   */
+  clearAllMocks(): JestObjectType,
+  /**
+   * Resets the state of all mocks. Equivalent to calling .mockReset() on every
+   * mocked function.
+   */
+  resetAllMocks(): JestObjectType,
+  /**
+   * Restores all mocks back to their original value.
+   */
+  restoreAllMocks(): JestObjectType,
+  /**
+   * Removes any pending timers from the timer system.
+   */
+  clearAllTimers(): void,
+  /**
+   * Returns the number of fake timers still left to run.
+   */
+  getTimerCount(): number,
+  /**
+   * Set the current system time used by fake timers.
+   * Simulates a user changing the system clock while your program is running.
+   * It affects the current time but it does not in itself cause
+   * e.g. timers to fire; they will fire exactly as they would have done
+   * without the call to jest.setSystemTime().
+   */
+  setSystemTime(now?: number | Date): void,
+  /**
+   * The same as `mock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  doMock(moduleName: string, moduleFactory?: any): JestObjectType,
+  /**
+   * The same as `unmock` but not moved to the top of the expectation by
+   * babel-jest.
+   */
+  dontMock(moduleName: string): JestObjectType,
+  /**
+   * Returns a new, unused mock function. Optionally takes a mock
+   * implementation.
+   */
+  fn<TArguments: $ReadOnlyArray<any>, TReturn>(
+    implementation?: (...args: TArguments) => TReturn
+  ): JestMockFn<TArguments, TReturn>,
+  /**
+   * Determines if the given function is a mocked function.
+   */
+  isMockFunction(fn: Function): boolean,
+  /**
+   * Alias of `createMockFromModule`.
+   */
+  genMockFromModule(moduleName: string): any,
+  /**
+   * Given the name of a module, use the automatic mocking system to generate a
+   * mocked version of the module for you.
+   */
+  createMockFromModule(moduleName: string): any,
+  /**
+   * Mocks a module with an auto-mocked version when it is being required.
+   *
+   * The second argument can be used to specify an explicit module factory that
+   * is being run instead of using Jest's automocking feature.
+   *
+   * The third argument can be used to create virtual mocks -- mocks of modules
+   * that don't exist anywhere in the system.
+   */
+  mock(
+    moduleName: string,
+    moduleFactory?: any,
+    options?: Object
+  ): JestObjectType,
+  /**
+   * Returns the actual module instead of a mock, bypassing all checks on
+   * whether the module should receive a mock implementation or not.
+   */
+  requireActual<T>(m: $Flow$ModuleRef<T> | string): T,
+  /**
+   * Returns a mock module instead of the actual module, bypassing all checks
+   * on whether the module should be required normally or not.
+   */
+  requireMock(moduleName: string): any,
+  /**
+   * Resets the module registry - the cache of all required modules. This is
+   * useful to isolate modules where local state might conflict between tests.
+   */
+  resetModules(): JestObjectType,
+  /**
+   * Creates a sandbox registry for the modules that are loaded inside the
+   * callback function. This is useful to isolate specific modules for every
+   * test so that local module state doesn't conflict between tests.
+   */
+  isolateModules(fn: () => void): JestObjectType,
+  /**
+   * Exhausts the micro-task queue (usually interfaced in node via
+   * process.nextTick).
+   */
+  runAllTicks(): void,
+  /**
+   * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout(),
+   * setInterval(), and setImmediate()).
+   */
+  runAllTimers(): void,
+  /**
+   * Exhausts all tasks queued by setImmediate().
+   */
+  runAllImmediates(): void,
+  /**
+   * Executes only the macro task queue (i.e. all tasks queued by setTimeout()
+   * or setInterval() and setImmediate()).
+   */
+  advanceTimersByTime(msToRun: number): void,
+  /**
+   * Executes only the macro-tasks that are currently pending (i.e., only the
+   * tasks that have been queued by setTimeout() or setInterval() up to this
+   * point)
+   */
+  runOnlyPendingTimers(): void,
+  /**
+   * Explicitly supplies the mock object that the module system should return
+   * for the specified module. Note: It is recommended to use jest.mock()
+   * instead.
+   */
+  setMock(moduleName: string, moduleExports: any): JestObjectType,
+  /**
+   * Indicates that the module system should never return a mocked version of
+   * the specified module from require() (e.g. that it should always return the
+   * real module).
+   */
+  unmock(moduleName: string): JestObjectType,
+  /**
+   * Instructs Jest to use fake versions of the standard timer functions
+   * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
+   * setImmediate and clearImmediate).
+   */
+  useFakeTimers(fakeTimersConfig?: FakeTimersConfig): JestObjectType,
+  /**
+   * Instructs Jest to use the real versions of the standard timer functions.
+   */
+  useRealTimers(): JestObjectType,
+  /**
+   * Creates a mock function similar to jest.fn but also tracks calls to
+   * object[methodName].
+   */
+  spyOn(
+    object: Object,
+    methodName: string,
+    accessType?: 'get' | 'set'
+  ): JestMockFn<any, any>,
+  /**
+   * Set the default timeout interval for tests and before/after hooks in milliseconds.
+   * Note: The default timeout interval is 5 seconds if this method is not called.
+   */
+  setTimeout(timeout: number): JestObjectType,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+type JestDoneFn = {|
+  (error?: Error): void,
+  fail: (error: Error) => void,
+|};
+
+/** Runs this function after every test inside this context */
+declare function afterEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before every test inside this context */
+declare function beforeEach(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function after all tests have finished inside this context */
+declare function afterAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** Runs this function before any tests have started inside this context */
+declare function beforeAll(
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+
+/** A context for grouping tests together */
+declare var describe: {
+  /**
+   * Creates a block that groups together several related tests in one "test suite"
+   */
+  (name: JestTestName, fn: () => void): void,
+  /**
+   * Only run this describe block
+   */
+  only(name: JestTestName, fn: () => void): void,
+  /**
+   * Skip running this describe block
+   */
+  skip(name: JestTestName, fn: () => void): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+/** An individual test unit */
+declare var it: {
+  /**
+   * An individual test unit
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  (
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * Only run this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  only: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Skip running this test
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  skip: {|
+    (
+      name: JestTestName,
+      fn?: (done: JestDoneFn) => ?Promise<mixed>,
+      timeout?: number
+    ): void,
+    each(
+      ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+    ): (
+      name: JestTestName,
+      fn?: (...args: Array<any>) => ?Promise<mixed>,
+      timeout?: number
+    ) => void,
+  |},
+  /**
+   * Highlight planned tests in the summary output
+   *
+   * @param {String} Name of Test to do
+   */
+  todo(name: string): void,
+  /**
+   * Run the test concurrently
+   *
+   * @param {JestTestName} Name of Test
+   * @param {Function} Test
+   * @param {number} Timeout for the test, in milliseconds.
+   */
+  concurrent(
+    name: JestTestName,
+    fn?: (done: JestDoneFn) => ?Promise<mixed>,
+    timeout?: number
+  ): void,
+  /**
+   * each runs this test against array of argument arrays per each run
+   *
+   * @param {table} table of Test
+   */
+  each(
+    ...table: Array<Array<mixed> | mixed> | [Array<string>, string]
+  ): (
+    name: JestTestName,
+    fn?: (...args: Array<any>) => ?Promise<mixed>,
+    timeout?: number
+  ) => void,
+  ...
+};
+
+declare function fit(
+  name: JestTestName,
+  fn: (done: JestDoneFn) => ?Promise<mixed>,
+  timeout?: number
+): void;
+/** An individual test unit */
+declare var test: typeof it;
+/** A disabled group of tests */
+declare var xdescribe: typeof describe;
+/** A focused group of tests */
+declare var fdescribe: typeof describe;
+/** A disabled individual test */
+declare var xit: typeof it;
+/** A disabled individual test */
+declare var xtest: typeof it;
+
+type JestPrettyFormatColors = {
+  comment: {
+    close: string,
+    open: string,
+    ...
+  },
+  content: {
+    close: string,
+    open: string,
+    ...
+  },
+  prop: {
+    close: string,
+    open: string,
+    ...
+  },
+  tag: {
+    close: string,
+    open: string,
+    ...
+  },
+  value: {
+    close: string,
+    open: string,
+    ...
+  },
+  ...
+};
+
+type JestPrettyFormatIndent = (string) => string;
+type JestPrettyFormatRefs = Array<any>;
+type JestPrettyFormatPrint = (any) => string;
+type JestPrettyFormatStringOrNull = string | null;
+
+type JestPrettyFormatOptions = {|
+  callToJSON: boolean,
+  edgeSpacing: string,
+  escapeRegex: boolean,
+  highlight: boolean,
+  indent: number,
+  maxDepth: number,
+  min: boolean,
+  plugins: JestPrettyFormatPlugins,
+  printFunctionName: boolean,
+  spacing: string,
+  theme: {|
+    comment: string,
+    content: string,
+    prop: string,
+    tag: string,
+    value: string,
+  |},
+|};
+
+type JestPrettyFormatPlugin = {
+  print: (
+    val: any,
+    serialize: JestPrettyFormatPrint,
+    indent: JestPrettyFormatIndent,
+    opts: JestPrettyFormatOptions,
+    colors: JestPrettyFormatColors
+  ) => string,
+  test: (any) => boolean,
+  ...
+};
+
+type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
+
+/** The expect function is used every time you want to test a value */
+declare var expect: {
+  /** The object that you want to make assertions against */
+  (
+    value: any
+  ): JestExpectType &
+    JestPromiseType &
+    EnzymeMatchersType &
+    DomTestingLibraryType &
+    JestJQueryMatchersType &
+    JestStyledComponentsMatchersType &
+    JestExtendedMatchersType &
+    SnapshotDiffType,
+  /** Add additional Jasmine matchers to Jest's roster */
+  extend(matchers: { [name: string]: JestMatcher, ... }): void,
+  /** Add a module that formats application-specific data structures. */
+  addSnapshotSerializer(pluginModule: JestPrettyFormatPlugin): void,
+  assertions(expectedAssertions: number): void,
+  hasAssertions(): void,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  objectContaining(value: Object): Object,
+  /** Matches any received string that contains the exact expected string. */
+  stringContaining(value: string): string,
+  stringMatching(value: string | RegExp): string,
+  not: {
+    arrayContaining: (value: $ReadOnlyArray<mixed>) => Array<mixed>,
+    objectContaining: (value: { ... }) => Object,
+    stringContaining: (value: string) => string,
+    stringMatching: (value: string | RegExp) => string,
+    ...
+  },
+  ...
+};
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+/** Holds all functions related to manipulating test runner */
+declare var jest: JestObjectType;
+
+/**
+ * The global Jasmine object, this is generally not exposed as the public API,
+ * using features inside here could break in later versions of Jest.
+ */
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): any,
+  arrayContaining(value: Array<mixed>): Array<mixed>,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  createSpyObj(
+    baseName: string,
+    methodNames: Array<string>
+  ): { [methodName: string]: JestSpyType, ... },
+  objectContaining(value: Object): Object,
+  stringMatching(value: string): string,
+  ...
+};
diff --git a/definitions/npm/jest_v29.x.x/flow_v0.201.x-/test_jest_v29.x.x.js b/definitions/npm/jest_v29.x.x/flow_v0.201.x-/test_jest_v29.x.x.js
new file mode 100644
index 0000000000..60b2993731
--- /dev/null
+++ b/definitions/npm/jest_v29.x.x/flow_v0.201.x-/test_jest_v29.x.x.js
@@ -0,0 +1,803 @@
+/* @flow */
+/* eslint-disable */
+import * as React from 'react';
+
+jest.useFakeTimers({ legacyFakeTimers: true });
+
+jest.autoMockOff();
+jest.clearAllMocks();
+jest.resetAllMocks();
+jest.restoreAllMocks();
+
+// $FlowExpectedError[prop-missing] property `atoMockOff` not found in object type
+jest.atoMockOff();
+
+const mockFn = jest.fn();
+mockFn.mock.calls.map(String).map((a) => a + a);
+
+type Foo = {
+  doStuff: (string) => number,
+  doAsyncStuff: (string) => Promise<number>,
+  ...
+};
+const foo: Foo = {
+  doStuff(str: string): number {
+    return 5;
+  },
+  doAsyncStuff(str: string): Promise<number> {
+    return Promise.resolve(5);
+  },
+};
+
+foo.doStuff = jest.fn().mockImplementation((str) => 10);
+foo.doStuff = jest.fn().mockImplementation((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementation((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementation((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementation((str) => '10');
+foo.doStuff = jest.fn().mockImplementationOnce((str) => 10);
+foo.doStuff = jest.fn().mockImplementationOnce((str) => parseInt(str, 10));
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.indexOf('a'));
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => str.doesntExist());
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockImplementationOnce((str) => '10');
+
+foo.doStuff = jest.fn().mockReturnValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValue('10');
+
+foo.doStuff = jest.fn().mockReturnValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return number, not string.
+foo.doStuff = jest.fn().mockReturnValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValue(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValue('10');
+
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce(10);
+// $FlowExpectedError[incompatible-call] Mock function expected to return Promise<number>, not Promise<string>
+foo.doAsyncStuff = jest.fn().mockResolvedValueOnce('10');
+
+foo.doAsyncStuff = jest.fn().mockRejectedValue(10);
+foo.doAsyncStuff = jest.fn().mockRejectedValueOnce(10);
+
+foo.doStuff = jest.fn().mockName('10');
+// $FlowExpectedError[incompatible-call] mockName expects a string, not a number
+foo.doStuff = jest.fn().mockName(10);
+
+const mockedDoStuff = (foo.doStuff = jest.fn().mockImplementation((str) => 10));
+mockedDoStuff.mock.calls[0][0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.calls[0][0].doesntExist('a');
+
+mockedDoStuff.mock.lastCall[0].indexOf('a');
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in string.
+mockedDoStuff.mock.lastCall[0].doesntExist('a');
+
+mockedDoStuff.mock.instances[0] > 5;
+// $FlowExpectedError[prop-missing] function `doesntExist` not found in number.
+mockedDoStuff.mock.instances[0].indexOf('a');
+
+expect(mockedDoStuff.mock.results[0].isThrow).toBe(false);
+expect(mockedDoStuff.mock.results[0].value).toBe(10);
+// $FlowExpectedError[prop-missing]
+mockedDoStuff.mock.results[0].foo;
+
+expect(1).toEqual(1);
+expect(true).toBe(true);
+expect(5).toBeGreaterThan(3);
+expect(5).toBeLessThan(8);
+expect('jester').toContain('jest');
+expect({ foo: 'bar' }).toHaveProperty('foo');
+expect({ foo: 'bar' }).toHaveProperty('foo', 'bar');
+expect({ foo: { fizz: 'bar' } }).toHaveProperty(['foo', 'fizz'], 'bar');
+expect('foo').toMatchSnapshot('snapshot name only');
+expect('foo').toMatchSnapshot(undefined, 'snapshot name');
+expect({
+  foo: 1,
+}).toMatchSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  'snapshot name'
+);
+expect('foo').toMatchInlineSnapshot();
+expect('foo').toMatchInlineSnapshot(`"foo"`);
+expect({ foo: 1 }).toMatchInlineSnapshot({
+  foo: expect.any(Number),
+});
+expect({ foo: 1 }).toMatchInlineSnapshot(
+  {
+    foo: expect.any(Number),
+  },
+  `
+Object {
+"foo": Any<Number>,
+}
+`
+);
+// $FlowExpectedError[incompatible-call] - options must be object or undefined
+expect('foo').toMatchDiffSnapshot('any', null, 'test name');
+expect('foo').toMatchDiffSnapshot('any', {}, 'test name');
+expect('foo').toMatchDiffSnapshot('foobar');
+expect('foo').toMatchDiffSnapshot(
+  'foobar',
+  undefined,
+  'snapshot difference between two strings'
+);
+
+expect({ foo: 1 }).toMatchInlineSnapshot([]);
+expect({ foo: 'bar' }).toMatchObject({ baz: 'qux' });
+expect('foobar').toMatch(/foo/);
+expect('foobar').toMatch('foo');
+
+mockFn('a');
+expect('someVal').toBeCalled();
+expect('someVal').toBeCalledWith('a');
+
+// $FlowExpectedError[incompatible-call] property `toHaveBeeenCalledWith` not found in object type
+expect('someVal').toHaveBeeenCalledWith('a');
+
+// $FlowExpectedError[prop-missing] property `fn` not found in Array
+mockFn.mock.calls.fn();
+
+class AClass {}
+function aFunction() {}
+
+describe('name', () => {});
+describe(AClass, () => {});
+describe(aFunction, () => {});
+
+describe.only('name', () => {});
+describe.only(AClass, () => {});
+describe.only(aFunction, () => {});
+describe.each([['arg1'], ['arg2']])('test', (a) => expect(a).toMatchSnapshot());
+describe.each(['arg1', 2, true])('test', (a) => expect(a).toMatchSnapshot());
+describe.each([
+  ['arg1', 'arg2'],
+  ['arg2', 'arg3'],
+])('test', (a, b) => expect(a).toMatchDiffSnapshot(b));
+describe.each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+])('.add(%i, %i)', (a, b, expected) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+describe.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('$a + $b', ({ a, b, expected }) => {
+  test(`returns ${expected}`, () => {
+    expect(a + b).toBe(expected);
+  });
+});
+
+describe.skip('name', () => {});
+describe.skip(AClass, () => {});
+describe.skip(aFunction, () => {});
+
+test('test', () => expect('foo').toMatchSnapshot());
+test(AClass, () => expect('foo').toMatchSnapshot());
+test(aFunction, () => expect('foo').toMatchSnapshot());
+test.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.each(['arg1', 2, true])('test', () => expect('foo').toMatchSnapshot());
+test.only.each([
+  ['arg1', 2, true],
+  ['arg2', 3, false],
+])('test', () => expect('foo').toMatchSnapshot());
+test.only.each(['arg1', 2, true])('test', () =>
+  expect('foo').toMatchSnapshot()
+);
+test.only('test', () => expect('foo').toMatchSnapshot());
+test.skip('test', () => expect('foo').toMatchSnapshot());
+test.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+test.skip.each`
+  a    | b    | expected
+  ${1} | ${1} | ${2}
+  ${1} | ${2} | ${3}
+  ${2} | ${1} | ${3}
+`('returns $expected when $a is added $b', ({ a, b, expected }) => {
+  expect(a + b).toBe(expected);
+});
+
+// $FlowExpectedError[prop-missing] property `fonly` not found in object type
+test.fonly('test', () => expect('foo').toMatchSnapshot());
+
+test('name', (done) => {
+  done();
+});
+test.only('name', (done) => {
+  done();
+});
+test.skip('name', (done) => {
+  done();
+});
+test('name', (done) => {
+  done.fail(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done.fail();
+  done(new Error('fail'));
+  // $FlowExpectedError[incompatible-call]
+  done('foo');
+});
+
+test.todo('');
+// $FlowExpectedError[extra-arg]
+test.todo('', () => {});
+
+// $FlowExpectedError[incompatible-call] tests should return void or Promise.
+test('name', () => 5);
+test('name', async () => {});
+test('name', () => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] describe does not support Promises.
+describe('name', () => new Promise((resolve, reject) => {}));
+
+beforeEach(() => {});
+beforeEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeEach(() => 5);
+
+beforeAll(() => {});
+beforeAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+beforeAll(() => 5);
+
+afterEach(() => {});
+afterEach(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterEach(() => 5);
+
+afterAll(() => {});
+afterAll(() => new Promise((resolve, reject) => {}));
+// $FlowExpectedError[incompatible-call] Lifecycle methods should return void or Promise.
+afterAll(() => 5);
+
+xtest('test', () => {});
+
+// $FlowExpectedError[prop-missing] property `bar` not found in object type
+expect.bar();
+
+expect.extend({
+  blah(actual, expected) {
+    return {
+      message: () => 'blah fail',
+      pass: false,
+    };
+  },
+});
+
+expect.extend({
+  foo(actual, expected) {
+    // $FlowExpectedError[incompatible-call] property `pass` not found in object literal
+    return {};
+  },
+});
+
+expect.extend({
+  blah(actual: string, one: string, two: string, three: string) {
+    return Promise.resolve({
+      message: () => one + two + three,
+      pass: false,
+    });
+  },
+});
+
+const err = new Error('err');
+expect(() => {
+  throw err;
+}).toThrowError('err');
+
+expect(() => {
+  throw err;
+}).toThrowError(/err/);
+
+expect(() => {
+  throw err;
+}).toThrowError(err);
+
+expect(() => {}).toThrowErrorMatchingSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot();
+expect(() => {}).toThrowErrorMatchingInlineSnapshot('err');
+
+expect(() => {}).toThrow('err');
+expect(() => {}).toThrow(/err/);
+expect(() => {}).toThrow(err);
+
+(jest.getTimerCount(): number);
+// $FlowExpectedError[extra-arg]
+jest.getTimerCount(3);
+
+jest.setSystemTime();
+jest.setSystemTime(123);
+jest.setSystemTime(new Date());
+// $FlowExpectedError[incompatible-call]
+jest.setSystemTime('');
+
+jest.genMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.genMockFromModule(1);
+
+jest.createMockFromModule('../mocked');
+// $FlowExpectedError[incompatible-call]
+jest.createMockFromModule(1);
+
+// Test method chaining fixes
+jest.doMock('testModule1', () => {}).doMock('testModule2', () => {});
+
+jest.dontMock('testModule1').dontMock('testModule2');
+
+jest.resetModules().resetModules();
+
+jest.isolateModules(() => {});
+// $FlowExpectedError[incompatible-call]
+jest.isolateModules();
+
+jest.spyOn({}, 'foo', 'get');
+
+jest.setTimeout(1000);
+
+jest.advanceTimersByTime(3000);
+
+expect.addSnapshotSerializer({
+  print: (val, serialize) => `Foo: ${serialize(val.foo)}`,
+  test: (val) => val && val.hasOwnProperty('foo'),
+});
+
+// $FlowExpectedError[incompatible-call]
+expect.addSnapshotSerializer(JSON.stringify);
+
+expect.assertions(1);
+expect.hasAssertions();
+
+expect.anything();
+expect.any(Error);
+expect.objectContaining({
+  foo: 'bar',
+});
+expect.arrayContaining(['red', 'blue']);
+expect.stringMatching('*this part*');
+
+expect.not.arrayContaining(['red', 'blue']);
+expect.not.objectContaining({ foo: 'bar' });
+expect.not.stringContaining('foobar');
+expect.not.stringMatching(/foobar/);
+
+test.concurrent('test', () => {});
+
+expect([1, 2, 3]).toHaveLength(3);
+
+(async () => {
+  await expect(Promise.reject('ok')).rejects.toBe('ok');
+  await expect(Promise.resolve('ok')).resolves.toBe('ok');
+})();
+
+/**
+ *  Plugin: jest-styled-components
+ */
+// $FlowExpectedError[cannot-resolve-module]
+import { mount } from 'enzyme';
+// $FlowExpectedError[cannot-resolve-module]
+import styled from 'styled-components';
+
+const ColoredSpan = styled.span`
+  color: red;
+`;
+
+const ButtonWithBreakpoint = styled.button`
+  @media (max-width: 640px) {
+    &:hover {
+      color: red;
+    }
+  }
+`;
+
+const styledWrapper = mount(<ColoredSpan />);
+
+expect(styledWrapper).toHaveStyleRule('color', 'red');
+
+expect(styledWrapper).not.toHaveStyleRule('cursor', expect.any(String));
+
+expect(mount(<ButtonWithBreakpoint />)).toHaveStyleRule('color', 'red', {
+  media: '(max-width:640px)',
+  modifier: ':hover',
+});
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule();
+
+// $FlowExpectedError[incompatible-call]
+expect(styledWrapper).toHaveStyleRule({ backgroundColor: 'red' });
+
+/**
+ *  Plugin: jest-enzyme
+ */
+
+// $FlowExpectedError[cannot-resolve-module]
+import { shallow } from 'enzyme';
+const Dummy = () => <div />;
+const wrapper = shallow(<Dummy />);
+
+// 5.x
+
+expect(wrapper).toBeEmpty();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmpty(true);
+
+expect(wrapper).toBePresent();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBePresent(true);
+
+// 6.x
+
+expect(wrapper).toBeChecked();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeChecked(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toBeEmptyRender();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toBeEmptyRender(true);
+
+expect(wrapper).toContainMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElement(true);
+
+expect(wrapper).toContainMatchingElements(2, 'span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainMatchingElements('span', true);
+
+expect(wrapper).toContainExactlyOneMatchingElement('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainExactlyOneMatchingElement(true);
+
+expect(wrapper).toContainReact(<Dummy />);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toContainReact('string');
+
+expect(wrapper).toExist();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toExist(true);
+
+expect(wrapper).toHaveClassName('class');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveClassName(true);
+
+expect(wrapper).toHaveHTML('<span>test</span>');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveHTML(true);
+
+expect(wrapper).toHaveProp('test');
+expect(wrapper).toHaveProp('test', 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp(true);
+expect(wrapper).toHaveProp({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveProp({ test: 'test' }, 'test');
+
+expect(wrapper).toHaveRef('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveRef(true);
+
+expect(wrapper).toHaveState('test');
+expect(wrapper).toHaveState('test', 'test');
+expect(wrapper).toHaveState({ test: 'test' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState({ test: 'test' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveState(true);
+
+expect(wrapper).toHaveStyle('color');
+expect(wrapper).toHaveStyle('color', '#ccc');
+expect(wrapper).toHaveStyle({ color: '#ccc' });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle({ color: '#ccc' }, 'test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveStyle(true);
+
+expect(wrapper).toHaveTagName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveTagName(true);
+
+expect(wrapper).toHaveText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveText(true);
+
+expect(wrapper).toHaveValue('test');
+
+expect(wrapper).toIncludeText('test');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toIncludeText(true);
+
+expect(wrapper).toMatchElement(<Dummy />);
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: true });
+expect(wrapper).toMatchElement(<Dummy />, { verbose: true });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(true);
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { ignoreProps: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { verbose: 123 });
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchElement(<Dummy />, { foobar: true });
+
+expect(wrapper).toMatchSelector('span');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toMatchSelector(true);
+
+// 7.x
+
+expect(wrapper).toHaveDisplayName('marquee');
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName();
+// $FlowExpectedError[incompatible-call]
+expect(wrapper).toHaveDisplayName(true);
+
+/**
+ * @testing-library/jest-dom
+ */
+{
+  const element = document.createElement('div');
+
+  expect(element).toBeDisabled();
+  expect(element).toBeEnabled();
+  expect(element).toBeEmpty();
+  expect(element).toBeInTheDocument();
+  expect(element).toBeVisible();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainElement();
+  expect(element).toContainElement(element);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toContainHTML();
+  expect(element).toContainHTML('<div></div>');
+  expect(element).toHaveAttribute('foo');
+  expect(element).toHaveAttribute('foo', 'bar');
+  // $FlowExpectedError[incompatible-call]: attribute name should be present
+  expect(element).toHaveAttribute();
+  // $FlowExpectedError[incompatible-call]: attribute name should be a string
+  expect(element).toHaveAttribute(1);
+  expect(element).toHaveAttribute('foo', 1);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveClass(1);
+  expect(element).toHaveClass('foo');
+  expect(element).toHaveFocus();
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveFormValues();
+  expect(element).toHaveFormValues({ foo: 'bar' });
+  expect(element).toHaveStyle('color: blue');
+  expect(element).toHaveStyle({ color: 'blue' });
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveStyle();
+  expect(element).toHaveStyle('foo');
+  expect(element).toHaveTextContent('123');
+  // $FlowExpectedError[incompatible-call]: expected text content should be present
+  expect(element).toHaveTextContent();
+  // $FlowExpectedError[incompatible-call]: expected text content should be a string
+  expect(element).toHaveTextContent(1);
+
+  expect(element).toHaveDisplayValue('test');
+  expect(element).toHaveDisplayValue(['foo', 'bar']);
+  expect(element).toBeChecked();
+  expect(element).toBeEmptyDOMElement();
+  expect(element).toBePartiallyChecked();
+
+  // $FlowExpectedError[incompatible-call]: expected description should be present
+  expect(element).toHaveDescription();
+  expect(element).toHaveDescription('foo');
+  expect(element).toHaveDescription(/[0-9]/);
+  // $FlowExpectedError[incompatible-call]
+  expect(element).toHaveDescription(true);
+}
+
+{
+  // in reality this would be a jquery object
+  const jquery = '$(someSelector)';
+
+  {
+    expect(jquery).toExist();
+    expect(jquery).not.toExist();
+
+    expect(jquery).toHaveLength(1);
+    // $FlowExpectedError[incompatible-call]: parameter required
+    expect(jquery).toHaveLength();
+
+    expect(jquery).toHaveId('username');
+
+    expect(jquery).toHaveClass('myclass');
+    expect(jquery).toHaveTag('div');
+    expect(jquery).toHaveAttr('attr1');
+    expect(jquery).toHaveAttr('attr1', 'value1');
+
+    expect(jquery).toHaveProp('attr1');
+    expect(jquery).toHaveProp('attr1', 'value1');
+
+    expect(jquery).toHaveData('attr1');
+    expect(jquery).toHaveData('attr1', 'value1');
+
+    expect(jquery).toHaveText('MyText');
+    expect(jquery).toHaveText(/MyTe.t/);
+
+    expect(jquery).toHaveDescendantWithText('selector', 'text');
+    expect(jquery).toHaveDescendantWithText('selector', /text/);
+
+    expect(jquery).toHaveCss({ key: 'value' });
+  }
+}
+
+{
+  expect('').toBeEmpty();
+  expect(1).toBeOneOf([1, 2, 3]);
+  expect(null).toBeNil();
+
+  {
+    const greaterThanOneButNotThree = (n) => n > 1 && n !== 3;
+    expect(100).toSatisfy(greaterThanOneButNotThree);
+  }
+
+  expect([]).toBeArray();
+
+  expect([]).toBeArrayOfSize(0);
+
+  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
+
+  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
+
+  {
+    const isOdd = (el) => el % 2 === 1;
+    expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
+  }
+
+  expect(false).toBeBoolean();
+  expect(false).not.toBeTrue();
+
+  expect(true).not.toBeFalse();
+  expect(() => {}).toBeFunction();
+
+  {
+    const timeout = (n: number) => {};
+    const mock1 = jest.fn(timeout(1));
+    const mock2 = jest.fn(timeout(1));
+    expect(mock1).toHaveBeenCalledBefore(mock2);
+  }
+
+  expect(1).toBeNumber();
+  expect(NaN).toBeNaN();
+  expect(1).toBeFinite();
+  expect(1).toBePositive();
+  expect(-1).toBeNegative();
+  expect(2).toBeEven();
+  expect(1).toBeOdd();
+  expect(1).toBeWithin(1, 3);
+  expect({}).toBeObject();
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKey('a');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAllKeys(['a', 'b']);
+  }
+  {
+    const o = { a: 'hello', b: 'world' };
+    expect(o).toContainAnyKeys(['a']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValue('foo');
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainValues(['foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllValues(['foo', 'bar', 'baz']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyValues(['qux', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntry(['a', 'foo']);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainEntries([['a', 'foo']]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAllEntries([
+      ['a', 'foo'],
+      ['b', 'bar'],
+      ['c', 'baz'],
+    ]);
+  }
+  {
+    const o = { a: 'foo', b: 'bar', c: 'baz' };
+    expect(o).toContainAnyEntries([
+      ['a', 'qux'],
+      ['a', 'foo'],
+    ]);
+  }
+  {
+    expect({ a: 1 }).toBeExtensible();
+  }
+
+  expect(Object.freeze({})).toBeFrozen();
+
+  expect(Object.seal({})).toBeSealed();
+
+  expect('').toBeString();
+  expect('hello world').toEqualCaseInsensitive('hello world');
+  expect('hello world').toStartWith('hello');
+  expect('hello world').toEndWith('world');
+  expect('hello world').toInclude('ell');
+  expect('hello hello world').toIncludeRepeated('hello', 2);
+  expect('hello world').toIncludeMultiple(['world', 'hello']);
+}
+
+{
+  // Type hint becomes the returned type
+  const FooModule1: string = jest.requireActual<string>('FooModule');
+  // $FlowExpectedError[incompatible-type] Type hint becomes the returned type
+  const FooModule2: number = jest.requireActual<string>('FooModule');
+  // No type hint means we return any
+  const FooModule3: boolean = jest.requireActual('FooModule');
+}
+
+it.each`
+  x    | y    | z
+  ${1} | ${2} | ${3}
+  ${2} | ${3} | ${5}
+  ${3} | ${4} | ${7}
+`('x=$x, y=$y, and z=$z', ({ x, y, z }) => {
+  // perform tests
+});
diff --git a/definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.104.x-/koa-bunyan-logger_v2.x.x.js b/definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.104.x-v.200.x/koa-bunyan-logger_v2.x.x.js
similarity index 100%
rename from definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.104.x-/koa-bunyan-logger_v2.x.x.js
rename to definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.104.x-v.200.x/koa-bunyan-logger_v2.x.x.js
diff --git a/definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.201.x-/koa-bunyan-logger_v2.x.x.js b/definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.201.x-/koa-bunyan-logger_v2.x.x.js
new file mode 100644
index 0000000000..a0b71807f1
--- /dev/null
+++ b/definitions/npm/koa-bunyan-logger_v2.x.x/flow_v0.201.x-/koa-bunyan-logger_v2.x.x.js
@@ -0,0 +1,176 @@
+/**
+ * This is an libdef for:
+ *
+ *   'koa-bunyan-logger'
+ *
+ * NOTE: once import types from modules is working,
+ * remove types redeclaration from bunyan and koa
+ *
+ */
+
+declare module 'koa-bunyan-logger' {
+  /**
+   * copy from bunyan library, import type does not work here?
+   * import type bunyan, { Logger, LoggerOptions, BunyanLogLevels } from 'bunyan';
+  **/
+  declare type BunyanLogLevels =
+    60 | // fatal
+    50 | // error
+    40 | // warn
+    30 | // info
+    20 | // debug
+    10;  // trace
+  declare type BunyanRecord = {
+    [key: string]: any,
+    v: number,
+    level: BunyanLogLevels,
+    name: string,
+    hostname: string,
+    pid: string,
+    time: Date,
+    msg: string,
+    src: string,
+    err?: {
+      message: string,
+      name: string,
+      code: any,
+      signal: any,
+      stack: string,
+      ...
+    },
+    ...
+  };
+  declare type Writable = { write(rec: BunyanRecord): void, ... }
+  declare type Stream = {
+    type?: string,
+    level?: number | string,
+    path?: string,
+    stream?: stream$Writable | tty$WriteStream | Stream | Writable,
+    closeOnExit?: boolean,
+    period?: string,
+    count?: number,
+    ...
+  }
+  declare interface LoggerOptions {
+    streams?: Array<Stream>;
+    level?: BunyanLogLevels | string,
+    stream?: stream$Writable;
+    serializers?: Serializers;
+    src?: boolean;
+  }
+  declare class Logger extends events$EventEmitter {
+      addSerializers(serializers: Serializers): void;
+      child(opts?: LoggerOptions, simple?: boolean): Logger;
+      reopenFileStreams(): void;
+      level(): string | number;
+      level(value: number | string): void;
+      levels(name: number | string, value: number | string): void;
+      trace(...params: Array<void>): boolean;
+      trace(error: Error, format?: any, ...params: Array<any>): void;
+      trace(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      trace(obj: Object, format?: any, ...params: Array<any>): void;
+      trace(format: string, ...params: Array<any>): void;
+      debug(...params: Array<void>): boolean;
+      debug(error: Error, format?: any, ...params: Array<any>): void;
+      debug(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      debug(obj: Object, format?: any, ...params: Array<any>): void;
+      debug(format: string, ...params: Array<any>): void;
+      info(...params: Array<void>): boolean;
+      info(error: Error, format?: any, ...params: Array<any>): void;
+      info(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      info(obj: Object, format?: any, ...params: Array<any>): void;
+      info(format: string, ...params: Array<any>): void;
+      warn(...params: Array<void>): boolean;
+      warn(error: Error, format?: any, ...params: Array<any>): void;
+      warn(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      warn(obj: Object, format?: any, ...params: Array<any>): void;
+      warn(format: string, ...params: Array<any>): void;
+      error(...params: Array<void>): boolean;
+      error(error: Error, format?: any, ...params: Array<any>): void;
+      error(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      error(obj: Object, format?: any, ...params: Array<any>): void;
+      error(format: string, ...params: Array<any>): void;
+      fatal(...params: Array<void>): boolean;
+      fatal(error: Error, format?: any, ...params: Array<any>): void;
+      fatal(buffer: Buffer, format?: any, ...params: Array<any>): void;
+      fatal(obj: Object, format?: any, ...params: Array<any>): void;
+      fatal(format: string, ...params: Array<any>): void;
+  }
+  declare type Serializers = { [key: string]: (input: any) => mixed, ... }
+  declare type StdSerializers = {
+    req: (req: http$ClientRequest) => {
+      method: string,
+      url: string,
+      headers: mixed,
+      remoteAddress: string,
+      remotePort: number,
+      ...
+    },
+    res: (res: http$IncomingMessage) => {
+      statusCode: number,
+      header: string,
+      ...
+    },
+    err: (err: Error) => {
+      message: string,
+      name: string,
+      stack: string,
+      code: string,
+      signal: string,
+      ...
+    },
+    ...
+  };
+
+  /**
+   * copy from koa library, import type does not work
+   * import type { Middleware } from 'koa';
+  **/
+  declare type Middleware =
+    (ctx: any, next: () => Promise<void>) => Promise<void> | void;
+
+  declare type MiddlewareType = Middleware;
+
+  declare type LoggerFactoryOptions = LoggerOptions & { name: string, ... };
+
+  declare type FieldsModifier = (fields: Object) => Object;
+  declare type FieldsStringifier = (fields: Object) => string;
+
+  declare type RequestLogger$Options = {
+    durationField?: string,
+    levelFn?: (status: number, err: Error) => BunyanLogLevels,
+    updateLogFields?: FieldsModifier,
+    updateRequestLogFields?: FieldsModifier,
+    updateResponseLogFields?: FieldsModifier,
+    formatRequestMessage?: FieldsStringifier,
+    formatResponseMessage?: FieldsStringifier,
+    ...
+  }
+
+  declare type TimeContext$Options = {
+    logLevel?: BunyanLogLevels,
+    updateLogFields?: FieldsModifier,
+    ...
+  }
+
+  declare type RequestIdOptions = {
+    header?: string,
+    prop?: string,
+    requestProp?: string,
+    field?: string,
+    ...
+  }
+
+  declare module.exports: {
+    (options?: LoggerFactoryOptions | Logger): MiddlewareType,
+    requestIdContext(options?: RequestIdOptions): MiddlewareType,
+    requestLogger(options?: RequestLogger$Options): MiddlewareType,
+    timeContext(options: TimeContext$Options): MiddlewareType,
+    bunyan: {
+      stdSerializers: StdSerializers,
+      createLogger(options: LoggerFactoryOptions): Logger,
+      ...
+    },
+    ...
+  };
+}
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/lodash-es_v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/lodash-es_v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/lodash-es_v4.x.x.js
rename to definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/lodash-es_v4.x.x.js
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_does-not-fail-on-null-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_does-not-fail-on-null-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_does-not-fail-on-null-v4.x.x.js
rename to definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_does-not-fail-on-null-v4.x.x.js
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_fails-on-null-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_fails-on-null-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_fails-on-null-v4.x.x.js
rename to definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_fails-on-null-v4.x.x.js
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_lodash-es-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_lodash-es-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_lodash-es-v4.x.x.js
rename to definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_lodash-es-v4.x.x.js
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_modules-lodash-es-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_modules-lodash-es-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-/test_modules-lodash-es-v4.x.x.js
rename to definitions/npm/lodash-es_v4.x.x/flow_v0.104.x-v.200.x/test_modules-lodash-es-v4.x.x.js
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/lodash-es_v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/lodash-es_v4.x.x.js
new file mode 100644
index 0000000000..2f2d8a1a7f
--- /dev/null
+++ b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/lodash-es_v4.x.x.js
@@ -0,0 +1,2268 @@
+declare module "lodash-es" {
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
+    ...r: [AA]
+  ) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB]) => R);
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
+    ...r: [AA]
+  ) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC]) => R);
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type UnaryFn<A, R> = (a: A) => R;
+
+  declare type TemplateSettings = {
+    escape?: RegExp,
+    evaluate?: RegExp,
+    imports?: Object,
+    interpolate?: RegExp,
+    variable?: string,
+    ...
+  };
+
+  declare type TruncateOptions = {
+    length?: number,
+    omission?: string,
+    separator?: RegExp | string,
+    ...
+  };
+
+  declare type DebounceOptions = {
+    leading?: boolean,
+    maxWait?: number,
+    trailing?: boolean,
+    ...
+  };
+
+  declare type ThrottleOptions = {
+    leading?: boolean,
+    trailing?: boolean,
+    ...
+  };
+
+  declare type NestedArray<T> = Array<Array<T>>;
+
+  declare type matchesIterateeShorthand = Object;
+  declare type matchesPropertyIterateeShorthand = [string, any];
+  declare type propertyIterateeShorthand = string;
+
+  declare type OPredicate<A, O> =
+    | ((value: A, key: string, object: O) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type OIterateeWithResult<V, O, R> =
+    | Object
+    | string
+    | ((value: V, key: string, object: O) => R);
+  declare type OIteratee<O> = OIterateeWithResult<any, O, any>;
+  declare type OFlatMapIteratee<T, U> = OIterateeWithResult<any, T, Array<U>>;
+
+  declare type Predicate<T> =
+    | ((value: T, index: number, array: Array<T>) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type _ValueOnlyIteratee<T> = (value: T) => mixed;
+  declare type ValueOnlyIteratee<T> = _ValueOnlyIteratee<T> | string;
+  declare type _Iteratee<T> = (
+    item: T,
+    index: number,
+    array: ?Array<T>
+  ) => mixed;
+  declare type Iteratee<T> = _Iteratee<T> | Object | string;
+  declare type FlatMapIteratee<T, U> =
+    | ((item: T, index: number, array: ?$ReadOnlyArray<T>) => Array<U>)
+    | Object
+    | string;
+  declare type Comparator<T> = (item: T, item2: T) => boolean;
+
+  declare type MapIterator<T, U> =
+    | ((item: T, index: number, array: Array<T>) => U)
+    | propertyIterateeShorthand;
+
+  declare type ReadOnlyMapIterator<T, U> =
+    | ((item: T, index: number, array: $ReadOnlyArray<T>) => U)
+    | propertyIterateeShorthand;
+
+  declare type OMapIterator<T, O, U> =
+    | ((item: T, key: string, object: O) => U)
+    | propertyIterateeShorthand;
+
+  // Array
+  declare export function chunk<T>(array?: ?Array<T>, size?: ?number): Array<Array<T>>;
+  declare export function compact<T, N: ?T>(array?: ?Array<N>): Array<T>;
+  declare export function concat<T>(base?: ?$ReadOnlyArray<T>, ...elements: Array<any>): Array<T | any>;
+  declare export function difference<T>(array?: ?$ReadOnlyArray<T>, ...values: Array<?$ReadOnlyArray<T>>): Array<T>;
+  declare export function differenceBy<T>(
+    array?: ?$ReadOnlyArray<T>,
+    values?: ?$ReadOnlyArray<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): T[];
+  declare export function differenceWith<T>(array?: ?$ReadOnlyArray<T>, values?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>): T[];
+  declare export function drop<T>(array?: ?Array<T>, n?: ?number): Array<T>;
+  declare export function dropRight<T>(array?: ?Array<T>, n?: ?number): Array<T>;
+  declare export function dropRightWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function dropWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function fill<T, U>(
+    array?: ?Array<T>,
+    value?: ?U,
+    start?: ?number,
+    end?: ?number
+  ): Array<T | U>;
+  declare export function findIndex<T>(
+    array: $ReadOnlyArray<T>,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): number;
+  declare export function findIndex<T>(
+    array: void | null,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): -1;
+  declare export function findLastIndex<T>(
+    array: $ReadOnlyArray<T>,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): number;
+  declare export function findLastIndex<T>(
+    array: void | null,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): -1;
+  declare export function first<T>(array: ?$ReadOnlyArray<T>): T;
+  declare export function flatten<T, X>(array?: ?Array<Array<T> | X>): Array<T | X>;
+  declare export function flattenDeep<T>(array?: ?any[]): Array<T>;
+  declare export function flattenDepth(array?: ?any[], depth?: ?number): any[];
+  declare export function fromPairs<A, B>(pairs?: ?Array<[A, B]>): { [key: A]: B, ... };
+  declare export function head<T>(array: ?$ReadOnlyArray<T>): T;
+  declare export function indexOf<T>(array: Array<T>, value: T, fromIndex?: number): number;
+  declare export function indexOf<T>(array: void | null, value?: ?T, fromIndex?: ?number): -1;
+  declare export function initial<T>(array: ?Array<T>): Array<T>;
+  declare export function intersection<T>(...arrays?: Array<Array<T>>): Array<T>;
+  declare export function intersectionBy<T>(a1?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
+  declare export function intersectionBy<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function intersectionBy<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    a3?: ?Array<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function intersectionBy<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    a3?: ?Array<T>,
+    a4?: ?Array<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function intersectionWith<T>(a1?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
+  declare export function intersectionWith<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    comparator?: ?Comparator<T>
+  ): Array<T>;
+  declare export function intersectionWith<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    a3?: ?Array<T>,
+    comparator?: ?Comparator<T>
+  ): Array<T>;
+  declare export function intersectionWith<T>(
+    a1?: ?Array<T>,
+    a2?: ?Array<T>,
+    a3?: ?Array<T>,
+    a4?: ?Array<T>,
+    comparator?: ?Comparator<T>
+  ): Array<T>;
+  declare export function join<T>(array: Array<T>, separator?: ?string): string;
+  declare export function join<T>(array: void | null, separator?: ?string): '';
+  declare export function last<T>(array: ?$ReadOnlyArray<T>): T;
+  declare export function lastIndexOf<T>(array: Array<T>, value?: ?T, fromIndex?: ?number): number;
+  declare export function lastIndexOf<T>(array: void | null, value?: ?T, fromIndex?: ?number): -1;
+  declare export function nth<T>(array: T[], n?: ?number): T;
+  declare export function nth(array: void | null, n?: ?number): void;
+  declare export function pull<T>(array: Array<T>, ...values?: Array<?T>): Array<T>;
+  declare export function pull<T: void | null>(array: T, ...values?: Array<?any>): T;
+  declare export function pullAll<T>(array: Array<T>, values?: ?Array<T>): Array<T>;
+  declare export function pullAll<T: void | null>(array: T, values?: ?Array<any>): T;
+  declare export function pullAllBy<T>(
+    array: Array<T>,
+    values?: ?Array<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function pullAllBy<T: void | null>(
+    array: T,
+    values?: ?Array<any>,
+    iteratee?: ?ValueOnlyIteratee<any>
+  ): T;
+  declare export function pullAllWith<T>(array: T[], values?: ?T[], comparator?: ?Function): T[];
+  declare export function pullAllWith<T: void | null>(array: T, values?: ?Array<any>, comparator?: ?Function): T;
+  declare export function pullAt<T>(array?: ?Array<T>, ...indexed?: Array<?number>): Array<T>;
+  declare export function pullAt<T>(array?: ?Array<T>, indexed?: ?Array<number>): Array<T>;
+  declare export function remove<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function reverse<T>(array: Array<T>): Array<T>;
+  declare export function reverse<T: void | null>(array: T): T;
+  declare export function slice<T>(array?: ?$ReadOnlyArray<T>, start?: ?number, end?: ?number): Array<T>;
+  declare export function sortedIndex<T>(array: Array<T>, value: T): number;
+  declare export function sortedIndex<T>(array: void | null, value: ?T): 0;
+  declare export function sortedIndexBy<T>(
+    array: Array<T>,
+    value?: ?T,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): number;
+  declare export function sortedIndexBy<T>(
+    array: void | null,
+    value?: ?T,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): 0;
+  declare export function sortedIndexOf<T>(array: Array<T>, value: T): number;
+  declare export function sortedIndexOf<T>(array: void | null, value?: ?T): -1;
+  declare export function sortedLastIndex<T>(array: Array<T>, value: T): number;
+  declare export function sortedLastIndex<T>(array: void | null, value?: ?T): 0;
+  declare export function sortedLastIndexBy<T>(
+    array: Array<T>,
+    value: T,
+    iteratee?: ValueOnlyIteratee<T>
+  ): number;
+  declare export function sortedLastIndexBy<T>(
+    array: void | null,
+    value?: ?T,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): 0;
+  declare export function sortedLastIndexOf<T>(array: Array<T>, value: T): number;
+  declare export function sortedLastIndexOf<T>(array: void | null, value?: ?T): -1;
+  declare export function sortedUniq<T>(array?: ?Array<T>): Array<T>;
+  declare export function sortedUniqBy<T>(array?: ?Array<T>, iteratee?: ?(value: T) => mixed): Array<T>;
+  declare export function tail<T>(array?: ?Array<T>): Array<T>;
+  declare export function take<T>(array?: ?Array<T>, n?: ?number): Array<T>;
+  declare export function takeRight<T>(array?: ?Array<T>, n?: ?number): Array<T>;
+  declare export function takeRightWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function takeWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function union<T>(...arrays?: Array<Array<T>>): Array<T>;
+  declare export function unionBy<T>(a1?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
+  declare export function unionBy<T>(
+    a1?: ?Array<T>,
+    a2: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function unionBy<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function unionBy<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    a4: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function unionWith<T>(a1?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
+  declare export function unionWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function unionWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function unionWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    a4: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function uniq<T>(array?: ?Array<T>): Array<T>;
+  declare export function uniqBy<T>(array?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
+  declare export function uniqWith<T>(array?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
+  declare export function unzip<T>(array?: ?Array<T>): Array<T>;
+  declare export function unzipWith<T>(array: ?Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
+  declare export function without<T>(array?: ?$ReadOnlyArray<T>, ...values?: Array<?T>): Array<T>;
+  declare export function xor<T>(...array: Array<Array<T>>): Array<T>;
+  declare export function xorBy<T>(a1?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
+  declare export function xorBy<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function xorBy<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function xorBy<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    a4: Array<T>,
+    iteratee?: ValueOnlyIteratee<T>
+  ): Array<T>;
+  declare export function xorWith<T>(a1?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
+  declare export function xorWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function xorWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function xorWith<T>(
+    a1: Array<T>,
+    a2: Array<T>,
+    a3: Array<T>,
+    a4: Array<T>,
+    comparator?: Comparator<T>
+  ): Array<T>;
+  declare export function zip<A, B>(a1?: ?A[], a2?: ?B[]): Array<[?A, ?B]>;
+  declare export function zip<A, B, C>(a1: A[], a2: B[], a3: C[]): Array<[?A, ?B, ?C]>;
+  declare export function zip<A, B, C, D>(a1: A[], a2: B[], a3: C[], a4: D[]): Array<[?A, ?B, ?C, ?D]>;
+  declare export function zip<A, B, C, D, E>(
+    a1: A[],
+    a2: B[],
+    a3: C[],
+    a4: D[],
+    a5: E[]
+  ): Array<[?A, ?B, ?C, ?D, ?E]>;
+
+  declare export function zipObject<K, V>(props: Array<K>, values?: ?Array<V>): { [key: K]: V, ... };
+  declare export function zipObject<K, V>(props: void | null, values?: ?Array<V>): {...};
+  declare export function zipObjectDeep(props: any[], values?: ?any): Object;
+  declare export function zipObjectDeep(props: void | null, values?: ?any): {...};
+
+  declare export function zipWith<A>(a1?: ?Array<A>): Array<[A]>;
+  declare export function zipWith<T, A>(a1: Array<A>, iteratee: (A) => T): Array<T>;
+
+  declare export function zipWith<A, B>(a1: Array<A>, a2: Array<B>): Array<[A, B]>;
+  declare export function zipWith<T, A, B>(
+    a1: Array<A>,
+    a2: Array<B>,
+    iteratee: (A, B) => T
+  ): Array<T>;
+
+  declare export function zipWith<A, B, C>(
+    a1: Array<A>,
+    a2: Array<B>,
+    a3: Array<C>
+  ): Array<[A, B, C]>;
+  declare export function zipWith<T, A, B, C>(
+    a1: Array<A>,
+    a2: Array<B>,
+    a3: Array<C>,
+    iteratee: (A, B, C) => T
+  ): Array<T>;
+
+  declare export function zipWith<A, B, C, D>(
+    a1: Array<A>,
+    a2: Array<B>,
+    a3: Array<C>,
+    a4: Array<D>
+  ): Array<[A, B, C, D]>;
+  declare export function zipWith<T, A, B, C, D>(
+    a1: Array<A>,
+    a2: Array<B>,
+    a3: Array<C>,
+    a4: Array<D>,
+    iteratee: (A, B, C, D) => T
+  ): Array<T>;
+
+  // Collection
+  declare export function countBy<T>(array: Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Object;
+  declare export function countBy<T>(array: void | null, iteratee?: ?ValueOnlyIteratee<T>): {...};
+  declare export function countBy<T: Object>(object: T, iteratee?: ?ValueOnlyIteratee<T>): Object;
+  declare export function each<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
+  declare export function each<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
+  declare export function each<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
+  declare export function eachRight<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
+  declare export function eachRight<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
+  declare export function eachRight<T: Object>(object: T, iteratee?: OIteratee<T>): T;
+  declare export function every<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): boolean;
+  declare export function every<T: Object>(object: T, iteratee?: OIteratee<T>): boolean;
+  declare export function filter<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
+  declare export function filter<A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: OPredicate<A, T>
+  ): Array<A>;
+  declare export function find<T>(
+    array: $ReadOnlyArray<T>,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): T | void;
+  declare export function find<T>(
+    array: void | null,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): void;
+  declare export function find<V, A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: OPredicate<A, T>,
+    fromIndex?: number
+  ): V;
+  declare export function findLast<T>(
+    array: ?$ReadOnlyArray<T>,
+    predicate?: ?Predicate<T>,
+    fromIndex?: ?number
+  ): T | void;
+  declare export function findLast<V, A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: ?OPredicate<A, T>
+  ): V;
+  declare export function flatMap<T, U>(
+    array?: ?$ReadOnlyArray<T>,
+    iteratee?: ?FlatMapIteratee<T, U>
+  ): Array<U>;
+  declare export function flatMap<T: Object, U>(
+    object: T,
+    iteratee?: OFlatMapIteratee<T, U>
+  ): Array<U>;
+  declare export function flatMapDeep<T, U>(
+    array?: ?$ReadOnlyArray<T>,
+    iteratee?: ?FlatMapIteratee<T, U>
+  ): Array<U>;
+  declare export function flatMapDeep<T: Object, U>(
+    object: T,
+    iteratee?: ?OFlatMapIteratee<T, U>
+  ): Array<U>;
+  declare export function flatMapDepth<T, U>(
+    array?: ?Array<T>,
+    iteratee?: ?FlatMapIteratee<T, U>,
+    depth?: ?number
+  ): Array<U>;
+  declare export function flatMapDepth<T: Object, U>(
+    object: T,
+    iteratee?: OFlatMapIteratee<T, U>,
+    depth?: number
+  ): Array<U>;
+  declare export function forEach<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
+  declare export function forEach<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
+  declare export function forEach<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
+  declare export function forEachRight<T>(array: $ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
+  declare export function forEachRight<T: void | null>(array: T, iteratee?: ?Iteratee<any>): T;
+  declare export function forEachRight<T: Object>(object: T, iteratee?: ?OIteratee<T>): T;
+  declare export function groupBy<V, T>(
+    array: $ReadOnlyArray<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): { [key: V]: Array<T>, ... };
+  declare export function groupBy(
+    array: void | null,
+    iteratee?: ?ValueOnlyIteratee<any>
+  ): {...};
+  declare export function groupBy<V, A, T: { [id: string]: A, ... }>(
+    object: T,
+    iteratee?: ValueOnlyIteratee<A>
+  ): { [key: V]: Array<A>, ... };
+  declare export function includes<T>(array: $ReadOnlyArray<T>, value: T, fromIndex?: ?number): boolean;
+  declare export function includes<T>(array: void | null, value?: ?T, fromIndex?: ?number): false;
+  declare export function includes<T: Object>(object: T, value: any, fromIndex?: number): boolean;
+  declare export function includes(str: string, value: string, fromIndex?: number): boolean;
+  declare export function invokeMap<T>(
+    array?: ?Array<T>,
+    path?: ?((value: T) => Array<string> | string) | Array<string> | string,
+    ...args?: Array<any>
+  ): Array<any>;
+  declare export function invokeMap<T: Object>(
+    object: T,
+    path: ((value: any) => Array<string> | string) | Array<string> | string,
+    ...args?: Array<any>
+  ): Array<any>;
+  declare export function keyBy<T, V>(
+    array: $ReadOnlyArray<T>,
+    iteratee?: ?ValueOnlyIteratee<T>
+  ): { [key: V]: ?T, ... };
+  declare export function keyBy(
+    array: void | null,
+    iteratee?: ?ValueOnlyIteratee<any>
+  ): {...};
+  declare export function keyBy<V, A, I, T: { [id: I]: A, ... }>(
+    object: T,
+    iteratee?: ?ValueOnlyIteratee<A>
+  ): { [key: V]: ?A, ... };
+  declare export function map<T, U>(array?: ?Array<T>, iteratee?: ?MapIterator<T, U>): Array<U>;
+  declare export function map<T, U>(
+    array: ?$ReadOnlyArray<T>,
+    iteratee?: ReadOnlyMapIterator<T, U>
+  ): Array<U>;
+  declare export function map<V, T: Object, U>(
+    object: ?T,
+    iteratee?: OMapIterator<V, T, U>
+  ): Array<U>;
+  declare export function map(
+    str: ?string,
+    iteratee?: (char: string, index: number, str: string) => any
+  ): string;
+  declare export function orderBy<T>(
+    array: $ReadOnlyArray<T>,
+    iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
+    orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
+  ): Array<T>;
+  declare export function orderBy<T>(
+    array: null | void,
+    iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
+    orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
+  ): Array<T>;
+  declare export function orderBy<V, T: Object>(
+    object: T,
+    iteratees?: $ReadOnlyArray<OIteratee<any>> | string,
+    orders?: $ReadOnlyArray<"asc" | "desc"> | string
+  ): Array<V>;
+  declare export function partition<T>(
+    array?: ?Array<T>,
+    predicate?: ?Predicate<T>
+  ): [Array<T>, Array<T>];
+  declare export function partition<V, A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: OPredicate<A, T>
+  ): [Array<V>, Array<V>];
+  declare export function reduce<T, U>(
+    array: Array<T>,
+    iteratee?: (
+      accumulator: U,
+      value: T,
+      index: number,
+      array: ?Array<T>
+    ) => U,
+    accumulator?: U
+  ): U;
+  declare export function reduce<T, U>(
+    array: void | null,
+    iteratee?: ?(
+      accumulator: U,
+      value: T,
+      index: number,
+      array: ?Array<T>
+    ) => U,
+    accumulator?: ?U
+  ): void | null;
+  declare export function reduce<T: Object, U>(
+    object: T,
+    iteratee?: (accumulator: U, value: any, key: string, object: T) => U,
+    accumulator?: U
+  ): U;
+  declare export function reduceRight<T, U>(
+    array: void | null,
+    iteratee?: ?(
+      accumulator: U,
+      value: T,
+      index: number,
+      array: ?Array<T>
+    ) => U,
+    accumulator?: ?U
+  ): void | null;
+  declare export function reduceRight<T, U>(
+    array: Array<T>,
+    iteratee?: ?(
+      accumulator: U,
+      value: T,
+      index: number,
+      array: ?Array<T>
+    ) => U,
+    accumulator?: ?U
+  ): U;
+  declare export function reduceRight<T: Object, U>(
+    object: T,
+    iteratee?: ?(accumulator: U, value: any, key: string, object: T) => U,
+    accumulator?: ?U
+  ): U;
+  declare export function reject<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>): Array<T>;
+  declare export function reject<V: Object, A, T: { [id: string]: A, ... }>(
+    object?: ?T,
+    predicate?: ?OPredicate<A, T>
+  ): Array<V>;
+  declare export function sample<T>(array: ?Array<T>): T;
+  declare export function sample<V, T: Object>(object: T): V;
+  declare export function sampleSize<T>(array?: ?Array<T>, n?: ?number): Array<T>;
+  declare export function sampleSize<V, T: Object>(object: T, n?: number): Array<V>;
+  declare export function shuffle<T>(array: ?Array<T>): Array<T>;
+  declare export function shuffle<V, T: Object>(object: T): Array<V>;
+  declare export function size(collection: $ReadOnlyArray<any> | Object | string): number;
+  declare export function some<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>): boolean;
+  declare export function some<T>(array: void | null, predicate?: ?Predicate<T>): false;
+  declare export function some<A, T: { [id: string]: A, ... }>(
+    object?: ?T,
+    predicate?: OPredicate<A, T>
+  ): boolean;
+  declare export function sortBy<T>(
+    array: ?$ReadOnlyArray<T>,
+    ...iteratees?: $ReadOnlyArray<Iteratee<T>>
+  ): Array<T>;
+  declare export function sortBy<T>(
+    array: ?$ReadOnlyArray<T>,
+    iteratees?: $ReadOnlyArray<Iteratee<T>>
+  ): Array<T>;
+  declare export function sortBy<V, T: Object>(
+    object: T,
+    ...iteratees?: Array<OIteratee<T>>
+  ): Array<V>;
+  declare export function sortBy<V, T: Object>(
+    object: T,
+    iteratees?: $ReadOnlyArray<OIteratee<T>>
+  ): Array<V>;
+
+  // Date
+  declare export function now(): number;
+
+  // Function
+  declare export function after(n: number, fn: Function): Function;
+  declare export function ary(func: Function, n?: number): Function;
+  declare export function before(n: number, fn: Function): Function;
+  declare export function bind(func: Function, thisArg: any, ...partials: Array<any>): Function;
+  declare export function bindKey(obj?: ?Object, key?: ?string, ...partials?: Array<?any>): Function;
+  declare export var curry: Curry;
+  declare export function curry(func: Function, arity?: number): Function;
+  declare export function curryRight(func: Function, arity?: number): Function;
+  declare export function debounce<F: Function>(func: F, wait?: number, options?: DebounceOptions): F;
+  declare export function defer(func: Function, ...args?: Array<any>): TimeoutID;
+  declare export function delay(func: Function, wait: number, ...args?: Array<any>): TimeoutID;
+  declare export function flip(func: Function): Function;
+  declare export function memoize<F: Function>(func: F, resolver?: Function): F;
+  declare export function negate(predicate: Function): Function;
+  declare export function once(func: Function): Function;
+  declare export function overArgs(func?: ?Function, ...transforms?: Array<Function>): Function;
+  declare export function overArgs(func?: ?Function, transforms?: ?Array<Function>): Function;
+  declare export function partial(func: Function, ...partials: any[]): Function;
+  declare export function partialRight(func: Function, ...partials: Array<any>): Function;
+  declare export function partialRight(func: Function, partials: Array<any>): Function;
+  declare export function rearg(func: Function, ...indexes: Array<number>): Function;
+  declare export function rearg(func: Function, indexes: Array<number>): Function;
+  declare export function rest(func: Function, start?: number): Function;
+  declare export function spread(func: Function): Function;
+  declare export function throttle(
+    func: Function,
+    wait?: number,
+    options?: ThrottleOptions
+  ): Function;
+  declare export function unary(func: Function): Function;
+  declare export function wrap(value?: any, wrapper?: ?Function): Function;
+
+  // Lang
+  declare export function castArray(value: any): any[];
+  declare export function clone<T>(value: T): T;
+  declare export function cloneDeep<T>(value: T): T;
+  declare export function cloneDeepWith<T, U>(
+    value: T,
+    customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
+  ): U;
+  declare export function cloneWith<T, U>(
+    value: T,
+    customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
+  ): U;
+  declare export function conformsTo<T: { [key: string]: mixed, ... }>(
+    source: T,
+    predicates: T & { [key: string]: (x: any) => boolean, ... }
+  ): boolean;
+  declare export function eq(value: any, other: any): boolean;
+  declare export function gt(value: any, other: any): boolean;
+  declare export function gte(value: any, other: any): boolean;
+  declare export function isArguments(value: void | null): false;
+  declare export function isArguments(value: any): boolean;
+  declare export function isArray(value: Array<any>): true;
+  declare export function isArray(value: any): false;
+  declare export function isArrayBuffer(value: ArrayBuffer): true;
+  declare export function isArrayBuffer(value: any): false;
+  declare export function isArrayLike(value: Array<any> | string | { length: number, ... }): true;
+  declare export function isArrayLike(value: any): false;
+  declare export function isArrayLikeObject(value: { length: number, ... } | Array<any>): true;
+  declare export function isArrayLikeObject(value: any): false;
+  declare export function isBoolean(value: boolean): true;
+  declare export function isBoolean(value: any): false;
+  declare export function isBuffer(value: void | null): false;
+  declare export function isBuffer(value: any): boolean;
+  declare export function isDate(value: Date): true;
+  declare export function isDate(value: any): false;
+  declare export function isElement(value: Element): true;
+  declare export function isElement(value: any): false;
+  declare export function isEmpty(value: void | null | '' | {...} | [] | number | boolean): true;
+  declare export function isEmpty(value: any): boolean;
+  declare export function isEqual(value: any, other: any): boolean;
+  declare export function isEqualWith<T, U>(
+    value?: ?T,
+    other?: ?U,
+    customizer?: ?(
+      objValue: any,
+      otherValue: any,
+      key: number | string,
+      object: T,
+      other: U,
+      stack: any
+    ) => boolean | void
+  ): boolean;
+  declare export function isError(value: Error): true;
+  declare export function isError(value: any): false;
+  declare export function isFinite(value: number): boolean;
+  declare export function isFinite(value: any): false;
+  declare export function isFunction(value: Function): true;
+  declare export function isFunction(value: any): false;
+  declare export function isInteger(value: number): boolean;
+  declare export function isInteger(value: any): false;
+  declare export function isLength(value: void | null): false;
+  declare export function isLength(value: any): boolean;
+  declare export function isMap(value: Map<any, any>): true;
+  declare export function isMap(value: any): false;
+  declare export function isMatch(object?: ?Object, source?: ?Object): boolean;
+  declare export function isMatchWith<T: Object, U: Object>(
+    object?: ?T,
+    source?: ?U,
+    customizer?: ?(
+      objValue: any,
+      srcValue: any,
+      key: number | string,
+      object: T,
+      source: U
+    ) => boolean | void
+  ): boolean;
+  declare export function isNaN(value: number): boolean;
+  declare export function isNaN(value: any): false;
+  declare export function isNative(value: number | string | void | null | Object): false;
+  declare export function isNative(value: any): boolean;
+  declare export function isNil(value: void | null): true;
+  declare export function isNil(value: any): false;
+  declare export function isNull(value: null): true;
+  declare export function isNull(value: any): false;
+  declare export function isNumber(value: number): true;
+  declare export function isNumber(value: any): false;
+  declare export function isObject(value: Object): true;
+  declare export function isObject(value: any): false;
+  declare export function isObjectLike(value: void | null): false;
+  declare export function isObjectLike(value: any): boolean;
+  declare export function isPlainObject(value: Object): true;
+  declare export function isPlainObject(value: any): false;
+  declare export function isRegExp(value: RegExp): true;
+  declare export function isRegExp(value: any): false;
+  declare export function isSafeInteger(value: number): boolean;
+  declare export function isSafeInteger(value: any): false;
+  declare export function isSet(value: Set<any>): true;
+  declare export function isSet(value: any): false;
+  declare export function isString(value: string): true;
+  declare export function isString(value: any): false;
+  declare export function isSymbol(value: Symbol): true;
+  declare export function isSymbol(value: any): false;
+  declare export function isTypedArray(value: $TypedArray): true;
+  declare export function isTypedArray(value: any): false;
+  declare export function isUndefined(value: void): true;
+  declare export function isUndefined(value: any): false;
+  declare export function isWeakMap(value: WeakMap<any, any>): true;
+  declare export function isWeakMap(value: any): false;
+  declare export function isWeakSet(value: WeakSet<any>): true;
+  declare export function isWeakSet(value: any): false;
+  declare export function lt(value: any, other: any): boolean;
+  declare export function lte(value: any, other: any): boolean;
+  declare export function toArray(value: any): Array<any>;
+  declare export function toFinite(value: void | null): 0;
+  declare export function toFinite(value: any): number;
+  declare export function toInteger(value: void | null): 0;
+  declare export function toInteger(value: any): number;
+  declare export function toLength(value: void | null): 0;
+  declare export function toLength(value: any): number;
+  declare export function toNumber(value: void | null): 0;
+  declare export function toNumber(value: any): number;
+  declare export function toPlainObject(value: any): Object;
+  declare export function toSafeInteger(value: void | null): 0;
+  declare export function toSafeInteger(value: any): number;
+  declare export function toString(value: void | null): '';
+  declare export function toString(value: any): string;
+
+  // Math
+  declare export function add(augend: number, addend: number): number;
+  declare export function ceil(number: number, precision?: number): number;
+  declare export function divide(dividend: number, divisor: number): number;
+  declare export function floor(number: number, precision?: number): number;
+  declare export function max<T>(array: ?Array<T>): T;
+  declare export function maxBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
+  declare export function mean(array: Array<any>): number;
+  declare export function meanBy<T>(array: Array<T>, iteratee?: Iteratee<T>): number;
+  declare export function min<T>(array: ?Array<T>): T;
+  declare export function minBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
+  declare export function multiply(multiplier: number, multiplicand: number): number;
+  declare export function round(number: number, precision?: number): number;
+  declare export function subtract(minuend: number, subtrahend: number): number;
+  declare export function sum(array: Array<any>): number;
+  declare export function sumBy<T>(array: Array<T>, iteratee?: Iteratee<T>): number;
+
+  // number
+  declare export function clamp(number?: number, lower?: ?number, upper?: ?number): number;
+  declare export function clamp(number: ?number, lower?: ?number, upper?: ?number): 0;
+  declare export function inRange(number: number, start?: number, end: number): boolean;
+  declare export function random(lower?: number, upper?: number, floating?: boolean): number;
+
+  // Object
+  declare export function assign(object?: ?Object, ...sources?: Array<?Object>): Object;
+  declare export function assignIn(): {...};
+  declare export function assignIn<A, B>(a: A, b: B): A & B;
+  declare export function assignIn<A, B, C>(a: A, b: B, c: C): A & B & C;
+  declare export function assignIn<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
+  declare export function assignIn<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): A & B & C & D & E;
+  declare export function assignInWith(): {...};
+  declare export function assignInWith<T: Object, A: Object>(
+    object: T,
+    s1: A,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A
+    ) => any | void
+  ): Object;
+  declare export function assignInWith<T: Object, A: Object, B: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B
+    ) => any | void
+  ): Object;
+  declare export function assignInWith<T: Object, A: Object, B: Object, C: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C
+    ) => any | void
+  ): Object;
+  declare export function assignInWith<T: Object, A: Object, B: Object, C: Object, D: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    s4: D,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C | D
+    ) => any | void
+  ): Object;
+  declare export function assignWith(): {...};
+  declare export function assignWith<T: Object, A: Object>(
+    object: T,
+    s1: A,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A
+    ) => any | void
+  ): Object;
+  declare export function assignWith<T: Object, A: Object, B: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B
+    ) => any | void
+  ): Object;
+  declare export function assignWith<T: Object, A: Object, B: Object, C: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C
+    ) => any | void
+  ): Object;
+  declare export function assignWith<T: Object, A: Object, B: Object, C: Object, D: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    s4: D,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C | D
+    ) => any | void
+  ): Object;
+  declare export function at(object?: ?Object, ...paths: Array<string>): Array<any>;
+  declare export function at(object?: ?Object, paths: Array<string>): Array<any>;
+  declare export function create<T>(prototype: T, properties: Object): T;
+  declare export function create(prototype: any, properties: void | null): {...};
+  declare export function defaults(object?: ?Object, ...sources?: Array<?Object>): Object;
+  declare export function defaultsDeep(object?: ?Object, ...sources?: Array<?Object>): Object;
+  // alias for _.toPairs
+  declare export function entries(object?: ?Object): Array<[string, any]>;
+  // alias for _.toPairsIn
+  declare export function entriesIn(object?: ?Object): Array<[string, any]>;
+  // alias for _.assignIn
+  declare export function extend<A, B>(a?: ?A, b?: ?B): A & B;
+  declare export function extend<A, B, C>(a: A, b: B, c: C): A & B & C;
+  declare export function extend<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
+  declare export function extend<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): A & B & C & D & E;
+  // alias for _.assignInWith
+  declare export function extendWith<T: Object, A: Object>(
+    object?: ?T,
+    s1?: ?A,
+    customizer?: ?(
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A
+    ) => any | void
+  ): Object;
+  declare export function extendWith<T: Object, A: Object, B: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B
+    ) => any | void
+  ): Object;
+  declare export function extendWith<T: Object, A: Object, B: Object, C: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C
+    ) => any | void
+  ): Object;
+  declare export function extendWith<T: Object, A: Object, B: Object, C: Object, D: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    s4: D,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C | D
+    ) => any | void
+  ): Object;
+  declare export function findKey<A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: ?OPredicate<A, T>
+  ): string | void;
+  declare export function findKey<A, T: { [id: string]: A, ... }>(
+    object: void | null,
+    predicate?: ?OPredicate<A, T>
+  ): void;
+  declare export function findLastKey<A, T: { [id: string]: A, ... }>(
+    object: T,
+    predicate?: ?OPredicate<A, T>
+  ): string | void;
+  declare export function findLastKey<A, T: { [id: string]: A, ... }>(
+    object: void | null,
+    predicate?: ?OPredicate<A, T>
+  ): void;
+  declare export function forIn(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function forIn(object: void | null, iteratee?: ?OIteratee<any>): null;
+  declare export function forInRight(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function forInRight(object: void | null, iteratee?: ?OIteratee<any>): null;
+  declare export function forOwn(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function forOwn(object: void | null, iteratee?: ?OIteratee<any>): null;
+  declare export function forOwnRight(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function forOwnRight(object: void | null, iteratee?: ?OIteratee<any>): null;
+  declare export function functions(object?: ?Object): Array<string>;
+  declare export function functionsIn(object?: ?Object): Array<string>;
+  declare export function get(
+    object?: ?Object | ?$ReadOnlyArray<any> | void | null,
+    path?: ?$ReadOnlyArray<string | number> | string | number,
+    defaultValue?: any
+  ): any;
+  declare export function has(object: Object, path: Array<string> | string): boolean;
+  declare export function has(object: Object, path: void | null): false;
+  declare export function has(object: void | null, path?: ?Array<string> | ?string): false;
+  declare export function hasIn(object: Object, path: Array<string> | string): boolean;
+  declare export function hasIn(object: Object, path: void | null): false;
+  declare export function hasIn(object: void | null, path?: ?Array<string> | ?string): false;
+  declare export function invert(object: Object, multiVal?: ?boolean): Object;
+  declare export function invert(object: void | null, multiVal?: ?boolean): {...};
+  declare export function invertBy(object: Object, iteratee?: ?Function): Object;
+  declare export function invertBy(object: void | null, iteratee?: ?Function): {...};
+  declare export function invoke(
+    object?: ?Object,
+    path?: ?Array<string> | string,
+    ...args?: Array<any>
+  ): any;
+  declare export function keys<K>(object?: ?{ [key: K]: any, ... }): Array<K>;
+  declare export function keys(object?: ?Object): Array<string>;
+  declare export function keysIn(object?: ?Object): Array<string>;
+  declare export function mapKeys(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function mapKeys(object: void | null, iteratee?: ?OIteratee<any>): {...};
+  declare export function mapValues(object: Object, iteratee?: ?OIteratee<any>): Object;
+  declare export function mapValues(object: void | null, iteratee?: ?OIteratee<any>): {...};
+  declare export function merge(object?: ?Object, ...sources?: Array<?Object>): Object;
+  declare export function mergeWith(): {...};
+  declare export function mergeWith<T: Object, A: Object>(
+    object: T,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A
+    ) => any | void
+  ): Object;
+  declare export function mergeWith<T: Object, A: Object, B: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B
+    ) => any | void
+  ): Object;
+  declare export function mergeWith<T: Object, A: Object, B: Object, C: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C
+    ) => any | void
+  ): Object;
+  declare export function mergeWith<T: Object, A: Object, B: Object, C: Object, D: Object>(
+    object: T,
+    s1: A,
+    s2: B,
+    s3: C,
+    s4: D,
+    customizer?: (
+      objValue: any,
+      srcValue: any,
+      key: string,
+      object: T,
+      source: A | B | C | D
+    ) => any | void
+  ): Object;
+  declare export function omit(object?: ?Object, ...props: $ReadOnlyArray<string>): Object;
+  declare export function omit(object?: ?Object, props: $ReadOnlyArray<string>): Object;
+  declare export function omitBy<A, T: $ReadOnly<{ [id: string]: A, ... }>>(
+    object: T,
+    predicate?: ?OPredicate<A, T>
+  ): Object;
+  declare export function omitBy<A, T>(
+    object: void | null,
+    predicate?: ?OPredicate<A, T>
+  ): {...};
+  declare export function pick(object?: ?Object, ...props: $ReadOnlyArray<string>): Object;
+  declare export function pick(object?: ?Object, props: $ReadOnlyArray<string>): Object;
+  declare export function pickBy<A, T: $ReadOnly<{ [id: string]: A, ... }>>(
+    object: T,
+    predicate?: ?OPredicate<A, T>
+  ): Object;
+  declare export function pickBy<A, T>(
+    object: void | null,
+    predicate?: ?OPredicate<A, T>
+  ): {...};
+  declare export function result(
+    object?: ?Object,
+    path?: ?Array<string> | string,
+    defaultValue?: any
+  ): any;
+  declare export function set(object: Object, path?: ?Array<string> | string, value: any): Object;
+  declare export function set<T: void | null>(
+    object: T,
+    path?: ?Array<string> | string,
+    value?: ?any): T;
+  declare export function setWith<T>(
+    object: T,
+    path?: ?Array<string> | string,
+    value: any,
+    customizer?: (nsValue: any, key: string, nsObject: T) => any
+  ): Object;
+  declare export function setWith<T: void | null>(
+    object: T,
+    path?: ?Array<string> | string,
+    value?: ?any,
+    customizer?: ?(nsValue: any, key: string, nsObject: T) => any
+  ): T;
+  declare export function toPairs(object?: ?Object | Array<any>): Array<[string, any]>;
+  declare export function toPairsIn(object?: ?Object): Array<[string, any]>;
+  declare export function transform(
+    collection: Object | $ReadOnlyArray<any>,
+    iteratee?: ?OIteratee<any>,
+    accumulator?: any
+  ): any;
+  declare export function transform(
+    collection: void | null,
+    iteratee?: ?OIteratee<any>,
+    accumulator?: ?any
+  ): {...};
+  declare export function unset(object: Object, path?: ?Array<string> | ?string): boolean;
+  declare export function unset(object: void | null, path?: ?Array<string> | ?string): true;
+  declare export function update(object: Object, path: string[] | string, updater: Function): Object;
+  declare export function update<T: void | null>(
+    object: T,
+    path?: ?string[] | ?string,
+    updater?: ?Function): T;
+  declare export function updateWith(
+    object: Object,
+    path?: ?string[] | ?string,
+    updater?: ?Function,
+    customizer?: ?Function,
+  ): Object;
+  declare export function updateWith<T: void | null>(
+    object: T,
+    path?: ?string[] | ?string,
+    updater?: ?Function,
+    customizer?: ?Function,
+  ): T;
+  declare export function values(object?: ?Object): Array<any>;
+  declare export function valuesIn(object?: ?Object): Array<any>;
+
+  // Seq
+  declare export function chain<T>(value: T): any;
+  declare export function tap<T>(value: T, interceptor: (value: T) => any): T;
+  declare export function thru<T1, T2>(value: T1, interceptor: (value: T1) => T2): T2;
+
+  // String
+  declare export function camelCase(string: string): string;
+  declare export function camelCase(string: void | null): '';
+  declare export function capitalize(string: string): string;
+  declare export function capitalize(string: void | null): '';
+  declare export function deburr(string: string): string;
+  declare export function deburr(string: void | null): '';
+  declare export function endsWith(string: string, target?: string, position?: ?number): boolean;
+  declare export function endsWith(string: void | null, target?: ?string, position?: ?number): false;
+  declare export function escape(string: string): string;
+  declare export function escape(string: void | null): '';
+  declare export function escapeRegExp(string: string): string;
+  declare export function escapeRegExp(string: void | null): '';
+  declare export function kebabCase(string: string): string;
+  declare export function kebabCase(string: void | null): '';
+  declare export function lowerCase(string: string): string;
+  declare export function lowerCase(string: void | null): '';
+  declare export function lowerFirst(string: string): string;
+  declare export function lowerFirst(string: void | null): '';
+  declare export function pad(string?: ?string, length?: ?number, chars?: ?string): string;
+  declare export function padEnd(string?: ?string, length?: ?number, chars?: ?string): string;
+  declare export function padStart(string?: ?string, length?: ?number, chars?: ?string): string;
+  declare export function parseInt(string: string, radix?: ?number): number;
+  declare export function repeat(string: string, n?: ?number): string;
+  declare export function repeat(string: void | null, n?: ?number): '';
+  declare export function replace(
+    string: string,
+    pattern: RegExp | string,
+    replacement: ((string: string) => string) | string
+  ): string;
+  declare export function replace(
+    string: void | null,
+    pattern?: ?RegExp | ?string,
+    replacement: ?((string: string) => string) | ?string
+  ): '';
+  declare export function snakeCase(string: string): string;
+  declare export function snakeCase(string: void | null): '';
+  declare export function split(
+    string?: ?string,
+    separator?: ?RegExp | ?string,
+    limit?: ?number
+  ): Array<string>;
+  declare export function startCase(string: string): string;
+  declare export function startCase(string: void | null): '';
+  declare export function startsWith(string: string, target?: string, position?: number): boolean;
+  declare export function startsWith(string: void | null, target?: ?string, position?: ?number): false;
+  declare export function template(string?: ?string, options?: ?TemplateSettings): Function;
+  declare export function toLower(string: string): string;
+  declare export function toLower(string: void | null): '';
+  declare export function toUpper(string: string): string;
+  declare export function toUpper(string: void | null): '';
+  declare export function trim(string: string, chars?: string): string;
+  declare export function trim(string: void | null, chars?: ?string): '';
+  declare export function trimEnd(string: string, chars?: ?string): string;
+  declare export function trimEnd(string: void | null, chars?: ?string): '';
+  declare export function trimStart(string: string, chars?: ?string): string;
+  declare export function trimStart(string: void | null, chars?: ?string): '';
+  declare export function truncate(string: string, options?: TruncateOptions): string;
+  declare export function truncate(string: void | null, options?: ?TruncateOptions): '';
+  declare export function unescape(string: string): string;
+  declare export function unescape(string: void | null): '';
+  declare export function upperCase(string: string): string;
+  declare export function upperCase(string: void | null): '';
+  declare export function upperFirst(string: string): string;
+  declare export function upperFirst(string: void | null): '';
+  declare export function words(string?: ?string, pattern?: ?RegExp | ?string): Array<string>;
+
+  // Util
+  declare export function attempt(func: Function, ...args: Array<any>): any;
+  declare export function bindAll(object: Object, methodNames?: ?Array<string>): Object;
+  declare export function bindAll<T: void | null>(object: T, methodNames?: ?Array<string>): T;
+  declare export function bindAll(object: Object, ...methodNames: Array<string>): Object;
+  declare export function cond(pairs?: ?NestedArray<Function>): Function;
+  declare export function conforms(source?: ?Object): Function;
+  declare export function constant<T>(value: T): () => T;
+  declare export function defaultTo<T1: string | boolean | Object, T2>(
+    value: T1,
+    defaultValue: T2,
+  ): T1;
+  declare export function defaultTo<T1: number, T2>(value: T1, defaultValue: T2): T1 | T2;
+  declare export function defaultTo<T1: void | null, T2>(value: T1, defaultValue: T2): T2;
+  declare export var flow: ($ComposeReverse & (funcs: Array<Function>) => Function);
+  declare export var flowRight: ($Compose & (funcs: Array<Function>) => Function);
+  declare export function identity<T>(value: T): T;
+  declare export function iteratee(func?: any): Function;
+  declare export function matches(source?: ?Object): Function;
+  declare export function matchesProperty(path?: ?Array<string> | string, srcValue: any): Function;
+  declare export function method(path?: ?Array<string> | string, ...args?: Array<any>): Function;
+  declare export function methodOf(object?: ?Object, ...args?: Array<any>): Function;
+  declare export function mixin<T: Function | Object>(
+    object?: T,
+    source: Object,
+    options?: { chain: boolean, ... }
+  ): T;
+  declare export function noop(...args: Array<mixed>): void;
+  declare export function nthArg(n?: ?number): Function;
+  declare export function over(...iteratees: Array<Function>): Function;
+  declare export function over(iteratees: Array<Function>): Function;
+  declare export function overEvery(...predicates: Array<Function>): Function;
+  declare export function overEvery(predicates: Array<Function>): Function;
+  declare export function overSome(...predicates: Array<Function>): Function;
+  declare export function overSome(predicates: Array<Function>): Function;
+  declare export function property(path?: ?Array<string> | string): Function;
+  declare export function propertyOf(object?: ?Object): Function;
+  declare export function range(start: number, end: number, step?: number): Array<number>;
+  declare export function range(end: number, step?: number): Array<number>;
+  declare export function rangeRight(start?: ?number, end?: ?number, step?: ?number): Array<number>;
+  declare export function rangeRight(end?: ?number, step?: ?number): Array<number>;
+  declare export function runInContext(context?: ?Object): Function;
+
+  declare export function stubArray(): Array<any>;
+  declare export function stubFalse(): false;
+  declare export function stubObject(): {...};
+  declare export function stubString(): "";
+  declare export function stubTrue(): true;
+  declare export function times(n?: ?number, ...rest?: Array<void | null>): Array<number>;
+  declare export function times<T>(n: number, iteratee: (i: number) => T): Array<T>;
+  declare export function toPath(value: any): Array<string>;
+  declare export function uniqueId(prefix?: ?string): string;
+}
+declare module "lodash-es/chunk" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "chunk">;
+}
+declare module "lodash-es/compact" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "compact">;
+}
+declare module "lodash-es/concat" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "concat">;
+}
+declare module "lodash-es/difference" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "difference">;
+}
+declare module "lodash-es/differenceBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "differenceBy">;
+}
+declare module "lodash-es/differenceWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "differenceWith">;
+}
+declare module "lodash-es/drop" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "drop">;
+}
+declare module "lodash-es/dropRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "dropRight">;
+}
+declare module "lodash-es/dropRightWhile" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "dropRightWhile">;
+}
+declare module "lodash-es/dropWhile" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "dropWhile">;
+}
+declare module "lodash-es/fill" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "fill">;
+}
+declare module "lodash-es/findIndex" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "findIndex">;
+}
+declare module "lodash-es/findLastIndex" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "findLastIndex">;
+}
+declare module "lodash-es/first" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "first">;
+}
+declare module "lodash-es/flatten" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flatten">;
+}
+declare module "lodash-es/flattenDeep" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flattenDeep">;
+}
+declare module "lodash-es/flattenDepth" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flattenDepth">;
+}
+declare module "lodash-es/fromPairs" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "fromPairs">;
+}
+declare module "lodash-es/head" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "head">;
+}
+declare module "lodash-es/indexOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "indexOf">;
+}
+declare module "lodash-es/initial" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "initial">;
+}
+declare module "lodash-es/intersection" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "intersection">;
+}
+declare module "lodash-es/intersectionBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "intersectionBy">;
+}
+declare module "lodash-es/intersectionWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "intersectionWith">;
+}
+declare module "lodash-es/join" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "join">;
+}
+declare module "lodash-es/last" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "last">;
+}
+declare module "lodash-es/lastIndexOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "lastIndexOf">;
+}
+declare module "lodash-es/nth" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "nth">;
+}
+declare module "lodash-es/pull" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pull">;
+}
+declare module "lodash-es/pullAll" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pullAll">;
+}
+declare module "lodash-es/pullAllBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pullAllBy">;
+}
+declare module "lodash-es/pullAllWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pullAllWith">;
+}
+declare module "lodash-es/pullAt" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pullAt">;
+}
+declare module "lodash-es/remove" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "remove">;
+}
+declare module "lodash-es/reverse" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "reverse">;
+}
+declare module "lodash-es/slice" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "slice">;
+}
+declare module "lodash-es/sortedIndex" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedIndex">;
+}
+declare module "lodash-es/sortedIndexBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedIndexBy">;
+}
+declare module "lodash-es/sortedIndexOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedIndexOf">;
+}
+declare module "lodash-es/sortedLastIndex" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedLastIndex">;
+}
+declare module "lodash-es/sortedLastIndexBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedLastIndexBy">;
+}
+declare module "lodash-es/sortedLastIndexOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedLastIndexOf">;
+}
+declare module "lodash-es/sortedUniq" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedUniq">;
+}
+declare module "lodash-es/sortedUniqBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortedUniqBy">;
+}
+declare module "lodash-es/tail" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "tail">;
+}
+declare module "lodash-es/take" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "take">;
+}
+declare module "lodash-es/takeRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "takeRight">;
+}
+declare module "lodash-es/takeRightWhile" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "takeRightWhile">;
+}
+declare module "lodash-es/takeWhile" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "takeWhile">;
+}
+declare module "lodash-es/union" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "union">;
+}
+declare module "lodash-es/unionBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unionBy">;
+}
+declare module "lodash-es/unionWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unionWith">;
+}
+declare module "lodash-es/uniq" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "uniq">;
+}
+declare module "lodash-es/uniqBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "uniqBy">;
+}
+declare module "lodash-es/uniqWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "uniqWith">;
+}
+declare module "lodash-es/unzip" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unzip">;
+}
+declare module "lodash-es/unzipWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unzipWith">;
+}
+declare module "lodash-es/without" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "without">;
+}
+declare module "lodash-es/xor" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "xor">;
+}
+declare module "lodash-es/xorBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "xorBy">;
+}
+declare module "lodash-es/xorWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "xorWith">;
+}
+declare module "lodash-es/zip" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "zip">;
+}
+declare module "lodash-es/zipObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "zipObject">;
+}
+declare module "lodash-es/zipObjectDeep" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "zipObjectDeep">;
+}
+declare module "lodash-es/zipWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "zipWith">;
+}
+declare module "lodash-es/countBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "countBy">;
+}
+declare module "lodash-es/each" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "each">;
+}
+declare module "lodash-es/eachRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "eachRight">;
+}
+declare module "lodash-es/every" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "every">;
+}
+declare module "lodash-es/filter" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "filter">;
+}
+declare module "lodash-es/find" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "find">;
+}
+declare module "lodash-es/findLast" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "findLast">;
+}
+declare module "lodash-es/flatMap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flatMap">;
+}
+declare module "lodash-es/flatMapDeep" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flatMapDeep">;
+}
+declare module "lodash-es/flatMapDepth" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flatMapDepth">;
+}
+declare module "lodash-es/forEach" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forEach">;
+}
+declare module "lodash-es/forEachRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forEachRight">;
+}
+declare module "lodash-es/groupBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "groupBy">;
+}
+declare module "lodash-es/includes" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "includes">;
+}
+declare module "lodash-es/invokeMap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "invokeMap">;
+}
+declare module "lodash-es/keyBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "keyBy">;
+}
+declare module "lodash-es/map" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "map">;
+}
+declare module "lodash-es/orderBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "orderBy">;
+}
+declare module "lodash-es/partition" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "partition">;
+}
+declare module "lodash-es/reduce" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "reduce">;
+}
+declare module "lodash-es/reduceRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "reduceRight">;
+}
+declare module "lodash-es/reject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "reject">;
+}
+declare module "lodash-es/sample" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sample">;
+}
+declare module "lodash-es/sampleSize" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sampleSize">;
+}
+declare module "lodash-es/shuffle" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "shuffle">;
+}
+declare module "lodash-es/size" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "size">;
+}
+declare module "lodash-es/some" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "some">;
+}
+declare module "lodash-es/sortBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sortBy">;
+}
+declare module "lodash-es/now" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "now">;
+}
+declare module "lodash-es/after" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "after">;
+}
+declare module "lodash-es/ary" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "ary">;
+}
+declare module "lodash-es/before" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "before">;
+}
+declare module "lodash-es/bind" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "bind">;
+}
+declare module "lodash-es/bindKey" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "bindKey">;
+}
+declare module "lodash-es/curry" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "curry">;
+}
+declare module "lodash-es/curryRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "curryRight">;
+}
+declare module "lodash-es/debounce" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "debounce">;
+}
+declare module "lodash-es/defer" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "defer">;
+}
+declare module "lodash-es/delay" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "delay">;
+}
+declare module "lodash-es/flip" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flip">;
+}
+declare module "lodash-es/memoize" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "memoize">;
+}
+declare module "lodash-es/negate" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "negate">;
+}
+declare module "lodash-es/once" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "once">;
+}
+declare module "lodash-es/overArgs" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "overArgs">;
+}
+declare module "lodash-es/partial" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "partial">;
+}
+declare module "lodash-es/partialRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "partialRight">;
+}
+declare module "lodash-es/rearg" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "rearg">;
+}
+declare module "lodash-es/rest" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "rest">;
+}
+declare module "lodash-es/spread" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "spread">;
+}
+declare module "lodash-es/throttle" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "throttle">;
+}
+declare module "lodash-es/unary" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unary">;
+}
+declare module "lodash-es/wrap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "wrap">;
+}
+declare module "lodash-es/castArray" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "castArray">;
+}
+declare module "lodash-es/clone" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "clone">;
+}
+declare module "lodash-es/cloneDeep" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "cloneDeep">;
+}
+declare module "lodash-es/cloneDeepWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "cloneDeepWith">;
+}
+declare module "lodash-es/cloneWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "cloneWith">;
+}
+declare module "lodash-es/conformsTo" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "conformsTo">;
+}
+declare module "lodash-es/eq" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "eq">;
+}
+declare module "lodash-es/gt" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "gt">;
+}
+declare module "lodash-es/gte" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "gte">;
+}
+declare module "lodash-es/isArguments" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isArguments">;
+}
+declare module "lodash-es/isArray" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isArray">;
+}
+declare module "lodash-es/isArrayBuffer" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isArrayBuffer">;
+}
+declare module "lodash-es/isArrayLike" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isArrayLike">;
+}
+declare module "lodash-es/isArrayLikeObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isArrayLikeObject">;
+}
+declare module "lodash-es/isBoolean" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isBoolean">;
+}
+declare module "lodash-es/isBuffer" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isBuffer">;
+}
+declare module "lodash-es/isDate" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isDate">;
+}
+declare module "lodash-es/isElement" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isElement">;
+}
+declare module "lodash-es/isEmpty" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isEmpty">;
+}
+declare module "lodash-es/isEqual" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isEqual">;
+}
+declare module "lodash-es/isEqualWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isEqualWith">;
+}
+declare module "lodash-es/isError" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isError">;
+}
+declare module "lodash-es/isFinite" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isFinite">;
+}
+declare module "lodash-es/isFunction" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isFunction">;
+}
+declare module "lodash-es/isInteger" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isInteger">;
+}
+declare module "lodash-es/isLength" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isLength">;
+}
+declare module "lodash-es/isMap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isMap">;
+}
+declare module "lodash-es/isMatch" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isMatch">;
+}
+declare module "lodash-es/isMatchWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isMatchWith">;
+}
+declare module "lodash-es/isNaN" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isNaN">;
+}
+declare module "lodash-es/isNative" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isNative">;
+}
+declare module "lodash-es/isNil" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isNil">;
+}
+declare module "lodash-es/isNull" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isNull">;
+}
+declare module "lodash-es/isNumber" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isNumber">;
+}
+declare module "lodash-es/isObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isObject">;
+}
+declare module "lodash-es/isObjectLike" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isObjectLike">;
+}
+declare module "lodash-es/isPlainObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isPlainObject">;
+}
+declare module "lodash-es/isRegExp" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isRegExp">;
+}
+declare module "lodash-es/isSafeInteger" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isSafeInteger">;
+}
+declare module "lodash-es/isSet" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isSet">;
+}
+declare module "lodash-es/isString" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isString">;
+}
+declare module "lodash-es/isSymbol" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isSymbol">;
+}
+declare module "lodash-es/isTypedArray" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isTypedArray">;
+}
+declare module "lodash-es/isUndefined" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isUndefined">;
+}
+declare module "lodash-es/isWeakMap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isWeakMap">;
+}
+declare module "lodash-es/isWeakSet" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "isWeakSet">;
+}
+declare module "lodash-es/lt" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "lt">;
+}
+declare module "lodash-es/lte" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "lte">;
+}
+declare module "lodash-es/toArray" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toArray">;
+}
+declare module "lodash-es/toFinite" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toFinite">;
+}
+declare module "lodash-es/toInteger" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toInteger">;
+}
+declare module "lodash-es/toLength" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toLength">;
+}
+declare module "lodash-es/toNumber" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toNumber">;
+}
+declare module "lodash-es/toPlainObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toPlainObject">;
+}
+declare module "lodash-es/toSafeInteger" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toSafeInteger">;
+}
+declare module "lodash-es/toString" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toString">;
+}
+declare module "lodash-es/add" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "add">;
+}
+declare module "lodash-es/ceil" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "ceil">;
+}
+declare module "lodash-es/divide" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "divide">;
+}
+declare module "lodash-es/floor" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "floor">;
+}
+declare module "lodash-es/max" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "max">;
+}
+declare module "lodash-es/maxBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "maxBy">;
+}
+declare module "lodash-es/mean" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "mean">;
+}
+declare module "lodash-es/meanBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "meanBy">;
+}
+declare module "lodash-es/min" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "min">;
+}
+declare module "lodash-es/minBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "minBy">;
+}
+declare module "lodash-es/multiply" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "multiply">;
+}
+declare module "lodash-es/round" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "round">;
+}
+declare module "lodash-es/subtract" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "subtract">;
+}
+declare module "lodash-es/sum" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sum">;
+}
+declare module "lodash-es/sumBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "sumBy">;
+}
+declare module "lodash-es/clamp" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "clamp">;
+}
+declare module "lodash-es/inRange" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "inRange">;
+}
+declare module "lodash-es/random" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "random">;
+}
+declare module "lodash-es/assign" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "assign">;
+}
+declare module "lodash-es/assignIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "assignIn">;
+}
+declare module "lodash-es/assignInWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "assignInWith">;
+}
+declare module "lodash-es/assignWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "assignWith">;
+}
+declare module "lodash-es/at" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "at">;
+}
+declare module "lodash-es/create" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "create">;
+}
+declare module "lodash-es/defaults" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "defaults">;
+}
+declare module "lodash-es/defaultsDeep" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "defaultsDeep">;
+}
+declare module "lodash-es/entries" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "entries">;
+}
+declare module "lodash-es/entriesIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "entriesIn">;
+}
+declare module "lodash-es/extend" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "extend">;
+}
+declare module "lodash-es/extendWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "extendWith">;
+}
+declare module "lodash-es/findKey" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "findKey">;
+}
+declare module "lodash-es/findLastKey" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "findLastKey">;
+}
+declare module "lodash-es/forIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forIn">;
+}
+declare module "lodash-es/forInRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forInRight">;
+}
+declare module "lodash-es/forOwn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forOwn">;
+}
+declare module "lodash-es/forOwnRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "forOwnRight">;
+}
+declare module "lodash-es/functions" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "functions">;
+}
+declare module "lodash-es/functionsIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "functionsIn">;
+}
+declare module "lodash-es/get" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "get">;
+}
+declare module "lodash-es/has" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "has">;
+}
+declare module "lodash-es/hasIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "hasIn">;
+}
+declare module "lodash-es/invert" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "invert">;
+}
+declare module "lodash-es/invertBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "invertBy">;
+}
+declare module "lodash-es/invoke" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "invoke">;
+}
+declare module "lodash-es/keys" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "keys">;
+}
+declare module "lodash-es/keysIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "keysIn">;
+}
+declare module "lodash-es/mapKeys" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "mapKeys">;
+}
+declare module "lodash-es/mapValues" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "mapValues">;
+}
+declare module "lodash-es/merge" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "merge">;
+}
+declare module "lodash-es/mergeWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "mergeWith">;
+}
+declare module "lodash-es/omit" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "omit">;
+}
+declare module "lodash-es/omitBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "omitBy">;
+}
+declare module "lodash-es/pick" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pick">;
+}
+declare module "lodash-es/pickBy" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pickBy">;
+}
+declare module "lodash-es/result" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "result">;
+}
+declare module "lodash-es/set" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "set">;
+}
+declare module "lodash-es/setWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "setWith">;
+}
+declare module "lodash-es/toPairs" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toPairs">;
+}
+declare module "lodash-es/toPairsIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toPairsIn">;
+}
+declare module "lodash-es/transform" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "transform">;
+}
+declare module "lodash-es/unset" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unset">;
+}
+declare module "lodash-es/update" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "update">;
+}
+declare module "lodash-es/updateWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "updateWith">;
+}
+declare module "lodash-es/values" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "values">;
+}
+declare module "lodash-es/valuesIn" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "valuesIn">;
+}
+declare module "lodash-es/chain" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "chain">;
+}
+declare module "lodash-es/tap" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "tap">;
+}
+declare module "lodash-es/thru" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "thru">;
+}
+declare module "lodash-es/camelCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "camelCase">;
+}
+declare module "lodash-es/capitalize" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "capitalize">;
+}
+declare module "lodash-es/deburr" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "deburr">;
+}
+declare module "lodash-es/endsWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "endsWith">;
+}
+declare module "lodash-es/escape" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "escape">;
+}
+declare module "lodash-es/escapeRegExp" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "escapeRegExp">;
+}
+declare module "lodash-es/kebabCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "kebabCase">;
+}
+declare module "lodash-es/lowerCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "lowerCase">;
+}
+declare module "lodash-es/lowerFirst" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "lowerFirst">;
+}
+declare module "lodash-es/pad" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "pad">;
+}
+declare module "lodash-es/padEnd" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "padEnd">;
+}
+declare module "lodash-es/padStart" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "padStart">;
+}
+declare module "lodash-es/parseInt" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "parseInt">;
+}
+declare module "lodash-es/repeat" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "repeat">;
+}
+declare module "lodash-es/replace" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "replace">;
+}
+declare module "lodash-es/snakeCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "snakeCase">;
+}
+declare module "lodash-es/split" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "split">;
+}
+declare module "lodash-es/startCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "startCase">;
+}
+declare module "lodash-es/startsWith" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "startsWith">;
+}
+declare module "lodash-es/template" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "template">;
+}
+declare module "lodash-es/toLower" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toLower">;
+}
+declare module "lodash-es/toUpper" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toUpper">;
+}
+declare module "lodash-es/trim" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "trim">;
+}
+declare module "lodash-es/trimEnd" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "trimEnd">;
+}
+declare module "lodash-es/trimStart" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "trimStart">;
+}
+declare module "lodash-es/truncate" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "truncate">;
+}
+declare module "lodash-es/unescape" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "unescape">;
+}
+declare module "lodash-es/upperCase" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "upperCase">;
+}
+declare module "lodash-es/upperFirst" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "upperFirst">;
+}
+declare module "lodash-es/words" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "words">;
+}
+declare module "lodash-es/attempt" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "attempt">;
+}
+declare module "lodash-es/bindAll" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "bindAll">;
+}
+declare module "lodash-es/cond" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "cond">;
+}
+declare module "lodash-es/conforms" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "conforms">;
+}
+declare module "lodash-es/constant" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "constant">;
+}
+declare module "lodash-es/defaultTo" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "defaultTo">;
+}
+declare module "lodash-es/flow" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flow">;
+}
+declare module "lodash-es/flowRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "flowRight">;
+}
+declare module "lodash-es/identity" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "identity">;
+}
+declare module "lodash-es/iteratee" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "iteratee">;
+}
+declare module "lodash-es/matches" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "matches">;
+}
+declare module "lodash-es/matchesProperty" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "matchesProperty">;
+}
+declare module "lodash-es/method" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "method">;
+}
+declare module "lodash-es/methodOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "methodOf">;
+}
+declare module "lodash-es/mixin" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "mixin">;
+}
+declare module "lodash-es/noop" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "noop">;
+}
+declare module "lodash-es/nthArg" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "nthArg">;
+}
+declare module "lodash-es/over" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "over">;
+}
+declare module "lodash-es/overEvery" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "overEvery">;
+}
+declare module "lodash-es/overSome" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "overSome">;
+}
+declare module "lodash-es/property" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "property">;
+}
+declare module "lodash-es/propertyOf" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "propertyOf">;
+}
+declare module "lodash-es/range" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "range">;
+}
+declare module "lodash-es/rangeRight" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "rangeRight">;
+}
+declare module "lodash-es/runInContext" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "runInContext">;
+}
+declare module "lodash-es/stubArray" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "stubArray">;
+}
+declare module "lodash-es/stubFalse" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "stubFalse">;
+}
+declare module "lodash-es/stubObject" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "stubObject">;
+}
+declare module "lodash-es/stubString" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "stubString">;
+}
+declare module "lodash-es/stubTrue" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "stubTrue">;
+}
+declare module "lodash-es/times" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "times">;
+}
+declare module "lodash-es/toPath" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "toPath">;
+}
+declare module "lodash-es/uniqueId" {
+  declare export default $PropertyType<$Exports<"lodash-es">, "uniqueId">;
+}
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js
new file mode 100644
index 0000000000..93d0d653d6
--- /dev/null
+++ b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js
@@ -0,0 +1,520 @@
+// @flow
+import {
+  assign,
+  assignIn,
+  assignWith,
+  at,
+  bindAll,
+  bindKey,
+  castArray,
+  chain,
+  chunk,
+  compact,
+  concat,
+  cond,
+  conforms,
+  constant,
+  countBy,
+  create,
+  defaults,
+  defaultsDeep,
+  difference,
+  differenceBy,
+  differenceWith,
+  drop,
+  dropRight,
+  dropRightWhile,
+  dropWhile,
+  fill,
+  filter,
+  flatMap,
+  flatMapDeep,
+  flatMapDepth,
+  flatten,
+  flattenDeep,
+  flattenDepth,
+  flow,
+  flowRight,
+  fromPairs,
+  functions,
+  functionsIn,
+  groupBy,
+  initial,
+  intersection,
+  intersectionBy,
+  invert,
+  invertBy,
+  invokeMap,
+  iteratee,
+  keyBy,
+  keys,
+  keysIn,
+  map,
+  mapKeys,
+  mapValues,
+  matches,
+  matchesProperty,
+  merge,
+  mergeWith,
+  method,
+  methodOf,
+  nthArg,
+  omit,
+  omitBy,
+  orderBy,
+  over,
+  overArgs,
+  overEvery,
+  overSome,
+  partition,
+  pick,
+  pickBy,
+  property,
+  propertyOf,
+  pull,
+  pullAll,
+  pullAllBy,
+  pullAllWith,
+  pullAt,
+  rangeRight,
+  reject,
+  remove,
+  reverse,
+  sampleSize,
+  set,
+  setWith,
+  shuffle,
+  slice,
+  sortBy,
+  sortedUniq,
+  sortedUniqBy,
+  split,
+  tail,
+  take,
+  takeRight,
+  takeRightWhile,
+  takeWhile,
+  toArray,
+  toPairs,
+  toPairsIn,
+  toPath,
+  toPlainObject,
+  transform,
+  union,
+  unionBy,
+  unionWith,
+  uniq,
+  uniqBy,
+  uniqWith,
+  unset,
+  unzip,
+  unzipWith,
+  update,
+  updateWith,
+  values,
+  valuesIn,
+  without,
+  words,
+  wrap,
+  xor,
+  xorBy,
+  xorWith,
+  zip,
+  zipObject,
+  zipObjectDeep,
+  zipWith,
+  entries,
+  entriesIn,
+  extend,
+  extendWith,
+  camelCase,
+  capitalize,
+  clamp,
+  clone,
+  cloneDeep,
+  cloneDeepWith,
+  cloneWith,
+  deburr,
+  defaultTo,
+  endsWith,
+  eq,
+  escape,
+  escapeRegExp,
+  find,
+  findIndex,
+  findKey,
+  findLast,
+  findLastIndex,
+  findLastKey,
+  forEach,
+  forEachRight,
+  forIn,
+  forInRight,
+  forOwn,
+  forOwnRight,
+  get,
+  gt,
+  gte,
+  has,
+  hasIn,
+  head,
+  identity,
+  includes,
+  indexOf,
+  invoke,
+  isArguments,
+  isArray,
+  isArrayBuffer,
+  isArrayLike,
+  isArrayLikeObject,
+  isBoolean,
+  isBuffer,
+  isDate,
+  isElement,
+  isEmpty,
+  isEqual,
+  isEqualWith,
+  isError,
+  isFinite,
+  isFunction,
+  isInteger,
+  isLength,
+  isMap,
+  isMatch,
+  isMatchWith,
+  isNaN,
+  isNative,
+  isNil,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isPlainObject,
+  isRegExp,
+  isSafeInteger,
+  isSet,
+  isString,
+  isSymbol,
+  isTypedArray,
+  isUndefined,
+  isWeakMap,
+  isWeakSet,
+  join,
+  kebabCase,
+  last,
+  lastIndexOf,
+  lowerCase,
+  lowerFirst,
+  lt,
+  lte,
+  max,
+  min,
+  stubArray,
+  stubFalse,
+  stubObject,
+  stubString,
+  stubTrue,
+  nth,
+  noop,
+  now,
+  pad,
+  padEnd,
+  padStart,
+  reduce,
+  reduceRight,
+  repeat,
+  replace,
+  result,
+  runInContext,
+  sample,
+  snakeCase,
+  some,
+  sortedIndex,
+  sortedIndexBy,
+  sortedIndexOf,
+  sortedLastIndex,
+  sortedLastIndexBy,
+  sortedLastIndexOf,
+  startCase,
+  startsWith,
+  template,
+  times,
+  toFinite,
+  toInteger,
+  toLength,
+  toLower,
+  toNumber,
+  toSafeInteger,
+  toString,
+  toUpper,
+  trim,
+  trimEnd,
+  trimStart,
+  truncate,
+  unescape,
+  uniqueId,
+  upperCase,
+  upperFirst,
+  each,
+  eachRight,
+  first,
+} from "lodash-es";
+
+(assign(): {...});
+(assignIn(): {...});
+(assignWith(): {...});
+(at(): Array<any>);
+(bindAll(): void);
+(bindKey(): Function);
+(castArray(): Array<any>);
+(chain(null): null);
+(chunk(null, null): Array<any>);
+(compact(null): Array<any>);
+(concat(): Array<any>);
+(cond(null): Function);
+(conforms(null): Function);
+(constant(null): Function);
+(countBy(null, null): {...});
+(create(null, null): {...});
+(defaults(): {...});
+(defaultsDeep(): {...});
+(difference(): Array<any>);
+(differenceBy(): Array<any>);
+(differenceWith(): Array<any>);
+(drop(null, null): Array<any>);
+(dropRight(null, null): Array<any>);
+(dropRightWhile(null, null): Array<any>);
+(dropWhile(null, null): Array<any>);
+(fill(null, null, null, null): Array<any>);
+(filter(null, null): Array<any>);
+(flatMap(null, null): Array<any>);
+(flatMapDeep(null, null): Array<any>);
+(flatMapDepth(null, null, null): Array<any>);
+(flatten(null): Array<any>);
+(flattenDeep(null): Array<any>);
+(flattenDepth(null, null): Array<any>);
+(flow(): Function);
+(flowRight(): Function);
+(fromPairs(null): {...});
+(functions(null): Array<any>);
+(functionsIn(null): Array<any>);
+(groupBy(null, null): {...});
+(initial(null): Array<any>);
+(intersection(): Array<any>);
+(intersectionBy(): Array<any>);
+(invert(null, null): {...});
+(invertBy(null, null): {...});
+(invokeMap(): Array<any>);
+(iteratee(null): Function);
+(keyBy(null, null): {...});
+(keys(null): Array<any>);
+(keysIn(null): Array<any>);
+(map(null, null): Array<any>);
+(mapKeys(null, null): {...});
+(mapValues(null, null): {...});
+(matches(null): Function);
+(matchesProperty(null, null): Function);
+(merge(): {...});
+(mergeWith(): {...});
+(method(): Function);
+(methodOf(): Function);
+(nthArg(null): Function);
+(omit(): {...});
+(omitBy(null, null): {...});
+(orderBy(null, null, null): Array<any>);
+(over(): Function);
+(overArgs(): Function);
+(overEvery(): Function);
+(overSome(): Function);
+(partition(null, null): [Array<any>,Array<any>]);
+(pick(): {...});
+(pickBy(null, null): {...});
+(property(null): Function);
+(propertyOf(null): Function);
+(pull(): void);
+(pullAll(null, null): null);
+(pullAllBy(null, null, null): null);
+(pullAllWith(null, null, null): null);
+(pullAt(): Array<any>);
+(rangeRight(null, null, null): Array<any>);
+(reject(null, null): Array<any>);
+(remove(null, null): Array<any>);
+(reverse(null): null);
+(sampleSize(null, null): Array<any>);
+(set(null, null, null): null);
+(setWith(null, null, null, null): null);
+(shuffle(null): Array<any>);
+(slice(null, null, null): Array<any>);
+(sortBy(): Array<any>);
+(sortedUniq(null): Array<any>);
+(sortedUniqBy(null, null): Array<any>);
+(split(null, null, null): Array<any>);
+(tail(null): Array<any>);
+(take(null, null): Array<any>);
+(takeRight(null, null): Array<any>);
+(takeRightWhile(null, null): Array<any>);
+(takeWhile(null, null): Array<any>);
+(toArray(null): Array<any>);
+(toPairs(null): Array<any>);
+(toPairsIn(null): Array<any>);
+(toPath(null): Array<any>);
+(toPlainObject(null): {...});
+(transform(null, null, null): {...});
+(union(): Array<any>);
+(unionBy(): Array<any>);
+(unionWith(): Array<any>);
+(uniq(null): Array<any>);
+(uniqBy(null, null): Array<any>);
+(uniqWith(null, null): Array<any>);
+(unset(null, null): true);
+(unzip(null): Array<any>);
+(unzipWith(null, null): Array<any>);
+(update(null, null, null): null);
+(updateWith(null, null, null, null): null);
+(values(null): Array<any>);
+(valuesIn(null): Array<any>);
+(without(): Array<any>);
+(words(null, null): Array<any>);
+(wrap(null, null): Function);
+(xor(): Array<any>);
+(xorBy(): Array<any>);
+(xorWith(): Array<any>);
+(zip(): Array<any>);
+(zipObject(null, null): {...});
+(zipObjectDeep(null, null): {...});
+(zipWith(): Array<any>);
+(entries(null): Array<any>);
+(entriesIn(null): Array<any>);
+(extend(): Object);
+(extendWith(): Object);
+(camelCase(null): '');
+(capitalize(null): '');
+(clamp(null, null, null): 0);
+(clone(null): null);
+(cloneDeep(null): null);
+(cloneDeepWith(null, null): null);
+(cloneWith(null, null): null);
+(deburr(null): '');
+(defaultTo(null, null): null);
+(endsWith(null, null, null): false);
+(eq(null, null): boolean);
+(escape(null): '');
+(escapeRegExp(null): '');
+(find(null, null, null): void);
+(findIndex(null, null, null): -1);
+(findKey(null, null): void);
+(findLast(null, null, null): void);
+(findLastIndex(null, null, null): -1);
+(findLastKey(null, null): void);
+(forEach(null, null): null);
+(forEachRight(null, null): null);
+(forIn(null, null): null);
+(forInRight(null, null): null);
+(forOwn(null, null): null);
+(forOwnRight(null, null): null);
+(get(null, null, null): null);
+(gt(null, null): boolean);
+(gte(null, null): boolean);
+(has(null, null): false);
+(hasIn(null, null): false);
+(head(null): void);
+(identity(null): null);
+(includes(null, null, null): false);
+(indexOf(null, null, null): -1);
+(invoke(): void);
+(isArguments(null): false);
+(isArray(null): false);
+(isArrayBuffer(null): false);
+(isArrayLike(null): false);
+(isArrayLikeObject(null): false);
+(isBoolean(null): false);
+(isBuffer(): false);
+(isDate(null): false);
+(isElement(null): false);
+(isEmpty(null): true);
+(isEqual(null, null): boolean);
+(isEqualWith(null, null, null): boolean);
+(isError(null): false);
+(isFinite(null): false);
+(isFunction(null): false);
+(isInteger(null): false);
+(isLength(null): false);
+(isMap(null): false);
+(isMatch(null, null): boolean);
+(isMatchWith(null, null, null): boolean);
+(isNaN(null): false);
+(isNative(null): false);
+(isNil(null): true);
+(isNull(null): true);
+(isNumber(null): false);
+(isObject(null): false);
+(isObjectLike(null): false);
+(isPlainObject(null): false);
+(isRegExp(null): false);
+(isSafeInteger(null): false);
+(isSet(null): false);
+(isString(null): false);
+(isSymbol(null): false);
+(isTypedArray(null): false);
+(isUndefined(null): false);
+(isWeakMap(null): false);
+(isWeakSet(null): false);
+(join(null, null): '');
+(kebabCase(null): '');
+(last(null): void);
+(lastIndexOf(null, null, null): -1);
+(lowerCase(null): '');
+(lowerFirst(null): '');
+(lt(null, null): boolean);
+(lte(null, null): boolean);
+(max(null): void);
+(min(null): void);
+(stubArray(): Array<any>);
+(stubFalse(): false);
+(stubObject(): {...});
+(stubString(): '');
+(stubTrue(): true);
+(nth(null, null): void);
+(noop(): void);
+(now(): number);
+(pad(null, null, null): string);
+(padEnd(null, null, null): string);
+(padStart(null, null, null): string);
+(reduce(null, null): void | null);
+(reduceRight(null, null): void | null);
+(repeat(null, null): '');
+(replace(): '');
+(result(null, null, null): null);
+(runInContext(null): Function);
+(sample(null): void);
+(snakeCase(null): '');
+(some(null, null): false);
+(sortedIndex(null, null): 0);
+(sortedIndexBy(null, null, null): 0);
+(sortedIndexOf(null, null): -1);
+(sortedLastIndex(null, null): 0);
+(sortedLastIndexBy(null, null, null): 0);
+(sortedLastIndexOf(null, null): -1);
+(startCase(null): '');
+(startsWith(null, null, null): false);
+(template(null, null): Function);
+(times(null, null): Array<any>);
+(toFinite(null): 0);
+(toInteger(null): 0);
+(toLength(null): 0);
+(toLower(null): '');
+(toNumber(null): 0);
+(toSafeInteger(null): 0);
+(toString(null): '');
+(toUpper(null): '');
+(trim(null, null): '');
+(trimEnd(null, null): '');
+(trimStart(null, null): '');
+(truncate(null, null): '');
+(unescape(null): '');
+(uniqueId(null): string);
+(upperCase(null): '');
+(upperFirst(null): '');
+(each(null, null): null);
+(eachRight(null, null): null);
+(first(null): void);
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js
new file mode 100644
index 0000000000..0a47675184
--- /dev/null
+++ b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js
@@ -0,0 +1,54 @@
+// @flow
+import {
+  debounce,
+  memoize,
+  tap,
+  thru
+} from "lodash-es";
+// These tests are generated with modified script from this issue:
+// https://github.com/flowtype/flow-typed/issues/1639
+
+//$FlowExpectedError
+after(null, null);
+//$FlowExpectedError
+ary(null, null, null);
+//$FlowExpectedError
+before(null, null);
+//$FlowExpectedError
+bind();
+//$FlowExpectedError
+curry(null, null, null);
+//$FlowExpectedError
+curryRight(null, null, null);
+//$FlowExpectedError
+debounce(null, null, null);
+//$FlowExpectedError
+defer();
+//$FlowExpectedError
+delay();
+//$FlowExpectedError
+flip(null);
+//$FlowExpectedError
+memoize(null, null);
+//$FlowExpectedError
+negate(null);
+//$FlowExpectedError
+once(null);
+//$FlowExpectedError
+partial(null, null);
+//$FlowExpectedError
+partialRight(null, null);
+//$FlowExpectedError
+rearg(null, null);
+//$FlowExpectedError
+rest(null, null);
+//$FlowExpectedError
+spread(null, null);
+//$FlowExpectedError
+tap(null, null);
+//$FlowExpectedError
+throttle(null, null, null);
+//$FlowExpectedError
+thru(null, null);
+//$FlowExpectedError
+unary(null);
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_lodash-es-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_lodash-es-v4.x.x.js
new file mode 100644
index 0000000000..b4f7539a29
--- /dev/null
+++ b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_lodash-es-v4.x.x.js
@@ -0,0 +1,497 @@
+// @flow
+import {
+  assignIn,
+  attempt,
+  clone,
+  concat,
+  conformsTo,
+  countBy,
+  debounce,
+  defaultTo,
+  difference,
+  differenceBy,
+  each,
+  extend,
+  find,
+  first,
+  flatMap,
+  forEach,
+  get,
+  groupBy,
+  intersectionBy,
+  isEqual,
+  isString,
+  keyBy,
+  map,
+  memoize,
+  noop,
+  omitBy,
+  pickBy,
+  pullAllBy,
+  range,
+  sortedIndexBy,
+  sortedLastIndexBy,
+  tap,
+  thru,
+  times,
+  toPairs,
+  toPairsIn,
+  unionBy,
+  uniqBy,
+  xorBy,
+  zip,
+  zipWith
+} from "lodash-es";
+
+/**
+ * _.attempt
+ */
+attempt(() => void 0);
+attempt(x => x);
+attempt(x => x, "first arg");
+attempt((x, y, z) => {}, null, {}, []);
+
+/**
+ * _.countBy
+ */
+countBy([6.1, 4.2, 6.3], Math.floor);
+countBy(["one", "two", "three"], "length");
+
+/**
+ * _.difference
+ */
+difference((["a", "b"]: $ReadOnlyArray<string>), (["b"]: $ReadOnlyArray<string>));
+difference((["a", "b"]: $ReadOnlyArray<string>), (["b"]: $ReadOnlyArray<string>), (["a"]: $ReadOnlyArray<string>));
+
+/**
+ * _.differenceBy
+ */
+differenceBy(([2.1, 1.2]: $ReadOnlyArray<any>), [2.3, 3.4], Math.floor);
+differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], "x");
+
+/**
+ * _.differenceBy
+ */
+differenceBy(([2.1, 1.2]: $ReadOnlyArray<any>), [2.3, 3.4], Math.floor);
+
+/**
+ * _.each
+ */
+each(([1, 2]: $ReadOnlyArray<number>), (item: number) => false);
+
+/**
+ * _.find
+ */
+find([1, 2, 3], x => x * 1 == 3);
+find([1, 2, 3], x => x == 2, 1);
+// $FlowExpectedError number cannot be compared to string
+find([1, 2, 3], x => x == "a");
+// $FlowExpectedError number. This type is incompatible with function type.
+find([1, 2, 3], 1);
+// $FlowExpectedError property `y`. Property not found in object literal
+find([{ x: 1 }, { x: 2 }, { x: 3 }], v => v.y == 3);
+find([{ x: 1 }, { x: 2 }, { x: 3 }], v => v.x == 3);
+find({ x: 1, y: 2 }, (a: number, b: string) => a);
+find({ x: 1, y: 2 }, { x: 3 });
+find((["a", "b"]: $ReadOnlyArray<string>), "c");
+
+// $FlowExpectedError undefined. This type is incompatible with object type.
+var result: Object = find(users, "active");
+
+/**
+ * _.find examples from the official doc
+ */
+var users = [
+  { user: "barney", age: 36, active: true },
+  { user: "fred", age: 40, active: false },
+  { user: "pebbles", age: 1, active: true }
+];
+
+find(users, function(o) {
+  return o.age < 40;
+});
+
+// The `_.matches` iteratee shorthand.
+find(users, { age: 1, active: true });
+
+// The `_.matchesProperty` iteratee shorthand.
+find(users, ["active", false]);
+
+// The `_.property` iteratee shorthand.
+find(users, "active");
+
+/**
+ * _.forEach
+ */
+forEach(([1, 2]: $ReadOnlyArray<number>), (item: number) => false);
+
+/**
+ * _.groupBy
+ */
+var numbersGroupedByMathFloor = groupBy([6.1, 4.2, 6.3], Math.floor);
+if (numbersGroupedByMathFloor[6]) {
+  numbersGroupedByMathFloor[6][0] / numbersGroupedByMathFloor[6][1];
+}
+var stringsGroupedByLength = groupBy(["one", "two", "three"], "length");
+if (stringsGroupedByLength[3]) {
+  stringsGroupedByLength[3][0].toLowerCase();
+}
+var numbersObj: { [key: string]: number, ... } = { a: 6.1, b: 4.2, c: 6.3 };
+var numbersGroupedByMathFloor2 = groupBy(numbersObj, Math.floor);
+if (numbersGroupedByMathFloor2[6]) {
+  numbersGroupedByMathFloor2[6][0] / numbersGroupedByMathFloor2[6][1];
+}
+var stringObj: { [key: string]: string, ... } = { a: "one", b: "two", c: "three" };
+var stringsGroupedByLength2 = groupBy(stringObj, "length");
+if (stringsGroupedByLength2[3]) {
+  stringsGroupedByLength2[3][0].toLowerCase();
+}
+
+/**
+ * _.intersectionBy
+ */
+intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+intersectionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+
+/**
+ * _.get
+ */
+
+// Object — examples from lodash docs
+var exampleObjectForGetTest = { a: [{ b: { c: 3 } }] };
+get(exampleObjectForGetTest, "a[0].b.c");
+get(exampleObjectForGetTest, ["a", "0", "b", "c"]);
+get(exampleObjectForGetTest, "a.b.c", "default");
+
+// Array — not documented, but _.get does support arrays
+get([1, 2, 3], "0");
+get(["foo", "bar", "baz"], "[1]");
+get([{ a: "foo" }, { b: "bar" }, { c: "baz" }], "2");
+get([[1, 2], [3, 4], [5, 6], [7, 8]], "3");
+
+// Nil - it is safe to perform on nil root values, just like nil values along the "get" path
+get(null, 'thing');
+get(undefined, 'data');
+
+// Path argument may also be a numeric index (flow-typed/flow-typed/pull/2444)
+// It's definitely safe: get → baseGet → castPath → stringToPath → toString
+get([1, 2, 3], 0);
+
+/**
+ * _.keyBy
+ */
+keyBy([{ dir: "left", code: 97 }, { dir: "right", code: 100 }], function(o) {
+  return String.fromCharCode(o.code);
+});
+keyBy([{ dir: "left", code: 97 }, { dir: "right", code: 100 }], "dir");
+
+// Example of keying a map of objects by a number type
+type KeyByTest$ByNumber<T: Object> = { [number]: T, ... };
+type KeyByTest$ByNumberMaybe<T: ?Object> = { [number]: T, ... };
+type KeyByTest$Record = { id: number, ... };
+var keyByTest_array: Array<KeyByTest$Record> = [
+  { id: 4 },
+  { id: 4 },
+  { id: 7 }
+];
+var keyByTest_map: KeyByTest$ByNumber<KeyByTest$Record> = {
+  [keyByTest_array[0].id]: keyByTest_array[0],
+  [keyByTest_array[1].id]: keyByTest_array[1],
+  [keyByTest_array[2].id]: keyByTest_array[2]
+};
+
+var keyByTest_map2: KeyByTest$ByNumberMaybe<?KeyByTest$Record> = keyBy(
+  keyByTest_map,
+  "id"
+);
+
+/**
+ * _.map examples from the official doc
+ */
+function square(n) {
+  return n * n;
+}
+
+map([4, 8], square);
+map({ a: 4, b: 8 }, square);
+
+//accepts tuple types
+
+const tuple: [number, number] = [1, 2];
+map(tuple, val => val + 2);
+//$FlowExpectedError cannot push to tuple
+map(tuple, (val, nothing, tupleArray) => tupleArray.push(123));
+
+var users = [{ user: "barney" }, { user: "fred" }];
+
+// The `_.property` iteratee shorthand.
+map(users, "user");
+
+/**
+ * _.pullAllBy
+ */
+pullAllBy([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 1 }], [{ x: 1 }, { x: 3 }], "x");
+
+/**
+ * _.unionBy
+ */
+unionBy([2.1], [1.2, 2.3], Math.floor);
+unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+
+/**
+ * _.uniqBy
+ */
+uniqBy([2.1, 1.2, 2.3], Math.floor);
+uniqBy([{ x: 1 }, { x: 2 }, { x: 1 }], "x");
+
+/**
+ * _.clone
+ */
+clone({ a: 1 }).a == 1;
+// $FlowExpectedError property `b`. Property not found in object literal
+clone({ a: 1 }).b == 1;
+// $FlowExpectedError number. This type is incompatible with function type.
+clone({ a: 1 }).a == "c";
+
+/**
+ * _.isEqual
+ */
+isEqual("a", "b");
+isEqual({ x: 1 }, { y: 2 });
+
+// Flow considers this compatible with isEqual(a: any, b: any).
+// Reasonable people disagree about whether this should be considered a legal call.
+// See https://github.com/splodingsocks/FlowTyped/pull/1#issuecomment-149345275
+// and https://github.com/facebook/flow/issues/956
+isEqual(1);
+
+// $FlowExpectedError function type expects no more than 2 arguments
+isEqual(1, 2, 3);
+
+/**
+ * _.range
+ */
+range(0, 10)[4] == 4;
+// $FlowExpectedError string. This type is incompatible with number
+range(0, "a");
+// $FlowExpectedError string cannot be compared to number
+range(0, 10)[4] == "a";
+
+/**
+ * _.sortedIndexBy
+ */
+sortedIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, function(o) {
+  return o.x;
+});
+sortedIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, "x");
+
+/**
+ * _.sortedLastIndexBy
+ */
+sortedLastIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, function(o) {
+  return o.x;
+});
+sortedLastIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, "x");
+
+/**
+ * _.extend
+ */
+extend({ a: 1 }, { b: 2 }).a;
+extend({ a: 1 }, { b: 2 }).b;
+// $FlowExpectedError property `c`. Property not found in object literal
+extend({ a: 1 }, { b: 2 }).c;
+// $FlowExpectedError property `c`. Poperty not found in object literal
+assignIn({ a: 1 }, { b: 2 }).c;
+
+/**
+ * _.xorBy
+ */
+xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+
+/**
+ * _.zip
+ */
+zip(["a", "b", "c"], ["d", "e", "f"])[0].length;
+
+zip(["a", "b", "c"], [1, 2, 3])[0].length;
+
+var tupleA = zip(["a", "b", "c"], [1, 2, 3])[0];
+tupleA[0] && tupleA[0] + "a";
+
+var tupleB = zip(["a", "b", "c"], [1, 2, 3])[0];
+tupleB[1] && tupleB[1] * 10;
+// $FlowExpectedError `x` property not found in Array
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0].x;
+// $FlowExpectedError `y` property not found in object literal
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][0].y;
+// $FlowExpectedError `y` is missing in null or undefined
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][1].y;
+// $FlowExpectedError Flow could potentially catch this -- the tuple only has two elements.
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][2];
+zip(['A'], ['A', 'B']).map(([x, y]) =>
+  // $FlowExpectedError `x` is `undefined for second item
+  x.toLowerCase() + y.toLowerCase()
+)
+zip(['A'], ['A', 'B']).map(([x, y]) =>
+  (x || '').toLowerCase() + (y || '').toLowerCase()
+)
+
+/**
+ * _.zipWith
+ */
+zipWith(["a", "b", "c"], [1, 2, 3], (str, num) => ({ [str]: num }));
+// $FlowExpectedError `x` should be a `string`, `y` a `number`
+zipWith(["a", "b", "c"], [1, 2, 3]).map(([x, y]) => x * y);
+
+/**
+ * _.isString
+ */
+
+var boolTrue: true;
+var boolFalse: false;
+
+boolTrue = isString("foo");
+boolFalse = isString([""]);
+boolFalse = isString({});
+boolFalse = isString(5);
+boolFalse = isString(function(f) {
+  return f;
+});
+boolFalse = isString();
+boolFalse = isString(true);
+
+// $FlowExpectedError
+boolFalse = isString("");
+// $FlowExpectedError
+boolTrue = isString(undefined);
+
+/**
+ * _.find
+ */
+find([1, 2, 3], x => x == 1);
+// $FlowExpectedError number. This type is incompatible with function type.
+find([1, 2, 3], 1);
+
+// Copy pasted tests from iflow-lodash
+var nums: number[] = [1, 2, 3, 4, 5, 6];
+var num: number;
+var string: string;
+var bool: boolean;
+
+var nativeSquares: number[];
+var directSquares: number[];
+
+var nativeStrings: string[];
+var directStrings: string[];
+
+var allNums: number[];
+var numsAndStrList: Array<number | string>;
+var mixedList: Array<mixed>;
+allNums = concat(nums, nums, nums);
+numsAndStrList = concat(nums, "123", "456");
+numsAndStrList = concat(nums, ["123", "456"]);
+numsAndStrList = concat(nums, [[1, 2, 3], "456"]);
+mixedList = concat(nums, [[1, 2, 3], "456"]);
+
+// Array#map, lodash.map, lodash#map
+nativeSquares = nums.map(function(num) {
+  return num * num;
+});
+directSquares = map(nums, function(num) {
+  return num * num;
+});
+
+num = first(nums);
+
+// return type of iterator is reflected in result and chain
+nativeStrings = nums.map(function(num) {
+  return JSON.stringify(num);
+});
+directStrings = map(nums, function(num) {
+  return JSON.stringify(num);
+});
+
+var obj = { a: 1, b: 2 };
+bool = conformsTo(obj, {
+  a: function(x: number) {
+    return true;
+  }
+});
+
+num = defaultTo(undefined, 2);
+string = defaultTo(undefined, "str");
+bool = defaultTo(true, "str");
+string = defaultTo("str", true);
+
+num = tap(1, function(n) {
+  return false;
+});
+bool = thru(1, function(n) {
+  return false;
+});
+
+var timesNums: number[];
+
+timesNums = times(5);
+// $FlowExpectedError string. This type is incompatible with number
+var strings: string[] = times(5);
+timesNums = times(5, function(i: number) {
+  return i + 1;
+});
+// $FlowExpectedError string. This type is incompatible with number
+timesNums = times(5, function(i: number) {
+  return JSON.stringify(i);
+});
+
+// lodash.flatMap for collections and objects
+// this arrow function needs a type annotation due to a bug in flow
+// https://github.com/facebook/flow/issues/1948
+flatMap([1, 2, 3], (n): number[] => [n, n]);
+flatMap({ a: 1, b: 2 }, n => [n, n]);
+
+/**
+ * _.noop
+ */
+noop();
+noop(1);
+noop("a", 2, [], null);
+(noop: string => void);
+(noop: (number, string) => void);
+// $FlowExpectedError functions are contravariant in return types
+(noop: string => string);
+
+/**
+ * _.memoize
+ */
+var memoized: (a: number) => string = memoize((a: number) => "foo");
+// $FlowExpectedError memoize retains type information
+memoized = memoize(() => {});
+
+/**
+ * _.debounce
+ */
+var debounced: (a: number) => string = debounce((a: number) => "foo");
+// $FlowExpectedError debounce retains type information
+debounced = debounce(() => {});
+
+/**
+ * _.toPairs / _.toPairsIn
+ */
+var pairs: [string, number][];
+pairs = toPairs({ a: 12, b: 100 });
+pairs = toPairsIn({ a: 12, b: 100 });
+
+/**
+ * _.pickBy
+ */
+(pickBy({a: 2, b: 3, c: 4}, num => num % 2): { [prop: string]: number, ... });
+(pickBy(null, num => num % 2): {...});
+(pickBy(undefined, num => num % 2): {...});
+
+/**
+ * _.omitBy
+ */
+(omitBy({a: 2, b: 3, c: 4}, num => num % 2): { [prop: string]: number, ... });
+(omitBy(null, num => num % 2): {...});
+(omitBy(undefined, num => num % 2): {...});
diff --git a/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_modules-lodash-es-v4.x.x.js b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_modules-lodash-es-v4.x.x.js
new file mode 100644
index 0000000000..9bbb8470a4
--- /dev/null
+++ b/definitions/npm/lodash-es_v4.x.x/flow_v0.201.x-/test_modules-lodash-es-v4.x.x.js
@@ -0,0 +1,121 @@
+// @flow
+import assignIn from 'lodash-es/assignIn'
+import attempt from 'lodash-es/attempt'
+import clone from 'lodash-es/clone'
+import concat from 'lodash-es/concat'
+import conformsTo from 'lodash-es/conformsTo'
+import countBy from 'lodash-es/countBy'
+import defaultTo from 'lodash-es/defaultTo'
+import difference from 'lodash-es/difference'
+import differenceBy from 'lodash-es/differenceBy'
+import each from 'lodash-es/each'
+import extend from 'lodash-es/extend'
+import find from 'lodash-es/find'
+import first from 'lodash-es/first'
+import flatMap from 'lodash-es/flatMap'
+import forEach from 'lodash-es/forEach'
+import get from 'lodash-es/get'
+import groupBy from 'lodash-es/groupBy'
+import intersectionBy from 'lodash-es/intersectionBy'
+import isEqual from 'lodash-es/isEqual'
+import keyBy from 'lodash-es/keyBy'
+import pullAllBy from 'lodash-es/pullAllBy'
+import range from 'lodash-es/range'
+import tap from 'lodash-es/tap'
+import thru from 'lodash-es/thru'
+import times from 'lodash-es/times'
+import zip from 'lodash-es/zip'
+
+/**
+ * _.attempt
+ */
+attempt(() => void 0);
+
+/**
+ * _.countBy
+ */
+countBy([6.1, 4.2, 6.3], Math.floor);
+
+/**
+ * _.difference
+ */
+difference((["a", "b"]: $ReadOnlyArray<string>), (["b"]: $ReadOnlyArray<string>));
+
+/**
+ * _.differenceBy
+ */
+differenceBy(([2.1, 1.2]: $ReadOnlyArray<any>), [2.3, 3.4], Math.floor);
+
+/**
+ * _.each
+ */
+each(([1, 2]: $ReadOnlyArray<number>), (item: number) => false);
+
+/**
+ * _.find
+ */
+find([1, 2, 3], x => x * 1 == 3);
+
+/**
+ * _.forEach
+ */
+forEach(([1, 2]: $ReadOnlyArray<number>), (item: number) => false);
+
+/**
+ * _.groupBy
+ */
+var numbersGroupedByMathFloor = groupBy([6.1, 4.2, 6.3], Math.floor);
+
+/**
+ * _.intersectionBy
+ */
+intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+
+/**
+ * _.get
+ */
+
+var exampleObjectForGetTest = { a: [{ b: { c: 3 } }] };
+get(exampleObjectForGetTest, "a[0].b.c");
+
+/**
+ * _.keyBy
+ */
+keyBy([{ dir: "left", code: 97 }, { dir: "right", code: 100 }], function(o) {
+  return String.fromCharCode(o.code);
+});
+
+/**
+ * _.pullAllBy
+ */
+pullAllBy([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 1 }], [{ x: 1 }, { x: 3 }], "x");
+
+/**
+ * _.clone
+ */
+clone({ a: 1 }).a == 1;
+
+/**
+ * _.isEqual
+ */
+isEqual("a", "b");
+
+/**
+ * _.range
+ */
+range(0, 10)[4] == 4;
+
+/**
+ * _.extend
+ */
+extend({ a: 1 }, { b: 2 }).a;
+
+/**
+ * _.zip
+ */
+zip(["a", "b", "c"], ["d", "e", "f"])[0].length;
+
+/**
+ * _.find
+ */
+find([1, 2, 3], x => x == 1);
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.155.x-/lodash_v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/lodash_v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash_v4.x.x/flow_v0.155.x-/lodash_v4.x.x.js
rename to definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/lodash_v4.x.x.js
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_does-not-fail-on-null-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_does-not-fail-on-null-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_does-not-fail-on-null-v4.x.x.js
rename to definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_does-not-fail-on-null-v4.x.x.js
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_fails-on-null-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_fails-on-null-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_fails-on-null-v4.x.x.js
rename to definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_fails-on-null-v4.x.x.js
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_lodash-fp-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_lodash-fp-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_lodash-fp-v4.x.x.js
rename to definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_lodash-fp-v4.x.x.js
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_lodash-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_lodash-v4.x.x.js
similarity index 100%
rename from definitions/npm/lodash_v4.x.x/flow_v0.155.x-/test_lodash-v4.x.x.js
rename to definitions/npm/lodash_v4.x.x/flow_v0.155.x-v.200.x/test_lodash-v4.x.x.js
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/lodash_v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/lodash_v4.x.x.js
new file mode 100644
index 0000000000..3fcd1a775b
--- /dev/null
+++ b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/lodash_v4.x.x.js
@@ -0,0 +1,6316 @@
+declare module "lodash" {
+  declare type Path = $ReadOnlyArray<string | number> | string | number;
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
+    ...r: [AA]
+  ) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB]) => R);
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
+    ...r: [AA]
+  ) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC]) => R);
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type UnaryFn<A, R> = (a: A) => R;
+
+  declare type TemplateSettings = {
+    escape?: RegExp,
+    evaluate?: RegExp,
+    imports?: Object,
+    interpolate?: RegExp,
+    variable?: string,
+    ...
+  };
+
+  declare type TruncateOptions = {
+    length?: number,
+    omission?: string,
+    separator?: RegExp | string,
+    ...
+  };
+
+  declare type Cancelable = {
+    cancel: () => void,
+    flush: () => mixed,
+    ...
+  };
+
+  declare type DebounceOptions = {
+    leading?: boolean,
+    maxWait?: number,
+    trailing?: boolean,
+    ...
+  };
+
+  declare type ThrottleOptions = {
+    leading?: boolean,
+    trailing?: boolean,
+    ...
+  };
+
+  // using opaque type for object key is not supported by Flow atm: https://github.com/facebook/flow/issues/5407
+  declare type Key = string | number;
+  declare type IndexerObject<V, K = Key> = { [key: K]: V, ... };
+  declare type ReadOnlyIndexerObject<V, K = Key> = $ReadOnly<IndexerObject<V, K>>;
+  declare type NestedArray<V> = Array<Array<V>>;
+  declare type Collection<V, K = Key> = $ReadOnlyArray<V> | ReadOnlyIndexerObject<V, K>;
+
+  declare type matchesIterateeShorthand = { [key: string]: any, ... };
+  declare type matchesPropertyIterateeShorthand = [string, any];
+  declare type propertyIterateeShorthand = string;
+
+  declare type OPredicate<A, O> =
+    | ((value: A, key: string, object: O) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type IterateeWithResult<V, K, O, R> =
+    | ((value: V, key: K, object: O) => R)
+    | string;
+
+  declare type OIterateeWithResult<V, K, O, R> =
+    | ReadOnlyIndexerObject<V, K>
+    | IterateeWithResult<V, K, O, R>;
+  declare type OIteratee<O> = OIterateeWithResult<any, any, O, any>;
+
+  declare type AFlatMapIteratee<V, O, R> =
+    | ((item: V, index: number, array: O) => $ReadOnlyArray<R> | R)
+    | string
+  declare type OFlatMapIteratee<V, K, O, R> = IterateeWithResult<V, K, O, $ReadOnlyArray<R> | R>;
+
+  declare type Predicate<T> =
+    | ((value: T, index: number, array: Array<T>) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type _ValueOnlyIteratee<T> = (value: T) => mixed;
+  declare type ValueOnlyIteratee<T> = _ValueOnlyIteratee<T> | string;
+  declare type _Iteratee<T> = (
+    item: T,
+    index: number,
+    array: ?Array<T>
+  ) => mixed;
+  declare type Iteratee<T> = _Iteratee<T> | Object | string;
+  declare type Comparator<T> = (item: T, item2: T) => boolean;
+
+  declare type ReadOnlyMapIterator<T, U> =
+    | ((item: T, index: number, array: $ReadOnlyArray<T>) => U)
+    | propertyIterateeShorthand;
+
+  declare type OMapIterator<T, O, U> =
+    | ((item: T, key: string, object: O) => U)
+    | propertyIterateeShorthand;
+
+  declare type Lodash = {|
+    // Array
+    chunk<T>(array?: ?$ReadOnlyArray<T>, size?: ?number): Array<Array<T>>;
+    compact<T, N = ?T | boolean>(array?: ?$ReadOnlyArray<N>): Array<T>;
+    concat<T>(
+      base?: ?$ReadOnlyArray<T>,
+      ...elements: $ReadOnlyArray<any>
+    ): Array<T | any>;
+    difference<T>(
+      array?: ?$ReadOnlyArray<T>,
+      ...values: $ReadOnlyArray<?$ReadOnlyArray<T>>
+    ): Array<T>;
+    differenceBy<T, U>(
+      array?: ?$ReadOnlyArray<T>,
+      values?: ?$ReadOnlyArray<U>,
+      iteratee?: ?ValueOnlyIteratee<T | U>
+    ): Array<T>;
+    differenceWith<T, U>(
+      array?: ?$ReadOnlyArray<T>,
+      values?: ?$ReadOnlyArray<U>,
+      comparator?: ?(item: T, item2: U) => boolean
+    ): Array<T>;
+    drop<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
+    dropRight<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
+    dropRightWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
+    dropWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
+    fill<T, U>(
+      array?: ?Array<T>,
+      value?: ?U,
+      start?: ?number,
+      end?: ?number
+    ): Array<T | U>;
+    findIndex:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => number)
+      & (<T>(
+        array: void | null,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => -1);
+    findLastIndex:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => number)
+      & (<T>(
+        array: void | null,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => -1);
+    // alias of _.head
+    first<T>(array: ?$ReadOnlyArray<T>): T;
+    flatten<T, X>(array?: ?$ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
+    flattenDeep<T>(array?: ?$ReadOnlyArray<any>): Array<T>;
+    flattenDepth(array?: ?$ReadOnlyArray<any>, depth?: ?number): Array<any>;
+    fromPairs<A, B>(pairs?: ?$ReadOnlyArray<[A, B]>): {| [key: A]: B |};
+    head<T>(array: ?$ReadOnlyArray<T>): T;
+    indexOf:
+      & (<T>(array: $ReadOnlyArray<T>, value: T, fromIndex?: number) => number)
+      & (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => -1);
+    initial<T>(array: ?$ReadOnlyArray<T>): Array<T>;
+    intersection<T>(...arrays?: Array<$ReadOnlyArray<T>>): Array<T>;
+    //Workaround until (...parameter: T, parameter2: U) works
+    intersectionBy:
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        a3?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        a3?: ?$ReadOnlyArray<T>,
+        a4?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>);
+    //Workaround until (...parameter: T, parameter2: U) works
+    intersectionWith:
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        comparator?: ?Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        comparator?: ?Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        a3?: ?$ReadOnlyArray<T>,
+        comparator?: ?Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2?: ?$ReadOnlyArray<T>,
+        a3?: ?$ReadOnlyArray<T>,
+        a4?: ?$ReadOnlyArray<T>,
+        comparator?: ?Comparator<T>
+      ) => Array<T>);
+    join:
+      & (<T>(array: $ReadOnlyArray<T>, separator?: ?string) => string)
+      & (<T>(array: void | null, separator?: ?string) => "");
+    last<T>(array: ?$ReadOnlyArray<T>): T;
+    lastIndexOf:
+      & (<T>(array: $ReadOnlyArray<T>, value?: ?T, fromIndex?: ?number) => number)
+      & (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => -1);
+    nth:
+      & (<T>(array: $ReadOnlyArray<T>, n?: ?number) => T)
+      & ((array: void | null, n?: ?number) => void);
+    pull:
+      & (<T>(array: Array<T>, ...values?: $ReadOnlyArray<?T>) => Array<T>)
+      & (<T: void | null>(array: T, ...values?: $ReadOnlyArray<?any>) => T);
+    pullAll:
+      & (<T>(array: Array<T>, values?: ?$ReadOnlyArray<T>) => Array<T>)
+      & (<T: void | null>(array: T, values?: ?$ReadOnlyArray<any>) => T);
+    pullAllBy:
+      & (<T>(
+        array: Array<T>,
+        values?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T: void | null>(
+        array: T,
+        values?: ?$ReadOnlyArray<any>,
+        iteratee?: ?ValueOnlyIteratee<any>
+      ) => T);
+    pullAllWith:
+      & (<T: void | null>(
+        array: T,
+        values?: ?$ReadOnlyArray<any>,
+        comparator?: ?Function
+      ) => T)
+      & (<T>(array: Array<T>, values?: ?($ReadOnlyArray<T>), comparator?: ?Function) => Array<T>);
+    pullAt:
+      & (<T>(array?: ?Array<T>, ...indexed?: $ReadOnlyArray<?number>) => Array<T>)
+      & (<T>(array?: ?Array<T>, indexed?: ?$ReadOnlyArray<number>) => Array<T>);
+    remove<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
+    reverse:
+      & (<T>(array: Array<T>) => Array<T>)
+      & (<T: void | null>(array: T) => T);
+    slice<T>(
+      array?: ?$ReadOnlyArray<T>,
+      start?: ?number,
+      end?: ?number
+    ): Array<T>;
+    sortedIndex:
+      & (<T>(array: $ReadOnlyArray<T>, value: T) => number)
+      & (<T>(array: void | null, value: ?T) => 0);
+    sortedIndexBy:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        value?: ?T,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => number)
+      & (<T>(
+        array: void | null,
+        value?: ?T,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => 0);
+    sortedIndexOf:
+      & (<T>(array: $ReadOnlyArray<T>, value: T) => number)
+      & (<T>(array: void | null, value?: ?T) => -1);
+    sortedLastIndex:
+      & (<T>(array: $ReadOnlyArray<T>, value: T) => number)
+      & (<T>(array: void | null, value?: ?T) => 0);
+    sortedLastIndexBy:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        value: T,
+        iteratee?: ValueOnlyIteratee<T>
+      ) => number)
+      & (<T>(
+        array: void | null,
+        value?: ?T,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => 0);
+    sortedLastIndexOf:
+      & (<T>(array: $ReadOnlyArray<T>, value: T) => number)
+      & (<T>(array: void | null, value?: ?T) => -1);
+    sortedUniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
+    sortedUniqBy<T>(
+      array?: ?$ReadOnlyArray<T>,
+      iteratee?: ?ValueOnlyIteratee<T>
+    ): Array<T>;
+    tail<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
+    take<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
+    takeRight<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
+    takeRightWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
+    takeWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
+    union: <T>(...arrays?: Array<$ReadOnlyArray<T>>) => Array<T>;
+    //Workaround until (...parameter: T, parameter2: U) works
+    unionBy:
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1?: ?$ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        iteratee?: ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        iteratee?: ValueOnlyIteratee<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        a4: $ReadOnlyArray<T>,
+        iteratee?: ValueOnlyIteratee<T>
+      ) => Array<T>);
+    //Workaround until (...parameter: T, parameter2: U) works
+    unionWith:
+      & (<T>(a1?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        a4: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>);
+    uniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
+    uniqBy<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
+    uniqWith<T>(array?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>): Array<T>;
+    unzip<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
+    unzipWith<T>(array: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
+    without<T>(array?: ?$ReadOnlyArray<T>, ...values?: Array<?T>): Array<T>;
+    xor<T>(...array: $ReadOnlyArray<$ReadOnlyArray<T>>): Array<T>;
+    //Workaround until (...parameter: T, parameter2: U) works
+    xorBy:
+      & (<T>(a1?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>) => Array<T>)
+      & (<T>(
+      a1: $ReadOnlyArray<T>,
+      a2: $ReadOnlyArray<T>,
+      iteratee?: ValueOnlyIteratee<T>
+    ) => Array<T>)
+    & (<T>(
+      a1: $ReadOnlyArray<T>,
+      a2: $ReadOnlyArray<T>,
+      a3: $ReadOnlyArray<T>,
+      iteratee?: ValueOnlyIteratee<T>
+    ) => Array<T>)
+    & (<T>(
+      a1: $ReadOnlyArray<T>,
+      a2: $ReadOnlyArray<T>,
+      a3: $ReadOnlyArray<T>,
+      a4: $ReadOnlyArray<T>,
+      iteratee?: ValueOnlyIteratee<T>
+    ) => Array<T>);
+    //Workaround until (...parameter: T, parameter2: U) works
+    xorWith:
+      & (<T>(a1?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>)
+      & (<T>(
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>,
+        a3: $ReadOnlyArray<T>,
+        a4: $ReadOnlyArray<T>,
+        comparator?: Comparator<T>
+      ) => Array<T>);
+    zip:
+      & (<A, B>(a1?: ?($ReadOnlyArray<A>), a2?: ?($ReadOnlyArray<B>)) => Array<[A, B]>)
+      & (<A, B, C>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>) => Array<[A, B, C]>)
+      & (<A, B, C, D>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>, a4: $ReadOnlyArray<D>) => Array<[A, B, C, D]>)
+      & (<A, B, C, D, E>(
+        a1: $ReadOnlyArray<A>,
+        a2: $ReadOnlyArray<B>,
+        a3: $ReadOnlyArray<C>,
+        a4: $ReadOnlyArray<D>,
+        a5: $ReadOnlyArray<E>
+      ) => Array<[A, B, C, D, E]>);
+
+    zipObject:
+      & (<K, V>(props: $ReadOnlyArray<K>, values?: ?$ReadOnlyArray<V>) => { [key: K]: V, ... })
+      & (<K, V>(props: void | null, values?: ?$ReadOnlyArray<V>) => {...});
+    zipObjectDeep:
+      & ((props: $ReadOnlyArray<any>, values?: ?any) => Object)
+      & ((props: void | null, values?: ?any) => {...});
+
+    zipWith:
+      & (<A>(a1?: ?$ReadOnlyArray<A>) => Array<[A]>)
+      & (<T, A>(a1: $ReadOnlyArray<A>, iteratee: (A) => T) => Array<T>)
+      & (<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>) => Array<[A, B]>)
+      & (<T, A, B>(
+      a1: $ReadOnlyArray<A>,
+      a2: $ReadOnlyArray<B>,
+      iteratee: (A, B) => T
+    ) => Array<T>)
+    & (<A, B, C>(
+      a1: $ReadOnlyArray<A>,
+      a2: $ReadOnlyArray<B>,
+      a3: $ReadOnlyArray<C>
+    ) => Array<[A, B, C]>)
+    & (<T, A, B, C>(
+      a1: $ReadOnlyArray<A>,
+      a2: $ReadOnlyArray<B>,
+      a3: $ReadOnlyArray<C>,
+      iteratee: (A, B, C) => T
+    ) => Array<T>)
+    & (<A, B, C, D>(
+      a1: $ReadOnlyArray<A>,
+      a2: $ReadOnlyArray<B>,
+      a3: $ReadOnlyArray<C>,
+      a4: $ReadOnlyArray<D>
+    ) => Array<[A, B, C, D]>)
+    & (<T, A, B, C, D>(
+      a1: $ReadOnlyArray<A>,
+      a2: $ReadOnlyArray<B>,
+      a3: $ReadOnlyArray<C>,
+      a4: $ReadOnlyArray<D>,
+      iteratee: (A, B, C, D) => T
+    ) => Array<T>);
+
+    // Collection
+    countBy:
+      & (<T>(array: $ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... })
+      & (<T>(array: void | null, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... })
+      & ((string: string, iteratee?: ?ValueOnlyIteratee<string>) => { [key: string]: number, ... })
+      & (<T>(object: ReadOnlyIndexerObject<T>, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... });
+    // alias of _.forEach
+    each<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
+    // alias of _.forEachRight
+    eachRight<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
+    every:
+      & (<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>) => boolean)
+      & ((str: string, iteratee?: ?Iteratee<string>) => boolean)
+      & (<A, T: ReadOnlyIndexerObject<A>>(object: T, iteratee?: OIterateeWithResult<A, string, T, any>) => boolean);
+    filter:
+      & (<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>) => Array<T>)
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: OPredicate<A, T>
+      ) => Array<A>);
+    find:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => T | void)
+      & (<T>(
+        array: void | null,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => void)
+      & (<R, A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: ?OPredicate<A, T>,
+        fromIndex?: ?number
+      ) => R);
+    findLast:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => T | void)
+      & (<T>(
+        array: void | null,
+        predicate?: ?Predicate<T>,
+        fromIndex?: ?number
+      ) => void)
+      & (<R, A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: ?OPredicate<A, T>,
+        fromIndex?: ?number
+      ) => R);
+    flatMap:
+      & (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
+        array: T,
+        iteratee?: ?AFlatMapIteratee<A, T, U>
+      ) => Array<U>)
+      & (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
+        object: T,
+        iteratee?: ?OFlatMapIteratee<A, K, T, U>
+      ) => Array<U>);
+    flatMapDeep:
+      & (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
+        array: T,
+        iteratee?: ?AFlatMapIteratee<A, T, any>
+      ) => Array<U>)
+      & (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
+        object: T,
+        iteratee?: ?OFlatMapIteratee<A, K, T, any>
+      ) => Array<U>);
+    flatMapDepth:
+      & (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
+        array: T,
+        iteratee?: ?AFlatMapIteratee<A, T, any>,
+        depth?: ?number
+      ) => Array<U>)
+      & (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
+        object: T,
+        iteratee?: ?OFlatMapIteratee<A, K, T, any>,
+        depth?: ?number
+      ) => Array<U>);
+    forEach<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
+    forEachRight<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
+    groupBy:
+      & (<V, T>(
+        array: $ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => { [key: V]: Array<T>, ... })
+      & ((array: void | null, iteratee?: ?ValueOnlyIteratee<any>) => {...})
+      & (<V, A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        iteratee?: ValueOnlyIteratee<A>
+      ) => { [key: V]: Array<A>, ... });
+    includes:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        value: T,
+        fromIndex?: ?number
+      ) => boolean)
+      & (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => false)
+      & (<A>(object: ReadOnlyIndexerObject<A>, value: A, fromIndex?: number) => boolean)
+      & ((str: string, value: string, fromIndex?: number) => boolean);
+    invokeMap:
+      & (<T>(
+        array?: ?$ReadOnlyArray<T>,
+        path?: ?((value: T) => Path) | Path,
+        ...args?: $ReadOnlyArray<any>
+      ) => Array<any>)
+      & (<A>(
+        object: ReadOnlyIndexerObject<A>,
+        path: ((value: any) => Path) | Path,
+        ...args?: $ReadOnlyArray<any>
+      ) => Array<any>);
+    keyBy:
+      & (<T, V>(
+        array: $ReadOnlyArray<T>,
+        iteratee?: ?ValueOnlyIteratee<T>
+      ) => { [key: V]: T, ... })
+      & ((array: void | null, iteratee?: ?ValueOnlyIteratee<any>) => {...})
+      & (<V, A, K, T: ReadOnlyIndexerObject<A, K>>(
+        object: T,
+        iteratee?: ?ValueOnlyIteratee<A>
+      ) => { [key: V]: A, ... });
+    map:
+      & (<T, U>(
+        array?: ?$ReadOnlyArray<T>,
+        iteratee?: ?ReadOnlyMapIterator<T, U>
+      ) => Array<U>)
+      & (<V, T: ReadOnlyIndexerObject<V>, U>(
+        object: ?T,
+        iteratee?: OMapIterator<V, T, U>
+      ) => Array<U>)
+      & ((
+        str: ?string,
+        iteratee?: (char: string, index: number, str: string) => any
+      ) => string);
+    orderBy:
+      & (<T>(
+        array: $ReadOnlyArray<T>,
+        iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
+        orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
+      ) => Array<T>)
+      & (<T>(
+        array: null | void,
+        iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
+        orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
+      ) => Array<T>)
+      & (<V, T: ReadOnlyIndexerObject<V>>(
+        object: T,
+        iteratees?: $ReadOnlyArray<OIteratee<any>> | string,
+        orders?: $ReadOnlyArray<"asc" | "desc"> | string
+      ) => Array<V>);
+    partition:
+      & (<T>(
+        array?: ?$ReadOnlyArray<T>,
+        predicate?: ?Predicate<T>
+      ) => [Array<T>, Array<T>])
+      & (<V, A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: OPredicate<A, T>
+      ) => [Array<V>, Array<V>]);
+    reduce:
+      & (<T, U>(
+        array: $ReadOnlyArray<T>,
+        iteratee?: (
+          accumulator: U,
+          value: T,
+          index: number,
+          array: ?Array<T>
+        ) => U,
+        accumulator?: U
+      ) => U)
+      & (<T, U>(
+        array: void | null,
+        iteratee?: ?(
+          accumulator: U,
+          value: T,
+          index: any,
+          array: ?Array<T>
+        ) => U,
+        accumulator?: U
+      ) => U)
+      & (<A, T: ReadOnlyIndexerObject<A>, U>(
+        object: T,
+        iteratee?: (accumulator: U, value: any, key: string, object: T) => U,
+        accumulator?: U
+      ) => U);
+    reduceRight:
+      & (<T, U>(
+        array: void | null,
+        iteratee?: ?(
+          accumulator: U,
+          value: T,
+          index: any,
+          array: ?Array<T>
+        ) => U,
+        accumulator?: U
+      ) => U)
+      & (<T, U>(
+        array: $ReadOnlyArray<T>,
+        iteratee?: ?(
+          accumulator: U,
+          value: T,
+          index: number,
+          array: ?Array<T>
+        ) => U,
+        accumulator?: ?U
+      ) => U)
+      & (<A, T: ReadOnlyIndexerObject<A>, U>(
+        object: T,
+        iteratee?: ?(accumulator: U, value: any, key: string, object: T) => U,
+        accumulator?: ?U
+      ) => U);
+    reject:
+      & (<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>) => Array<T>)
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object?: ?T,
+        predicate?: ?OPredicate<A, T>
+      ) => Array<A>);
+    sample<T>(collection: ?Collection<T>): T;
+    sampleSize<T>(collection?: ?Collection<T>, n?: ?number): Array<T>;
+    shuffle<T>(array?: ?Collection<T>): Array<T>;
+    size(collection?: ?Collection<any> | string): number;
+    some:
+      & (<T>(array: void | null, predicate?: ?Predicate<T>) => false)
+      & (<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>) => boolean)
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object?: ?T,
+        predicate?: OPredicate<A, T>
+      ) => boolean);
+    sortBy:
+      & (<T>(
+        array: ?$ReadOnlyArray<T>,
+        ...iteratees?: $ReadOnlyArray<Iteratee<T>>
+      ) => Array<T>)
+      & (<T>(
+        array: ?$ReadOnlyArray<T>,
+        iteratees?: $ReadOnlyArray<Iteratee<T>>
+      ) => Array<T>)
+      & (<V, T: ReadOnlyIndexerObject<V>>(
+        object: T,
+        ...iteratees?: $ReadOnlyArray<OIteratee<T>>
+      ) => Array<V>)
+      & (<V, T: ReadOnlyIndexerObject<V>>(
+        object: T,
+        iteratees?: $ReadOnlyArray<OIteratee<T>>
+      ) => Array<V>);
+
+    // Date
+    now(): number;
+
+    // Function
+    after(n: number, fn: Function): Function;
+    ary(func: Function, n?: number): Function;
+    before(n: number, fn: Function): Function;
+    bind<F:(...$ReadOnlyArray<any>) => any>(func: F, thisArg: any, ...partials: $ReadOnlyArray<any>): F;
+    bindKey(obj?: ?Object, key?: ?string, ...partials?: $ReadOnlyArray<?any>): Function;
+    curry:
+      & Curry
+      & ((func: Function, arity?: number) => Function);
+    curryRight(func: Function, arity?: number): Function;
+    debounce<F: (...$ReadOnlyArray<any>) => any>(
+      func: F,
+      wait?: number,
+      options?: DebounceOptions
+    ): F & Cancelable;
+    defer(func: (...$ReadOnlyArray<any>) => any, ...args?: $ReadOnlyArray<any>): TimeoutID;
+    delay(func: Function, wait: number, ...args?: $ReadOnlyArray<any>): TimeoutID;
+    flip<R>(func: (...$ReadOnlyArray<any>) => R): (...Array<any>) => R;
+    memoize<A, R>(func: (...A) => R, resolver?: (...A) => any): (...A) => R;
+    negate<A, R>(predicate: (...A) => R): (...A) => boolean;
+    once<F: (...$ReadOnlyArray<any>) => any>(func: F): F;
+    overArgs:
+      & ((func?: ?Function, ...transforms?: $ReadOnlyArray<Function>) => Function)
+      & ((func?: ?Function, transforms?: ?$ReadOnlyArray<Function>) => Function);
+    partial<R>(func: (...$ReadOnlyArray<any>) => R, ...partials: $ReadOnlyArray<any>): (...Array<any>) => R;
+    partialRight:
+      & (<R>(func: (...$ReadOnlyArray<any>) => R, ...partials: $ReadOnlyArray<any>) => ((...Array<any>) => R))
+      & (<R>(func: (...$ReadOnlyArray<any>) => R, partials: $ReadOnlyArray<any>) => ((...Array<any>) => R));
+    rearg:
+      & ((func: Function, ...indexes: $ReadOnlyArray<number>) => Function)
+      & ((func: Function, indexes: $ReadOnlyArray<number>) => Function);
+    rest(func: Function, start?: number): Function;
+    spread(func: Function): Function;
+    throttle<F: (...$ReadOnlyArray<any>) => any>(
+      func: F,
+      wait?: number,
+      options?: ThrottleOptions
+    ): F & Cancelable;
+    unary<F: (...$ReadOnlyArray<any>) => any>(func: F): F;
+    wrap(value?: any, wrapper?: ?Function): Function;
+
+    // Lang
+    castArray:
+      & (() => Array<any>)
+      & (<T: void | null | number | string | {...}>(value: T) => Array<T>)
+      & (<T: Array<any>>(value: T) => T);
+    clone<T>(value: T): T;
+    cloneDeep<T>(value: T): T;
+    cloneDeepWith<T, U>(
+      value: T,
+      customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
+    ): U;
+    cloneWith<T, U>(
+      value: T,
+      customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
+    ): U;
+    conformsTo<T: ReadOnlyIndexerObject<mixed>>(
+      source: T,
+      predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
+    ): boolean;
+    eq(value: any, other: any): boolean;
+    gt(value: any, other: any): boolean;
+    gte(value: any, other: any): boolean;
+    isArguments:
+      & ((value: void | null) => false)
+      & ((value: any) => boolean);
+    isArray:
+      & ((value: $ReadOnlyArray<any>) => true)
+      & ((value: any) => false);
+    isArrayBuffer:
+      & ((value: ArrayBuffer) => true)
+      & ((value: any) => false);
+    isArrayLike:
+      & ((value: $ReadOnlyArray<any> | string | { length: number, ... }) => true)
+      & ((value: any) => false);
+    isArrayLikeObject:
+      & ((value: { length: number, ... } | $ReadOnlyArray<any>) => true)
+      & ((value: any) => false);
+    isBoolean:
+      & ((value: boolean) => true)
+      & ((value: any) => false);
+    isBuffer:
+      & ((value: void | null) => false)
+      & ((value: any) => boolean);
+    isDate:
+      & ((value: Date) => true)
+      & ((value: any) => false);
+    isElement:
+      & ((value: Element) => true)
+      & ((value: any) => false);
+    isEmpty:
+      & ((value: void | null | "" | {...} | [] | number | boolean) => true)
+      & ((value: any) => boolean);
+    isEqual(value: any, other: any): boolean;
+    isEqualWith<T, U>(
+      value?: ?T,
+      other?: ?U,
+      customizer?: ?(
+        objValue: any,
+        otherValue: any,
+        key: number | string,
+        object: T,
+        other: U,
+        stack: any
+      ) => boolean | void
+    ): boolean;
+    isError:
+      & ((value: Error) => true)
+      & ((value: any) => false);
+    isFinite:
+      & ((value: number) => boolean)
+      & ((value: any) => false);
+    isFunction(value: any): boolean;
+    isInteger:
+      & ((value: number) => boolean)
+      & ((value: any) => false);
+    isLength:
+      & ((value: void | null) => false)
+      & ((value: any) => boolean);
+    isMap:
+      & ((value: Map<any, any>) => true)
+      & ((value: any) => false);
+    isMatch(object?: ?Object, source?: ?Object): boolean;
+    isMatchWith<T: Object, U: Object>(
+      object?: ?T,
+      source?: ?U,
+      customizer?: ?(
+        objValue: any,
+        srcValue: any,
+        key: number | string,
+        object: T,
+        source: U
+      ) => boolean | void
+    ): boolean;
+    isNaN:
+      & ((value: number) => boolean)
+      & ((value: any) => false);
+    isNative:
+      & ((value: number | string | void | null | Object) => false)
+      & ((value: any) => boolean);
+    isNil:
+      & ((value: void | null) => true)
+      & ((value: any) => false);
+    isNull:
+      & ((value: null) => true)
+      & ((value: any) => false);
+    isNumber:
+      & ((value: number) => true)
+      & ((value: any) => false);
+    isObject: (value: any) => boolean;
+    isObjectLike:
+      & ((value: void | null) => false)
+      & ((value: any) => boolean);
+    isPlainObject: (value: any) => boolean;
+    isRegExp:
+      & ((value: RegExp) => true)
+      & ((value: any) => false);
+    isSafeInteger:
+      & ((value: number) => boolean)
+      & ((value: any) => false);
+    isSet:
+      & ((value: Set<any>) => true)
+      & ((value: any) => false);
+    isString:
+      & ((value: string) => true)
+      & ((value: any) => false);
+    isSymbol:
+      & ((value: Symbol) => true)
+      & ((value: any) => false);
+    isTypedArray:
+      & ((value: $TypedArray) => true)
+      & ((value: any) => false);
+    isUndefined:
+      & ((value: void) => true)
+      & ((value: any) => false);
+    isWeakMap:
+      & ((value: WeakMap<any, any>) => true)
+      & ((value: any) => false);
+    isWeakSet:
+      & ((value: WeakSet<any>) => true)
+      & ((value: any) => false);
+    lt(value: any, other: any): boolean;
+    lte(value: any, other: any): boolean;
+    toArray(value: any): Array<any>;
+    toFinite:
+      & ((value: void | null) => 0)
+      & ((value: any) => number);
+    toInteger:
+      & ((value: void | null) => 0)
+      & ((value: any) => number);
+    toLength:
+      & ((value: void | null) => 0)
+      & ((value: any) => number);
+    toNumber:
+      & ((value: void | null) => 0)
+      & ((value: any) => number);
+    toPlainObject(value: any): Object;
+    toSafeInteger:
+      & ((value: void | null) => 0)
+      & ((value: any) => number);
+    toString:
+      & ((value: void | null) => "")
+      & ((value: any) => string);
+
+    // Math
+    add(augend: number, addend: number): number;
+    ceil(number: number, precision?: number): number;
+    divide(dividend: number, divisor: number): number;
+    floor(number: number, precision?: number): number;
+    max<T>(array: ?$ReadOnlyArray<T>): T;
+    maxBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
+    mean(array: $ReadOnlyArray<any>): number;
+    meanBy<T>(array: $ReadOnlyArray<T>, iteratee?: Iteratee<T>): number;
+    min<T>(array: ?$ReadOnlyArray<T>): T;
+    minBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
+    multiply(multiplier: number, multiplicand: number): number;
+    round(number: number, precision?: number): number;
+    subtract(minuend: number, subtrahend: number): number;
+    sum(array: $ReadOnlyArray<any>): number;
+    sumBy<T>(array: $ReadOnlyArray<T>, iteratee?: Iteratee<T>): number;
+
+    // number
+    clamp:
+      & ((number?: number, lower?: ?number, upper?: ?number) => number)
+      & ((number: ?number, lower?: ?number, upper?: ?number) => 0);
+    inRange(number: number, start?: number, end: number): boolean;
+    random(lower?: number, upper?: number, floating?: boolean): number;
+
+    // Object
+    assign(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
+    assignIn:
+      & (() => {...})
+      & (<A, B>(a: A, b: B) => A & B)
+      & (<A, B, C>(a: A, b: B, c: C) => A & B & C)
+      & (<A, B, C, D>(a: A, b: B, c: C, d: D) => A & B & C & D)
+      & (<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) => A & B & C & D & E);
+    assignInWith:
+      & (() => {...})
+      & (<T: Object, A: Object>(
+        object: T,
+        s1: A,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object, D: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        s4: D,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C | D
+        ) => any | void
+      ) => Object);
+    assignWith:
+      & (() => {...})
+      & (<T: Object, A: Object>(
+        object: T,
+        s1: A,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object, D: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        s4: D,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C | D
+        ) => any | void
+      ) => Object);
+    at:
+      & ((object?: ?Object, ...paths: $ReadOnlyArray<string>) => Array<any>)
+      & ((object?: ?Object, paths: $ReadOnlyArray<string>) => Array<any>);
+    create:
+      & ((prototype: void | null, properties: void | null) => {...})
+      & (<T>(prototype: T, properties: Object) => T)
+      & ((prototype: any, properties: void | null) => {...});
+    defaults(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
+    defaultsDeep(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
+    // alias for _.toPairs
+    entries(object?: ?Object): Array<[string, any]>;
+    // alias for _.toPairsIn
+    entriesIn(object?: ?Object): Array<[string, any]>;
+    // alias for _.assignIn
+    extend:
+      & (<A, B>(a?: ?A, b?: ?B) => A & B)
+      & (<A, B, C>(a: A, b: B, c: C) => A & B & C)
+      & (<A, B, C, D>(a: A, b: B, c: C, d: D) => A & B & C & D)
+      & (<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) => A & B & C & D & E);
+    // alias for _.assignInWith
+    extendWith:
+      & (<T: Object, A: Object>(
+        object?: ?T,
+        s1?: ?A,
+        customizer?: ?(
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object, D: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        s4: D,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C | D
+        ) => any | void
+      ) => Object);
+    findKey:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: ?OPredicate<A, T>
+      ) => string | void)
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: void | null,
+        predicate?: ?OPredicate<A, T>
+      ) => void);
+    findLastKey:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: T,
+        predicate?: ?OPredicate<A, T>
+      ) => string | void)
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: void | null,
+        predicate?: ?OPredicate<A, T>
+      ) => void);
+    forIn:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => null);
+    forInRight:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => null);
+    forOwn:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => null);
+    forOwnRight:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => null);
+    functions(object?: ?Object): Array<string>;
+    functionsIn(object?: ?Object): Array<string>;
+    get(
+      object?: ?Object | ?$ReadOnlyArray<any> | void | null,
+      path?: ?Path,
+      defaultValue?: any
+    ): any;
+    has:
+      & ((object: Object, path: Path) => boolean)
+      & ((object: Object, path: void | null) => false)
+      & ((object: void | null, path?: ?Path) => false);
+    hasIn:
+      & ((object: Object, path: Path) => boolean)
+      & ((object: Object, path: void | null) => false)
+      & ((object: void | null, path?: ?Path) => false);
+    invert:
+      & ((object: Object, multiVal?: ?boolean) => Object)
+      & ((object: void | null, multiVal?: ?boolean) => {...});
+    invertBy:
+      & ((object: Object, iteratee?: ?Function) => Object)
+      & ((object: void | null, iteratee?: ?Function) => {...});
+    invoke(
+      object?: ?Object,
+      path?: ?Path,
+      ...args?: $ReadOnlyArray<any>
+    ): any;
+    keys:
+      & (<K>(object?: ?ReadOnlyIndexerObject<any, K>) => Array<K>)
+      & ((object?: ?Object) => Array<string>);
+    keysIn(object?: ?Object): Array<string>;
+    mapKeys:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => {...});
+    mapValues:
+      & ((object: Object, iteratee?: ?OIteratee<any>) => Object)
+      & ((object: void | null, iteratee?: ?OIteratee<any>) => {...});
+    merge(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
+    mergeWith:
+      & (() => {...})
+      & (<T: Object, A: Object>(
+        object: T,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C
+        ) => any | void
+      ) => Object)
+      & (<T: Object, A: Object, B: Object, C: Object, D: Object>(
+        object: T,
+        s1: A,
+        s2: B,
+        s3: C,
+        s4: D,
+        customizer?: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B | C | D
+        ) => any | void
+      ) => Object);
+    omit:
+      & ((object?: ?Object, ...props: $ReadOnlyArray<string>) => Object)
+      & ((object?: ?Object, props: $ReadOnlyArray<string>) => Object);
+    omitBy:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: $ReadOnly<T>,
+        predicate?: ?OPredicate<A, T>
+      ) => Object)
+      & (<A, T>(object: void | null, predicate?: ?OPredicate<A, T>) => {...});
+    pick:
+      & ((object?: ?Object, ...props: $ReadOnlyArray<string>) => Object)
+      & ((object?: ?Object, props: $ReadOnlyArray<string>) => Object);
+    pickBy:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        object: $ReadOnly<T>,
+        predicate?: ?OPredicate<A, T>
+      ) => Object)
+      & (<A, T>(object: void | null, predicate?: ?OPredicate<A, T>) => {...});
+    result(
+      object?: ?Object,
+      path?: ?Path,
+      defaultValue?: any
+    ): any;
+    set:
+      & ((object: Object, path?: ?Path, value: any) => Object)
+      & (<T: void | null>(
+        object: T,
+        path?: ?Path,
+        value?: ?any
+      ) => T);
+    setWith:
+      & (<T>(
+        object: T,
+        path?: ?Path,
+        value: any,
+        customizer?: (nsValue: any, key: string, nsObject: T) => any
+      ) => Object)
+      & (<T: void | null>(
+        object: T,
+        path?: ?Path,
+        value?: ?any,
+        customizer?: ?(nsValue: any, key: string, nsObject: T) => any
+      ) => T);
+    toPairs(object?: ?Object | $ReadOnlyArray<any>): Array<[string, any]>;
+    toPairsIn(object?: ?Object): Array<[string, any]>;
+    transform:
+      & ((
+        collection: Object | $ReadOnlyArray<any>,
+        iteratee?: ?OIteratee<any>,
+        accumulator?: any
+      ) => any)
+      & ((
+        collection: void | null,
+        iteratee?: ?OIteratee<any>,
+        accumulator?: ?any
+      ) => {...});
+    unset:
+      & ((object: void | null, path?: ?Path) => true)
+      & ((object: Object, path?: ?Path) => boolean);
+    update:
+      & ((object: Object, path: Path, updater: Function) => Object)
+      & (<T: void | null>(
+        object: T,
+        path?: ?Path,
+        updater?: ?Function
+      ) => T);
+    updateWith:
+      & ((
+        object: Object,
+        path?: ?Path,
+        updater?: ?Function,
+        customizer?: ?Function
+      ) => Object)
+      & (<T: void | null>(
+        object: T,
+        path?: ?Path,
+        updater?: ?Function,
+        customizer?: ?Function
+      ) => T);
+    values(object?: ?Object): Array<any>;
+    valuesIn(object?: ?Object): Array<any>;
+
+    // Seq
+    // harder to read, but this is _()
+    (value: any): any;
+    chain<T>(value: T): any;
+    tap<T>(value: T, interceptor: (value: T) => any): T;
+    thru<T1, T2>(value: T1, interceptor: (value: T1) => T2): T2;
+    // TODO: _.prototype.*
+
+    // String
+    camelCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    capitalize:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    deburr:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    endsWith:
+      & ((string: string, target?: string, position?: ?number) => boolean)
+      & ((string: void | null, target?: ?string, position?: ?number) => false);
+    escape:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    escapeRegExp:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    kebabCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    lowerCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    lowerFirst:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    pad(string?: ?string, length?: ?number, chars?: ?string): string;
+    padEnd(string?: ?string, length?: ?number, chars?: ?string): string;
+    padStart(string?: ?string, length?: ?number, chars?: ?string): string;
+    parseInt(string: string, radix?: ?number): number;
+    repeat:
+      & ((string: string, n?: ?number) => string)
+      & ((string: void | null, n?: ?number) => "");
+    replace:
+      & ((
+        string: string,
+        pattern: RegExp | string,
+        replacement: ((string: string) => string) | string
+      ) => string)
+      & ((
+        string: void | null,
+        pattern?: ?RegExp | ?string,
+        replacement: ?((string: string) => string) | ?string
+      ) => "");
+    snakeCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    split(
+      string?: ?string,
+      separator?: ?RegExp | ?string,
+      limit?: ?number
+    ): Array<string>;
+    startCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    startsWith:
+      & ((string: string, target?: string, position?: number) => boolean)
+      & ((
+        string: void | null,
+        target?: ?string,
+        position?: ?number
+      ) => false);
+    template(string?: ?string, options?: ?TemplateSettings): Function;
+    toLower:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    toUpper:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    trim:
+      & ((string: string, chars?: string) => string)
+      & ((string: void | null, chars?: ?string) => "");
+    trimEnd:
+      & ((string: string, chars?: ?string) => string)
+      & ((string: void | null, chars?: ?string) => "");
+    trimStart:
+      & ((string: string, chars?: ?string) => string)
+      & ((string: void | null, chars?: ?string) => "");
+    truncate:
+      & ((string: string, options?: TruncateOptions) => string)
+      & ((string: void | null, options?: ?TruncateOptions) => "");
+    unescape:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    upperCase:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    upperFirst:
+      & ((string: string) => string)
+      & ((string: void | null) => "");
+    words(string?: ?string, pattern?: ?RegExp | ?string): Array<string>;
+
+    // Util
+    attempt(func: Function, ...args: $ReadOnlyArray<any>): any;
+    bindAll:
+      & ((object: Object, methodNames?: ?$ReadOnlyArray<string>) => Object)
+      & (<T: void | null>(object: T, methodNames?: ?$ReadOnlyArray<string>) => T)
+      & ((object: Object, ...methodNames: $ReadOnlyArray<string>) => Object);
+    cond(pairs?: ?NestedArray<Function>): Function;
+    conforms(source?: ?Object): Function;
+    constant<T>(value: T): () => T;
+    defaultTo:
+      & (<T1: void | null, T2>(value: T1, defaultValue: T2) => T2)
+      & (<T1: string | boolean, T2>(
+        value: T1,
+        defaultValue: T2
+      ) => T1)
+      // NaN is a number instead of its own type, otherwise it would behave like null/void
+      & (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
+    flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
+    flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+    identity<T>(value: T): T;
+    iteratee(func?: any): Function;
+    matches(source?: ?Object): Function;
+    matchesProperty(path?: ?Path, srcValue: any): Function;
+    method(path?: ?Path, ...args?: $ReadOnlyArray<any>): Function;
+    methodOf(object?: ?Object, ...args?: $ReadOnlyArray<any>): Function;
+    mixin<T: Function | Object>(
+      object?: T,
+      source: Object,
+      options?: { chain: boolean, ... }
+    ): T;
+    noConflict(): Lodash;
+    noop(...args: $ReadOnlyArray<mixed>): void;
+    nthArg(n?: ?number): Function;
+    over:
+      & ((...iteratees: $ReadOnlyArray<Function>) => Function)
+      & ((iteratees: $ReadOnlyArray<Function>) => Function);
+    overEvery:
+      & ((...predicates: $ReadOnlyArray<Function>) => Function)
+      & ((predicates: $ReadOnlyArray<Function>) => Function);
+    overSome:
+      & ((...predicates: $ReadOnlyArray<Function>) => Function)
+      & ((predicates: $ReadOnlyArray<Function>) => Function);
+    property(path?: ?Path): Function;
+    propertyOf(object?: ?Object): Function;
+    range:
+      & ((start: number, end: number, step?: number) => Array<number>)
+      & ((end: number, step?: number) => Array<number>);
+    rangeRight:
+      & ((start?: ?number, end?: ?number, step?: ?number) => Array<number>)
+      & (end?: ?number, step?: ?number) => Array<number>;
+    runInContext(context?: ?Object): Function;
+
+    stubArray(): Array<any>;
+    stubFalse(): false;
+    stubObject(): {...};
+    stubString(): "";
+    stubTrue(): true;
+    times:
+      & ((n?: ?number, ...rest?: $ReadOnlyArray<void | null>) => Array<number>)
+      & (<T>(n: number, iteratee: (i: number) => T) => Array<T>);
+    toPath(value: any): Array<string>;
+    uniqueId(prefix?: ?string): string;
+
+    // Properties
+    VERSION: string;
+    templateSettings: TemplateSettings;
+  |}
+
+  declare module.exports: Lodash;
+}
+
+declare module "lodash/fp" {
+  declare type Path = $ReadOnlyArray<string | number> | string | number;
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
+    ...r: [AA]
+  ) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB]) => R);
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
+    ...r: [AA]
+  ) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC]) => R);
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type UnaryFn<A, R> = (a: A) => R;
+
+  declare type TemplateSettings = {
+    escape?: RegExp,
+    evaluate?: RegExp,
+    imports?: Object,
+    interpolate?: RegExp,
+    variable?: string,
+    ...
+  };
+
+  declare type TruncateOptions = {
+    length?: number,
+    omission?: string,
+    separator?: RegExp | string,
+    ...
+  };
+
+  declare type DebounceOptions = {
+    leading?: boolean,
+    maxWait?: number,
+    trailing?: boolean,
+    ...
+  };
+
+  declare type ThrottleOptions = {
+    leading?: boolean,
+    trailing?: boolean,
+    ...
+  };
+
+  declare type Key = string | number;
+  declare type ReadOnlyIndexerObject<V, K = Key> = $ReadOnly<{ [id: K]: V, ... }>
+  declare type NestedArray<V> = Array<Array<V>>;
+  declare type Collection<V, K = Key> = $ReadOnlyArray<V> | ReadOnlyIndexerObject<V, K>;
+
+  declare type matchesIterateeShorthand = { [Key]: any, ... };
+  declare type matchesPropertyIterateeShorthand = [string, any];
+  declare type propertyIterateeShorthand = string;
+
+  declare type OPredicate<A> =
+    | ((value: A) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type IterateeWithResult<V, R> =
+    | ((value: V) => R)
+    | string;
+
+  declare type OIterateeWithResult<V, R> =
+     | ReadOnlyIndexerObject<V>
+     | IterateeWithResult<V, R>;
+  declare type OIteratee<O> = OIterateeWithResult<any, any>;
+
+  declare type Predicate<T> =
+    | ((value: T) => any)
+    | matchesIterateeShorthand
+    | matchesPropertyIterateeShorthand
+    | propertyIterateeShorthand;
+
+  declare type _ValueOnlyIteratee<T> = (value: T) => mixed;
+  declare type ValueOnlyIteratee<T> = _ValueOnlyIteratee<T> | string;
+  declare type _Iteratee<T> = (item: T) => mixed;
+  declare type Iteratee<T> = _Iteratee<T> | Object | string;
+  declare type AFlatMapIteratee<T, U> =
+    | ((item: T) => Array<U>)
+    | string;
+  declare type OFlatMapIteratee<T, U> = IterateeWithResult<T, Array<U>>;
+  declare type Comparator<T> = (item: T, item2: T) => boolean;
+
+  declare type MapIterator<T, U> = ((item: T) => U) | propertyIterateeShorthand;
+
+  declare type OMapIterator<T, U> =
+    | ((item: T) => U)
+    | propertyIterateeShorthand;
+
+  declare type Lodash = {|
+    // Array
+    chunk:
+      & (<T>(size: number) => ((array: $ReadOnlyArray<T>) => Array<Array<T>>))
+      & (<T>(size: number, array: $ReadOnlyArray<T>) => Array<Array<T>>);
+    compact<T, N: ?T>(array?: ?$ReadOnlyArray<N>): Array<T>;
+    concat:
+      & (<T, U, A: Array<T> | T, B: Array<U> | U>(
+        base: A
+      ) => (elements: B) => Array<T | U>)
+      & (<T, U, A: Array<T> | T, B: Array<U> | U>(
+        base: A,
+        elements: B
+      ) => Array<T | U>);
+    difference:
+      & (<T>(values: $ReadOnlyArray<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    differenceBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((values: $ReadOnlyArray<T>) => (array: $ReadOnlyArray<T>) => Array<T>) &
+        ((values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        values: $ReadOnlyArray<T>
+      ) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        values: $ReadOnlyArray<T>,
+        array: $ReadOnlyArray<T>
+      ) => Array<T>);
+    differenceWith:
+      & (<T>(
+        comparator: Comparator<T>
+      ) => (((first: $ReadOnlyArray<T>) => (second: $ReadOnlyArray<T>) => Array<T>) &
+        ((first: $ReadOnlyArray<T>, second: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        comparator: Comparator<T>,
+        first: $ReadOnlyArray<T>
+      ) => ((second: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        comparator: Comparator<T>,
+        first: $ReadOnlyArray<T>,
+        second: $ReadOnlyArray<T>
+      ) => Array<T>);
+    drop:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    dropLast:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    dropRight:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    dropRightWhile:
+      & (<T>(predicate: Predicate<T>) => (array: $ReadOnlyArray<T>) => Array<T>)
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    dropWhile:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    dropLastWhile:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    fill:
+      & (<T, U>(
+        start: number
+      ) => (((
+        end: number
+      ) => ((value: U) => (array: Array<T>) => Array<T | U>) &
+        ((value: U, array: Array<T>) => Array<T | U>)) &
+        ((end: number, value: U) => (array: Array<T>) => Array<T | U>) &
+        ((end: number, value: U, array: Array<T>) => Array<T | U>)))
+      & (<T, U>(
+        start: number,
+        end: number
+      ) => (((value: U) => (array: Array<T>) => Array<T | U>) &
+        ((value: U, array: Array<T>) => Array<T | U>)))
+      & (<T, U>(
+        start: number,
+        end: number,
+        value: U
+      ) => ((array: Array<T>) => Array<T | U>))
+      & (<T, U>(
+        start: number,
+        end: number,
+        value: U,
+        array: Array<T>
+      ) => Array<T | U>);
+    findIndex:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => number);
+    findIndexFrom:
+      & (<T>(
+      predicate: Predicate<T>
+    ) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
+      ((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
+    & (<T>(
+      predicate: Predicate<T>,
+      fromIndex: number
+    ) => ((array: $ReadOnlyArray<T>) => number))
+    & (<T>(
+      predicate: Predicate<T>,
+      fromIndex: number,
+      array: $ReadOnlyArray<T>
+    ) => number);
+    findLastIndex:
+      & (<T>(
+        predicate: Predicate<T>
+      ) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => number);
+    findLastIndexFrom:
+      & (<T>(
+        predicate: Predicate<T>
+      ) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
+        ((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
+      & (<T>(
+        predicate: Predicate<T>,
+        fromIndex: number
+      ) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(
+        predicate: Predicate<T>,
+        fromIndex: number,
+        array: $ReadOnlyArray<T>
+      ) => number);
+    // alias of _.head
+    first<T>(array: $ReadOnlyArray<T>): T;
+    flatten<T, X>(array: $ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
+    unnest<T, X>(array: $ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
+    flattenDeep<T>(array: $ReadOnlyArray<any>): Array<T>;
+    flattenDepth:
+      & ((depth: number) => ((array: $ReadOnlyArray<any>) => Array<any>))
+      & ((depth: number, array: $ReadOnlyArray<any>) => Array<any>);
+    fromPairs<A, B>(pairs: $ReadOnlyArray<[A, B]>): {| [key: A]: B |};
+    head<T>(array: $ReadOnlyArray<T>): T;
+    indexOf:
+      & (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    indexOfFrom:
+      & (<T>(
+      value: T
+    ) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
+      ((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
+    & (<T>(value: T, fromIndex: number) => ((array: $ReadOnlyArray<T>) => number))
+    & (<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>) => number);
+    initial<T>(array: $ReadOnlyArray<T>): Array<T>;
+    init<T>(array: $ReadOnlyArray<T>): Array<T>;
+    intersection:
+      & (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
+    intersectionBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    intersectionWith:
+      & (<T>(
+        comparator: Comparator<T>
+      ) => ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    join:
+      & (<T>(separator: string) => ((array: $ReadOnlyArray<T>) => string))
+      & (<T>(separator: string, array: $ReadOnlyArray<T>) => string);
+    last<T>(array: $ReadOnlyArray<T>): T;
+    lastIndexOf:
+      & (<T>(value: T) => (array: $ReadOnlyArray<T>) => number)
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    lastIndexOfFrom:
+      & (<T>(
+        value: T
+      ) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
+        ((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
+      & (<T>(
+        value: T,
+        fromIndex: number
+      ) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>) => number);
+    nth:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => T))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => T);
+    pull:
+      & (<T>(value: T) => ((array: Array<T>) => Array<T>))
+      & (<T>(value: T, array: Array<T>) => Array<T>);
+    pullAll:
+      & (<T>(values: $ReadOnlyArray<T>) => ((array: Array<T>) => Array<T>))
+      & (<T>(values: $ReadOnlyArray<T>, array: Array<T>) => Array<T>);
+    pullAllBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((values: $ReadOnlyArray<T>) => (array: Array<T>) => Array<T>) &
+        ((values: $ReadOnlyArray<T>, array: Array<T>) => Array<T>)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        values: $ReadOnlyArray<T>
+      ) => ((array: Array<T>) => Array<T>))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        values: $ReadOnlyArray<T>,
+        array: Array<T>
+      ) => Array<T>);
+    pullAllWith:
+      & (<T>(
+        comparator: Function
+      ) => (((values: Array<T>) => (array: Array<T>) => Array<T>) &
+        ((values: Array<T>, array: Array<T>) => Array<T>)))
+      & (<T>(comparator: Function, values: Array<T>) => ((array: Array<T>) => Array<T>))
+      & (<T>(comparator: Function, values: Array<T>, array: Array<T>) => Array<T>);
+    pullAt:
+      & (<T>(indexed: Array<number>) => ((array: Array<T>) => Array<T>))
+      & (<T>(indexed: Array<number>, array: Array<T>) => Array<T>);
+    remove:
+      & (<T>(predicate: Predicate<T>) => ((array: Array<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: Array<T>) => Array<T>);
+    reverse<T>(array: Array<T>): Array<T>;
+    slice:
+      & (<T>(
+        start: number
+      ) => (((end: number) => (array: $ReadOnlyArray<T>) => Array<T>) &
+        ((end: number, array: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(start: number, end: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(start: number, end: number, array: $ReadOnlyArray<T>) => Array<T>);
+    sortedIndex:
+      & (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    sortedIndexBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((value: T) => (array: $ReadOnlyArray<T>) => number) &
+        ((value: T, array: $ReadOnlyArray<T>) => number)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        value: T
+      ) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        value: T,
+        array: $ReadOnlyArray<T>
+      ) => number);
+    sortedIndexOf:
+      & (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    sortedLastIndex:
+      & (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    sortedLastIndexBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((value: T) => (array: $ReadOnlyArray<T>) => number) &
+        ((value: T, array: $ReadOnlyArray<T>) => number)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        value: T
+      ) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        value: T,
+        array: $ReadOnlyArray<T>
+      ) => number);
+    sortedLastIndexOf:
+      & (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
+      & (<T>(value: T, array: $ReadOnlyArray<T>) => number);
+    sortedUniq<T>(array: $ReadOnlyArray<T>): Array<T>;
+    sortedUniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>): Array<T>;
+    tail<T>(array: $ReadOnlyArray<T>): Array<T>;
+    take:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    takeRight:
+      & (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    takeLast:
+      & (<T>(n: number) => (array: $ReadOnlyArray<T>) => Array<T>)
+      & (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
+    takeRightWhile:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    takeLastWhile:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    takeWhile:
+      & (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    union:
+      & (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
+    unionBy:
+      & (<T>(
+      iteratee: ValueOnlyIteratee<T>
+    ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+      ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+    & (<T>(
+      iteratee: ValueOnlyIteratee<T>,
+      a1: $ReadOnlyArray<T>
+    ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+    & (<T>(
+      iteratee: ValueOnlyIteratee<T>,
+      a1: $ReadOnlyArray<T>,
+      a2: $ReadOnlyArray<T>
+    ) => Array<T>);
+    unionWith:
+      & (<T>(
+        comparator: Comparator<T>
+      ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    uniq<T>(array: $ReadOnlyArray<T>): Array<T>;
+    uniqBy:
+      & (<T>(iteratee: ValueOnlyIteratee<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    uniqWith:
+      & (<T>(comparator: Comparator<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(comparator: Comparator<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    unzip<T>(array: $ReadOnlyArray<T>): Array<T>;
+    unzipWith:
+      & (<T>(iteratee: Iteratee<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    without:
+      & (<T>(values: $ReadOnlyArray<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>);
+    xor:
+      & (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
+    symmetricDifference:
+      & (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
+    xorBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    symmetricDifferenceBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>
+      ) => (a2: $ReadOnlyArray<T>) => Array<T>)
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    xorWith:
+      & (<T>(
+        comparator: Comparator<T>
+      ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(comparator: Comparator<T>, a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
+    symmetricDifferenceWith:
+      & (<T>(
+        comparator: Comparator<T>
+      ) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
+        ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>
+      ) => ((a2: $ReadOnlyArray<T>) => Array<T>))
+      & (<T>(
+        comparator: Comparator<T>,
+        a1: $ReadOnlyArray<T>,
+        a2: $ReadOnlyArray<T>
+      ) => Array<T>);
+    zip:
+      & (<A, B>(a1: $ReadOnlyArray<A>) => ((a2: $ReadOnlyArray<B>) => Array<[A, B]>))
+      & (<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>) => Array<[A, B]>);
+    zipAll(arrays: $ReadOnlyArray<$ReadOnlyArray<any>>): Array<any>;
+    zipObject:
+      & (<K, V>(props?: $ReadOnlyArray<K>) => ((values?: $ReadOnlyArray<V>) => { [key: K]: V, ... }))
+      & (<K, V>(props?: $ReadOnlyArray<K>, values?: $ReadOnlyArray<V>) => { [key: K]: V, ... });
+    zipObj:
+      & ((props: $ReadOnlyArray<any>) => ((values: $ReadOnlyArray<any>) => Object))
+      & ((props: $ReadOnlyArray<any>, values: $ReadOnlyArray<any>) => Object);
+    zipObjectDeep:
+      & ((props: $ReadOnlyArray<any>) => ((values: any) => Object))
+      & ((props: $ReadOnlyArray<any>, values: any) => Object);
+    zipWith:
+      & (<T>(
+        iteratee: Iteratee<T>
+      ) => (((a1: NestedArray<T>) => (a2: NestedArray<T>) => Array<T>) &
+        ((a1: NestedArray<T>, a2: NestedArray<T>) => Array<T>)))
+      & (<T>(
+        iteratee: Iteratee<T>,
+        a1: NestedArray<T>
+      ) => ((a2: NestedArray<T>) => Array<T>))
+      & (<T>(
+        iteratee: Iteratee<T>,
+        a1: NestedArray<T>,
+        a2: NestedArray<T>
+      ) => Array<T>);
+
+    // Collection
+    countBy:
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => ((collection: Collection<T>) => { [string]: number, ... }))
+      & (<T>(
+        iteratee: ValueOnlyIteratee<T>,
+        collection: Collection<T>
+      ) => { [string]: number, ... });
+    // alias of _.forEach
+    each:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    // alias of _.forEachRight
+    eachRight:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    every:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => boolean))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => boolean);
+    all:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => boolean))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => boolean);
+    filter:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    find:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => T | void))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => (T | void));
+    findFrom:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => (((
+        fromIndex: number
+      ) => (collection: Collection<T>) => T | void) &
+        ((
+          fromIndex: number,
+          collection: Collection<T>
+        ) => T | void)))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        fromIndex: number
+      ) => ((collection: Collection<T>) => T | void))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        fromIndex: number,
+        collection: Collection<T>
+      ) => (T | void));
+    findLast:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => T | void))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => (T | void));
+    findLastFrom:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => (((
+        fromIndex: number
+      ) => (collection: Collection<T>) => T | void) &
+        ((
+          fromIndex: number,
+          collection: Collection<T>
+        ) => T | void)))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        fromIndex: number
+      ) => ((collection: Collection<T>) => T | void))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        fromIndex: number,
+        collection: Collection<T>
+      ) => T | void);
+    flatMap:
+      & (<T, U>(
+        iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
+      ) => ((collection: Collection<T>) => Array<U>))
+      & (<T, U>(
+        iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
+        collection: Collection<T>
+      ) => Array<U>);
+    flatMapDeep:
+      & (<T, U>(
+        iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
+      ) => ((collection: Collection<T>) => Array<U>))
+      & (<T, U>(
+        iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
+        collection: Collection<T>
+      ) => Array<U>);
+    flatMapDepth:
+      & (<T, U>(
+      iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
+    ) => (((
+      depth: number
+    ) => (collection: Collection<T>) => Array<U>) &
+      ((depth: number, collection: Collection<T>) => Array<U>)))
+    & (<T, U>(
+      iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
+      depth: number
+    ) => ((collection: Collection<T>) => Array<U>))
+    & (<T, U>(
+      iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
+      depth: number,
+      collection: Collection<T>
+    ) => Array<U>);
+    forEach:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    forEachRight:
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        iteratee: Iteratee<T> | OIteratee<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    groupBy:
+      & (<V, T>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => ((
+        collection: Collection<T>
+      ) => { [key: V]: Array<T>, ... }))
+      & (<V, T>(
+        iteratee: ValueOnlyIteratee<T>,
+        collection: Collection<T>
+      ) => { [key: V]: Array<T>, ... });
+    includes:
+      & (<T>(value: T) => ((collection: Collection<T>) => boolean))
+      & (<T>(value: T, collection: Collection<T>) => boolean)
+      & ((value: string) => ((str: string) => boolean))
+      & ((value: string, str: string) => boolean);
+    contains:
+      & ((value: string) => ((str: string) => boolean))
+      & ((value: string, str: string) => boolean)
+      & (<T>(value: T) => ((collection: Collection<T>) => boolean))
+      & (<T>(value: T, collection: Collection<T>) => boolean);
+    includesFrom:
+      & ((
+        value: string
+      ) => (((fromIndex: number) => (str: string) => boolean) &
+        ((fromIndex: number, str: string) => boolean)))
+      & ((value: string, fromIndex: number) => ((str: string) => boolean))
+      & ((value: string, fromIndex: number, str: string) => boolean)
+      & (<T>(
+        value: T
+      ) => (((fromIndex: number) => (collection: $ReadOnlyArray<T>) => boolean) &
+        ((fromIndex: number, collection: $ReadOnlyArray<T>) => boolean)))
+      & (<T>(
+        value: T,
+        fromIndex: number
+      ) => ((collection: $ReadOnlyArray<T>) => boolean))
+      & (<T>(value: T, fromIndex: number, collection: $ReadOnlyArray<T>) => boolean);
+    invokeMap:
+      & (<T>(
+        path: ((value: T) => Path) | Path
+      ) => ((collection: Collection<T>) => Array<any>))
+      & (<T>(
+        path: ((value: T) => Path) | Path,
+        collection: Collection<T>
+      ) => Array<any>);
+    invokeArgsMap:
+      & (<T>(
+        path: ((value: T) => Path) | Path
+      ) => (((
+        collection: Collection<T>
+      ) => (args: $ReadOnlyArray<any>) => Array<any>) &
+        ((
+          collection: Collection<T>,
+          args: $ReadOnlyArray<any>
+        ) => Array<any>)))
+      & (<T>(
+        path: ((value: T) => Path) | Path,
+        collection: Collection<T>
+      ) => ((args: $ReadOnlyArray<any>) => Array<any>))
+      & (<T>(
+        path: ((value: T) => Path) | Path,
+        collection: Collection<T>,
+        args: $ReadOnlyArray<any>
+      ) => Array<any>);
+    keyBy:
+      & (<T, V>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => ((collection: Collection<T>) => { [key: V]: T, ... }))
+      & (<T, V>(
+        iteratee: ValueOnlyIteratee<T>,
+        collection: Collection<T>
+      ) => { [key: V]: T, ... });
+    indexBy:
+      & (<T, V>(
+        iteratee: ValueOnlyIteratee<T>
+      ) => ((collection: Collection<T>) => { [key: V]: T, ... }))
+      & (<T, V>(
+        iteratee: ValueOnlyIteratee<T>,
+        collection: Collection<T>
+      ) => { [key: V]: T, ... });
+    map:
+      & (<T, U>(
+        iteratee: MapIterator<T, U> | OMapIterator<T, U>
+      ) => ((collection: Collection<T>) => Array<U>))
+      & (<T, U>(
+        iteratee: MapIterator<T, U> | OMapIterator<T, U>,
+        collection: Collection<T>
+      ) => Array<U>)
+      & ((iteratee: (char: string) => any) => ((str: string) => string))
+      & ((iteratee: (char: string) => any, str: string) => string);
+    pluck:
+      & (<T, U>(
+        iteratee: MapIterator<T, U> | OMapIterator<T, U>
+      ) => ((collection: Collection<T>) => Array<U>))
+      & (<T, U>(
+        iteratee: MapIterator<T, U> | OMapIterator<T, U>,
+        collection: Collection<T>
+      ) => Array<U>)
+      & ((iteratee: (char: string) => any) => ((str: string) => string))
+      & ((iteratee: (char: string) => any, str: string) => string);
+    orderBy:
+      & (<T>(
+        iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<any>> | string
+      ) => (((
+        orders: $ReadOnlyArray<"asc" | "desc"> | string
+      ) => (collection: Collection<T>) => Array<T>) &
+        ((
+          orders: $ReadOnlyArray<"asc" | "desc"> | string,
+          collection: Collection<T>
+        ) => Array<T>)))
+      & (<T>(
+        iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<any>> | string,
+        orders: $ReadOnlyArray<"asc" | "desc"> | string
+      ) => ((collection: Collection<T>) => Array<T>))
+      & <T>(
+        iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<any>> | string,
+        orders: $ReadOnlyArray<"asc" | "desc"> | string,
+        collection: Collection<T>
+      ) => Array<T>;
+    partition:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => [Array<T>, Array<T>]))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => [Array<T>, Array<T>]);
+    reduce:
+      & (<T, U>(
+        iteratee: (accumulator: U, value: T) => U
+      ) => (((accumulator: U) => (collection: Collection<T>) => U) &
+        ((accumulator: U, collection: Collection<T>) => U)))
+      & (<T, U>(
+        iteratee: (accumulator: U, value: T) => U,
+        accumulator: U
+      ) => ((collection: Collection<T>) => U))
+      & (<T, U>(
+        iteratee: (accumulator: U, value: T) => U,
+        accumulator: U,
+        collection: Collection<T>
+      ) => U);
+    reduceRight:
+      & (<T, U>(
+        iteratee: (value: T, accumulator: U) => U
+      ) => ((accumulator: U) => (collection: Collection<T>) => U) &
+         ((accumulator: U, collection: Collection<T>) => U))
+      & (<T, U>(
+        iteratee: (value: T, accumulator: U) => U,
+        accumulator: U
+      ) => (collection: Collection<T>) => U)
+      & (<T, U>(
+        iteratee: (value: T, accumulator: U) => U,
+        accumulator: U,
+        collection: Collection<T>
+      ) => U);
+    reject:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+    sample<T>(collection: Collection<T>): T;
+    sampleSize:
+      & (<T>(
+        n: number
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(n: number, collection: Collection<T>) => Array<T>);
+    shuffle<T>(collection: Collection<T>): Array<T>;
+    size(collection: $ReadOnlyArray<any> | Object | string): number;
+    some:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => (collection: Collection<T>) => boolean)
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => boolean);
+    any:
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>
+      ) => ((collection: Collection<T>) => boolean))
+      & (<T>(
+        predicate: Predicate<T> | OPredicate<T>,
+        collection: Collection<T>
+      ) => boolean);
+    sortBy:
+      & (<T>(
+        iteratees:
+          | $ReadOnlyArray<Iteratee<T> | OIteratee<T>>
+          | Iteratee<T>
+          | OIteratee<T>
+      ) => ((collection: Collection<T>) => Array<T>))
+      & (<T>(
+        iteratees:
+          | $ReadOnlyArray<Iteratee<T> | OIteratee<T>>
+          | Iteratee<T>
+          | OIteratee<T>,
+        collection: Collection<T>
+      ) => Array<T>);
+
+    // Date
+    now(): number;
+
+    // Function
+    after:
+      & ((fn: Function) => ((n: number) => Function))
+      & ((fn: Function, n: number) => Function);
+    ary(func: Function): Function;
+    nAry:
+      & ((n: number) => ((func: Function) => Function))
+      & ((n: number, func: Function) => Function);
+    before:
+      & ((fn: Function) => ((n: number) => Function))
+      & ((fn: Function, n: number) => Function);
+    bind:
+      & ((func: Function) => ((thisArg: any) => Function))
+      & ((func: Function, thisArg: any) => Function);
+    bindKey:
+      & ((obj: Object) => (key: string) => Function)
+      & ((obj: Object, key: string) => Function);
+    curry: Curry;
+    curryN:
+      & ((arity: number) => ((func: Function) => Function))
+      & ((arity: number, func: Function) => Function);
+    curryRight(func: Function): Function;
+    curryRightN:
+      & ((arity: number) => ((func: Function) => Function))
+      & ((arity: number, func: Function) => Function);
+    debounce:
+      & ((wait: number) => (<A, R>(func: (...A) => R) => (...A) => R))
+      & (<A, R>(wait: number, func: (...A) => R) => ((...A) => R));
+    defer(func: (...$ReadOnlyArray<any>) => any): TimeoutID;
+    delay:
+      & ((wait: number) => ((func: Function) => TimeoutID))
+      & ((wait: number, func: Function) => TimeoutID);
+    flip(func: Function): Function;
+    memoize<F: Function>(func: F): F;
+    negate<A, R>(predicate: (...A) => R): (...A) => boolean;
+    complement(predicate: Function): Function;
+    once(func: Function): Function;
+    overArgs:
+      & ((func: Function) => ((transforms: $ReadOnlyArray<Function>) => Function))
+      & ((func: Function, transforms: $ReadOnlyArray<Function>) => Function);
+    useWith:
+      & ((func: Function) => ((transforms: $ReadOnlyArray<Function>) => Function))
+      & ((func: Function, transforms: $ReadOnlyArray<Function>) => Function);
+    partial:
+      & ((func: Function) => ((partials: $ReadOnlyArray<any>) => Function))
+      & ((func: Function, partials: $ReadOnlyArray<any>) => Function);
+    partialRight:
+      & ((func: Function) => (partials: $ReadOnlyArray<any>) => Function)
+      & ((func: Function, partials: $ReadOnlyArray<any>) => Function);
+    rearg:
+      & ((indexes: $ReadOnlyArray<number>) => ((func: Function) => Function))
+      & ((indexes: $ReadOnlyArray<number>, func: Function) => Function);
+    rest(func: Function): Function;
+    unapply(func: Function): Function;
+    restFrom:
+      & ((start: number) => ((func: Function) => Function))
+      & ((start: number, func: Function) => Function);
+    spread(func: Function): Function;
+    apply(func: Function): Function;
+    spreadFrom:
+      & ((start: number) => ((func: Function) => Function))
+      & ((start: number, func: Function) => Function);
+    throttle:
+      & (<A, R>(wait: number) => ((func: (...A) => R) => (...A) => R))
+      & (<A, R>(wait: number, func: (...A) => R) => ((...A) => R));
+    unary<T, R>(func: (T, ...$ReadOnlyArray<any>) => R): (T) => R;
+    wrap:
+      & ((wrapper: Function) => ((value: any) => Function))
+      & ((wrapper: Function, value: any) => Function);
+
+    // Lang
+    castArray:
+      & (() => Array<any>)
+      & (<T: void | null | number | string | {...}>(value: T) => Array<T>)
+      & (<T: Array<any>>(value: T) => T);
+    clone<T>(value: T): T;
+    cloneDeep<T>(value: T): T;
+    cloneDeepWith:
+      & (<T, U>(
+        customizer: (value: T, key: number | string, object: T, stack: any) => U
+      ) => ((value: T) => U))
+      & (<T, U>(
+        customizer: (value: T, key: number | string, object: T, stack: any) => U,
+        value: T
+      ) => U);
+    cloneWith:
+      & (<T, U>(
+        customizer: (value: T, key: number | string, object: T, stack: any) => U
+      ) => ((value: T) => U))
+      & (<T, U>(
+        customizer: (value: T, key: number | string, object: T, stack: any) => U,
+        value: T
+      ) => U);
+    conformsTo:
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
+      ) => ((source: T) => boolean))
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
+        source: T
+      ) => boolean);
+    where:
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
+      ) => ((source: T) => boolean))
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
+        source: T
+      ) => boolean);
+    conforms:
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
+      ) => ((source: T) => boolean))
+      & (<T: ReadOnlyIndexerObject<mixed>>(
+        predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
+        source: T
+      ) => boolean);
+    eq:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    identical:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    gt:
+      & ((value: any) => (other: any) => boolean)
+      & ((value: any, other: any) => boolean);
+    gte:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    isArguments(value: any): boolean;
+    isArray(value: any): boolean;
+    isArrayBuffer(value: any): boolean;
+    isArrayLike(value: any): boolean;
+    isArrayLikeObject(value: any): boolean;
+    isBoolean(value: any): boolean;
+    isBuffer(value: any): boolean;
+    isDate(value: any): boolean;
+    isElement(value: any): boolean;
+    isEmpty(value: any): boolean;
+    isEqual:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    equals:
+      & ((value: any) => (other: any) => boolean)
+      & ((value: any, other: any) => boolean);
+    isEqualWith:
+      & (<T, U>(
+        customizer: (
+          objValue: any,
+          otherValue: any,
+          key: number | string,
+          object: T,
+          other: U,
+          stack: any
+        ) => boolean | void
+      ) => (((value: T) => (other: U) => boolean) &
+        ((value: T, other: U) => boolean)))
+      & (<T, U>(
+        customizer: (
+          objValue: any,
+          otherValue: any,
+          key: number | string,
+          object: T,
+          other: U,
+          stack: any
+        ) => boolean | void,
+        value: T
+      ) => ((other: U) => boolean))
+      & (<T, U>(
+        customizer: (
+          objValue: any,
+          otherValue: any,
+          key: number | string,
+          object: T,
+          other: U,
+          stack: any
+        ) => boolean | void,
+        value: T,
+        other: U
+      ) => boolean);
+    isError(value: any): boolean;
+    isFinite(value: any): boolean;
+    isFunction(value: any): boolean;
+    isInteger(value: any): boolean;
+    isLength(value: any): boolean;
+    isMap(value: any): boolean;
+    isMatch:
+      & ((source: Object) => (object: Object) => boolean)
+      & ((source: Object, object: Object) => boolean);
+    whereEq:
+      & ((source: Object) => (object: Object) => boolean)
+      & ((source: Object, object: Object) => boolean);
+    isMatchWith:
+      & (<T: Object, U: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: number | string,
+          object: T,
+          source: U
+        ) => boolean | void
+      ) => (((source: U) => (object: T) => boolean) &
+        ((source: U, object: T) => boolean)))
+      & (<T: Object, U: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: number | string,
+          object: T,
+          source: U
+        ) => boolean | void,
+        source: U
+      ) => ((object: T) => boolean))
+      & (<T: Object, U: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: number | string,
+          object: T,
+          source: U
+        ) => boolean | void,
+        source: U,
+        object: T
+      ) => boolean);
+    isNaN(value: any): boolean;
+    isNative(value: any): boolean;
+    isNil(value: any): boolean;
+    isNull(value: any): boolean;
+    isNumber(value: any): boolean;
+    isObject(value: any): boolean;
+    isObjectLike(value: any): boolean;
+    isPlainObject(value: any): boolean;
+    isRegExp(value: any): boolean;
+    isSafeInteger(value: any): boolean;
+    isSet(value: any): boolean;
+    isString:
+      & ((value: string) => true)
+      & ((value: any) => false);
+    isSymbol(value: any): boolean;
+    isTypedArray(value: any): boolean;
+    isUndefined(value: any): boolean;
+    isWeakMap(value: any): boolean;
+    isWeakSet(value: any): boolean;
+    lt:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    lte:
+      & ((value: any) => ((other: any) => boolean))
+      & ((value: any, other: any) => boolean);
+    toArray(value: any): Array<any>;
+    toFinite(value: any): number;
+    toInteger(value: any): number;
+    toLength(value: any): number;
+    toNumber(value: any): number;
+    toPlainObject(value: any): Object;
+    toSafeInteger(value: any): number;
+    toString(value: any): string;
+
+    // Math
+    add(augend: number): (addend: number) => number;
+    add(augend: number, addend: number): number;
+    ceil(number: number): number;
+    divide(dividend: number): (divisor: number) => number;
+    divide(dividend: number, divisor: number): number;
+    floor(number: number): number;
+    max<T>(array: $ReadOnlyArray<T>): T;
+    maxBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => T;
+    maxBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): T;
+    mean(array: $ReadOnlyArray<any>): number;
+    meanBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => number;
+    meanBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): number;
+    min<T>(array: $ReadOnlyArray<T>): T;
+    minBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => T;
+    minBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): T;
+    multiply(multiplier: number): (multiplicand: number) => number;
+    multiply(multiplier: number, multiplicand: number): number;
+    round(number: number): number;
+    subtract(minuend: number): (subtrahend: number) => number;
+    subtract(minuend: number, subtrahend: number): number;
+    sum(array: $ReadOnlyArray<any>): number;
+    sumBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => number;
+    sumBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): number;
+
+    // number
+    clamp:
+      & ((
+        lower: number
+      ) => (((upper: number) => (number: number) => number) &
+        ((upper: number, number: number) => number)))
+      & ((lower: number, upper: number) => ((number: number) => number))
+      & ((lower: number, upper: number, number: number) => number);
+    inRange:
+      & ((
+        start: number
+      ) => (((end: number) => (number: number) => boolean) &
+        ((end: number, number: number) => boolean)))
+      & ((start: number, end: number) => ((number: number) => boolean))
+      & ((start: number, end: number, number: number) => boolean);
+    random:
+      & ((lower: number) => ((upper: number) => number))
+      & ((lower: number, upper: number) => number);
+
+    // Object
+    assign:
+      & ((object: Object) => ((source: Object) => Object))
+      & ((object: Object, source: Object) => Object);
+    assignAll(objects: Array<Object>): Object;
+    assignInAll(objects: Array<Object>): Object;
+    extendAll(objects: Array<Object>): Object;
+    assignIn:
+      & (<A, B>(a: A) => ((b: B) => A & B))
+      & (<A, B>(a: A, b: B) => A & B);
+    assignInWith:
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T
+      ) => ((s1: A) => Object))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T,
+        s1: A
+      ) => Object);
+    assignWith:
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T
+      ) => ((s1: A) => Object))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T,
+        s1: A
+      ) => Object);
+    assignInAllWith:
+      & ((
+      customizer: (
+        objValue: any,
+        srcValue: any,
+        key: string,
+        object: Object,
+        source: Object
+      ) => any | void
+    ) => ((objects: Array<Object>) => Object))
+    & ((
+      customizer: (
+        objValue: any,
+        srcValue: any,
+        key: string,
+        object: Object,
+        source: Object
+      ) => any | void,
+      objects: Array<Object>
+    ) => Object);
+    extendAllWith:
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void
+      ) => ((objects: Array<Object>) => Object))
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void,
+        objects: Array<Object>
+      ) => Object);
+    assignAllWith:
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void
+      ) => ((objects: Array<Object>) => Object))
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void,
+        objects: Array<Object>
+      ) => Object);
+    at:
+      & ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
+      & ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
+    props:
+      & ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
+      & ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
+    paths:
+      & ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
+      & ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
+    create<T>(prototype: T): T;
+    defaults:
+      & ((source: Object) => ((object: Object) => Object))
+      & ((source: Object, object: Object) => Object);
+    defaultsAll(objects: Array<Object>): Object;
+    defaultsDeep:
+      & ((source: Object) => ((object: Object) => Object))
+      & ((source: Object, object: Object) => Object);
+    defaultsDeepAll(objects: Array<Object>): Object;
+    // alias for _.toPairs
+    entries(object: Object): Array<[string, any]>;
+    // alias for _.toPairsIn
+    entriesIn(object: Object): Array<[string, any]>;
+    // alias for _.assignIn
+    extend:
+      & (<A, B>(a: A) => ((b: B) => A & B))
+      & (<A, B>(a: A, b: B) => A & B);
+    // alias for _.assignInWith
+    extendWith:
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void
+      ) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T
+      ) => ((s1: A) => Object))
+      & (<T: Object, A: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A
+        ) => any | void,
+        object: T,
+        s1: A
+      ) => Object);
+    findKey:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>
+      ) => ((object: T) => string | void))
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>,
+        object: T
+      ) => string | void);
+    findLastKey:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>
+      ) => ((object: T) => string | void))
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>,
+        object: T
+      ) => string | void);
+    forIn:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    forInRight:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    forOwn:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    forOwnRight:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    functions(object: Object): Array<string>;
+    functionsIn(object: Object): Array<string>;
+    get:
+      & ((
+        path: Path
+      ) => ((object: Object | $ReadOnlyArray<any> | void | null) => any))
+      & ((
+        path: Path,
+        object: Object | $ReadOnlyArray<any> | void | null
+      ) => any);
+    prop:
+      & ((path: Path) => ((object: Object | $ReadOnlyArray<any>) => any))
+      & ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
+    path:
+      & ((path: Path) => ((object: Object | $ReadOnlyArray<any>) => any))
+      & ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
+    getOr:
+      & ((
+        defaultValue: any
+      ) => (((
+        path: Path
+      ) => (object: Object | $ReadOnlyArray<any>) => any) &
+        ((
+          path: Path,
+          object: Object | $ReadOnlyArray<any> | void | null
+        ) => any)))
+      & ((
+        defaultValue: any,
+        path: Path
+      ) => ((object: Object | $ReadOnlyArray<any> | void | null) => any))
+      & ((
+        defaultValue: any,
+        path: Path,
+        object: Object | $ReadOnlyArray<any> | void | null
+      ) => any);
+    propOr:
+      & ((
+        defaultValue: any
+      ) => (((
+        path: Path
+      ) => (object: Object | $ReadOnlyArray<any>) => any) &
+        ((path: Path, object: Object | $ReadOnlyArray<any>) => any)))
+      & ((
+        defaultValue: any,
+        path: Path
+      ) => ((object: Object | $ReadOnlyArray<any>) => any))
+      & ((
+        defaultValue: any,
+        path: Path,
+        object: Object | $ReadOnlyArray<any>
+      ) => any);
+    pathOr:
+      & ((
+        defaultValue: any
+      ) => (((
+        path: Path
+      ) => (object: Object | $ReadOnlyArray<any>) => any) &
+        ((path: Path, object: Object | $ReadOnlyArray<any>) => any)))
+      & ((
+        defaultValue: any,
+        path: Path
+      ) => ((object: Object | $ReadOnlyArray<any>) => any))
+      & ((
+        defaultValue: any,
+        path: Path,
+        object: Object | $ReadOnlyArray<any>
+      ) => any);
+    has:
+      & ((path: Path) => ((object: Object) => boolean))
+      & ((path: Path, object: Object) => boolean);
+    hasIn:
+      & ((path: Path) => ((object: Object) => boolean))
+      & ((path: Path, object: Object) => boolean);
+    invert(object: Object): Object;
+    invertObj(object: Object): Object;
+    invertBy:
+      & ((iteratee: Function) => ((object: Object) => Object))
+      & ((iteratee: Function, object: Object) => Object);
+    invoke:
+      & ((path: Path) => ((object: Object) => any))
+      & ((path: Path, object: Object) => any);
+    invokeArgs:
+      & ((
+        path: Path
+      ) => (((object: Object) => (args: Array<any>) => any) &
+        ((object: Object, args: Array<any>) => any)))
+      & ((
+        path: Path,
+        object: Object
+      ) => ((args: Array<any>) => any))
+      & (
+        path: Path,
+        object: Object,
+        args: Array<any>
+      ) => any;
+    keys:
+      & (<K>(object: ReadOnlyIndexerObject<any, K>) => Array<K>)
+      & ((object: Object) => Array<string>);
+    keysIn(object: Object): Array<string>;
+    mapKeys:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    mapValues:
+      & ((iteratee: OIteratee<any>) => ((object: Object) => Object))
+      & ((iteratee: OIteratee<any>, object: Object) => Object);
+    merge:
+      & ((object: Object) => ((source: Object) => Object))
+      & ((object: Object, source: Object) => Object);
+    mergeAll(objects: $ReadOnlyArray<Object>): Object;
+    mergeWith:
+      & (<T: Object, A: Object, B: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void
+      ) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
+      & (<T: Object, A: Object, B: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void,
+        object: T
+      ) => ((s1: A) => Object))
+      & (<T: Object, A: Object, B: Object>(
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: T,
+          source: A | B
+        ) => any | void,
+        object: T,
+        s1: A
+      ) => Object);
+    mergeAllWith:
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void
+      ) => ((objects: $ReadOnlyArray<Object>) => Object))
+      & ((
+        customizer: (
+          objValue: any,
+          srcValue: any,
+          key: string,
+          object: Object,
+          source: Object
+        ) => any | void,
+        objects: $ReadOnlyArray<Object>
+      ) => Object);
+    omit:
+      & ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
+      & ((props: $ReadOnlyArray<string>, object: Object) => Object);
+    omitAll:
+      & ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
+      & ((props: $ReadOnlyArray<string>, object: Object) => Object);
+    omitBy:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>
+      ) => ((object: T) => Object))
+      & (<A, T: ReadOnlyIndexerObject<A>>(predicate: OPredicate<A>, object: T) => Object);
+    pick:
+      & ((...props: $ReadOnlyArray<string | {...}>) => Object)
+      & ((props: $ReadOnlyArray<string>, object: Object) => Object)
+      & ((...props: $ReadOnlyArray<string>) => ((object: Object) => Object))
+      & ((props: $ReadOnlyArray<string>) => ((object: Object) => Object));
+    pickAll:
+      & ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
+      & ((props: $ReadOnlyArray<string>, object: Object) => Object);
+    pickBy:
+      & (<A, T: ReadOnlyIndexerObject<A>>(
+        predicate: OPredicate<A>
+      ) => ((object: T) => Object))
+      & (<A, T: ReadOnlyIndexerObject<A>>(predicate: OPredicate<A>, object: T) => Object);
+    result:
+      & ((path: Path) => ((object: Object) => any))
+      & ((path: Path, object: Object) => any);
+    set:
+      & ((
+        path: Path
+      ) => (((value: any) => (object: Object) => Object) &
+        ((value: any, object: Object) => Object)))
+      & ((path: Path, value: any) => ((object: Object) => Object))
+      & ((path: Path, value: any, object: Object) => Object);
+    assoc:
+      & ((
+        path: Path
+      ) => (((value: any) => (object: Object) => Object) &
+        ((value: any, object: Object) => Object)))
+      & ((path: Path, value: any) => ((object: Object) => Object))
+      & ((path: Path, value: any, object: Object) => Object);
+    assocPath:
+      & ((
+        path: Path
+      ) => (((value: any) => (object: Object) => Object) &
+        ((value: any, object: Object) => Object)))
+      & ((
+        path: Path,
+        value: any
+      ) => ((object: Object) => Object))
+      & ((path: Path, value: any, object: Object) => Object);
+    setWith:
+      & (<T>(
+        customizer: (nsValue: any, key: string, nsObject: T) => any
+      ) => (((
+        path: Path
+      ) => ((value: any) => (object: T) => Object) &
+        ((value: any, object: T) => Object)) &
+        ((path: Path, value: any) => (object: T) => Object) &
+        ((path: Path, value: any, object: T) => Object)))
+      & (<T>(
+        customizer: (nsValue: any, key: string, nsObject: T) => any,
+        path: Path
+      ) => (((value: any) => (object: T) => Object) &
+        ((value: any, object: T) => Object)))
+      & (<T>(
+        customizer: (nsValue: any, key: string, nsObject: T) => any,
+        path: Path,
+        value: any
+      ) => ((object: T) => Object))
+      & (<T>(
+        customizer: (nsValue: any, key: string, nsObject: T) => any,
+        path: Path,
+        value: any,
+        object: T
+      ) => Object);
+    toPairs(object: Object | $ReadOnlyArray<any>): Array<[string, any]>;
+    toPairsIn(object: Object): Array<[string, any]>;
+    transform:
+      & ((
+        iteratee: OIteratee<any>
+      ) => (((
+        accumulator: any
+      ) => (collection: Object | $ReadOnlyArray<any>) => any) &
+        ((accumulator: any, collection: Object | $ReadOnlyArray<any>) => any)))
+      & ((
+        iteratee: OIteratee<any>,
+        accumulator: any
+      ) => ((collection: Object | $ReadOnlyArray<any>) => any))
+      & ((
+        iteratee: OIteratee<any>,
+        accumulator: any,
+        collection: Object | $ReadOnlyArray<any>
+      ) => any);
+    unset:
+      & ((path: Path) => ((object: Object) => Object))
+      & ((path: Path, object: Object) => Object);
+    update:
+      & ((
+        path: Path
+      ) => (((updater: Function) => (object: Object) => Object) &
+        ((updater: Function, object: Object) => Object)))
+      & ((
+        path: Path,
+        updater: Function
+      ) => ((object: Object) => Object))
+      & ((path: Path, updater: Function, object: Object) => Object);
+    updateWith:
+      & ((
+        customizer: Function
+      ) => (((
+        path: Path
+      ) => ((updater: Function) => (object: Object) => Object) &
+        ((updater: Function, object: Object) => Object)) &
+        ((
+          path: Path,
+          updater: Function
+        ) => (object: Object) => Object) &
+        ((path: Path, updater: Function, object: Object) => Object)))
+      & ((
+        customizer: Function,
+        path: Path
+      ) => (((updater: Function) => (object: Object) => Object) &
+        ((updater: Function, object: Object) => Object)))
+      & ((
+        customizer: Function,
+        path: Path,
+        updater: Function
+      ) => ((object: Object) => Object))
+      & ((
+        customizer: Function,
+        path: Path,
+        updater: Function,
+        object: Object
+      ) => Object);
+    values(object: Object): Array<any>;
+    valuesIn(object: Object): Array<any>;
+
+    tap:
+      & (<T>(interceptor: (value: T) => any) => ((value: T) => T))
+      & (<T>(interceptor: (value: T) => any, value: T) => T);
+    thru:
+      & (<T1, T2>(interceptor: (value: T1) => T2) => ((value: T1) => T2))
+      & (<T1, T2>(interceptor: (value: T1) => T2, value: T1) => T2);
+
+    // String
+    camelCase(string: string): string;
+    capitalize(string: string): string;
+    deburr(string: string): string;
+    endsWith:
+      & ((target: string) => ((string: string) => boolean))
+      & ((target: string, string: string) => boolean);
+    escape(string: string): string;
+    escapeRegExp(string: string): string;
+    kebabCase(string: string): string;
+    lowerCase(string: string): string;
+    lowerFirst(string: string): string;
+    pad:
+      & ((length: number) => ((string: string) => string))
+      & ((length: number, string: string) => string);
+    padChars:
+      & ((
+        chars: string
+      ) => (((length: number) => (string: string) => string) &
+        ((length: number, string: string) => string)))
+      & ((chars: string, length: number) => ((string: string) => string))
+      & ((chars: string, length: number, string: string) => string);
+    padEnd:
+      & ((length: number) => ((string: string) => string))
+      & ((length: number, string: string) => string);
+    padCharsEnd:
+      & ((
+        chars: string
+      ) => (((length: number) => (string: string) => string) &
+        ((length: number, string: string) => string)))
+      & ((chars: string, length: number) => ((string: string) => string))
+      & ((chars: string, length: number, string: string) => string);
+    padStart:
+      & ((length: number) => ((string: string) => string))
+      & ((length: number, string: string) => string);
+    padCharsStart:
+      & ((
+        chars: string
+      ) => (((length: number) => (string: string) => string) &
+        ((length: number, string: string) => string)))
+      & ((chars: string, length: number) => ((string: string) => string))
+      & ((chars: string, length: number, string: string) => string);
+    parseInt:
+      & ((radix: number) => ((string: string) => number))
+      & ((radix: number, string: string) => number);
+    repeat:
+      & ((n: number) => (string: string) => string)
+      & ((n: number, string: string) => string);
+    replace:
+      & ((
+        pattern: RegExp | string
+      ) => (((
+        replacement: ((string: string) => string) | string
+      ) => (string: string) => string) &
+        ((
+          replacement: ((string: string) => string) | string,
+          string: string
+        ) => string)))
+      & ((
+        pattern: RegExp | string,
+        replacement: ((string: string) => string) | string
+      ) => ((string: string) => string))
+      & ((
+        pattern: RegExp | string,
+        replacement: ((string: string) => string) | string,
+        string: string
+      ) => string);
+    snakeCase(string: string): string;
+    split:
+      & ((separator: RegExp | string) => ((string: string) => Array<string>))
+      & ((separator: RegExp | string, string: string) => Array<string>);
+    startCase(string: string): string;
+    startsWith:
+      & ((target: string) => ((string: string) => boolean))
+      & ((target: string, string: string) => boolean);
+    template(string: string): Function;
+    toLower(string: string): string;
+    toUpper(string: string): string;
+    trim(string: string): string;
+    trimChars:
+      & ((chars: string) => ((string: string) => string))
+      & ((chars: string, string: string) => string);
+    trimEnd(string: string): string;
+    trimCharsEnd:
+      & ((chars: string) => ((string: string) => string))
+      & ((chars: string, string: string) => string);
+    trimStart(string: string): string;
+    trimCharsStart:
+      & ((chars: string) => ((string: string) => string))
+      & ((chars: string, string: string) => string);
+    truncate:
+      & ((options: TruncateOptions) => ((string: string) => string))
+      & ((options: TruncateOptions, string: string) => string);
+    unescape(string: string): string;
+    upperCase(string: string): string;
+    upperFirst(string: string): string;
+    words(string: string): Array<string>;
+
+    // Util
+    attempt(func: Function): any;
+    bindAll:
+      & ((methodNames: $ReadOnlyArray<string>) => ((object: Object) => Object))
+      & ((methodNames: $ReadOnlyArray<string>, object: Object) => Object);
+    cond(pairs: NestedArray<Function>): Function;
+    constant<T>(value: T): () => T;
+    always<T>(value: T): () => T;
+    defaultTo:
+      & (<T1: void | null, T2>(defaultValue: T2) => ((value: T1) => T2))
+      & (<T1: void | null, T2>(defaultValue: T2, value: T1) => T2)
+      & (<T1: string | boolean, T2>(
+        defaultValue: T2
+      ) => ((value: T1) => T1))
+      & (<T1: string | boolean, T2>(
+        defaultValue: T2,
+        value: T1
+      ) => T1)
+      // NaN is a number instead of its own type, otherwise it would behave like null/void
+      & (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
+      & (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
+    flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
+    pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
+    flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+    compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+    identity<T>(value: T): T;
+    iteratee(func: any): Function;
+    matches:
+      & ((source: Object) => ((object: Object) => boolean))
+      & ((source: Object, object: Object) => boolean);
+    matchesProperty:
+      & ((path: Path) => ((srcValue: any) => Function))
+      & ((path: Path, srcValue: any) => Function);
+    propEq:
+      & ((path: Path) => ((srcValue: any) => Function))
+      & ((path: Path, srcValue: any) => Function);
+    pathEq:
+      & ((path: Path) => ((srcValue: any) => Function))
+      & ((path: Path, srcValue: any) => Function);
+    method(path: Path): Function;
+    methodOf(object: Object): Function;
+    mixin:
+      & (<T: Function | Object>(
+        object: T
+      ) => (((source: Object) => (options: { chain: boolean, ... }) => T) &
+        ((source: Object, options: { chain: boolean, ... }) => T)))
+      & (<T: Function | Object>(
+        object: T,
+        source: Object
+      ) => ((options: { chain: boolean, ... }) => T))
+      & (<T: Function | Object>(
+        object: T,
+        source: Object,
+        options: { chain: boolean, ... }
+      ) => T);
+    noConflict(): Lodash;
+    noop(...args: $ReadOnlyArray<mixed>): void;
+    nthArg(n: number): Function;
+    over(iteratees: $ReadOnlyArray<Function>): Function;
+    juxt(iteratees: $ReadOnlyArray<Function>): Function;
+    overEvery(predicates: $ReadOnlyArray<Function>): Function;
+    allPass(predicates: $ReadOnlyArray<Function>): Function;
+    overSome(predicates: $ReadOnlyArray<Function>): Function;
+    anyPass(predicates: $ReadOnlyArray<Function>): Function;
+    property:
+      & ((
+        path: Path
+      ) => ((object: Object | $ReadOnlyArray<any>) => any))
+      & ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
+    propertyOf:
+      & ((object: Object) => ((path: Path) => Function))
+      & ((object: Object, path: Path) => Function);
+    range:
+      & ((start: number) => ((end: number) => Array<number>))
+      & (start: number, end: number) => Array<number>;
+    rangeStep:
+      & ((
+      step: number
+    ) => (((start: number) => (end: number) => Array<number>) &
+      ((start: number, end: number) => Array<number>)))
+    & ((step: number, start: number) => ((end: number) => Array<number>))
+    & ((step: number, start: number, end: number) => Array<number>);
+    rangeRight:
+      & ((start: number) => ((end: number) => Array<number>))
+      & ((start: number, end: number) => Array<number>);
+    rangeStepRight:
+      & ((
+        step: number
+      ) => (((start: number) => (end: number) => Array<number>) &
+        ((start: number, end: number) => Array<number>)))
+      & ((step: number, start: number) => ((end: number) => Array<number>))
+      & ((step: number, start: number, end: number) => Array<number>);
+    runInContext(context: Object): Function;
+
+    stubArray(): Array<any>;
+    stubFalse(): false;
+    F(): false;
+    stubObject(): {...};
+    stubString(): "";
+    stubTrue(): true;
+    T(): true;
+    times:
+      & (<T>(iteratee: (i: number) => T) => ((n: number) => Array<T>))
+      & (<T>(iteratee: (i: number) => T, n: number) => Array<T>);
+    toPath(value: any): Array<string>;
+    uniqueId(prefix: string): string;
+
+    __: any;
+    placeholder: any;
+
+    convert(options: {
+      cap?: boolean,
+      curry?: boolean,
+      fixed?: boolean,
+      immutable?: boolean,
+      rearg?: boolean,
+      ...
+    }): void;
+
+    // Properties
+    VERSION: string;
+    templateSettings: TemplateSettings;
+  |}
+
+  declare module.exports: Lodash;
+}
+
+declare module "lodash/chunk" {
+  declare module.exports: $Exports<"lodash">["chunk"];
+}
+
+declare module "lodash/compact" {
+  declare module.exports: $Exports<"lodash">["compact"];
+}
+
+declare module "lodash/concat" {
+  declare module.exports: $Exports<"lodash">["concat"];
+}
+
+declare module "lodash/difference" {
+  declare module.exports: $Exports<"lodash">["difference"];
+}
+
+declare module "lodash/differenceBy" {
+  declare module.exports: $Exports<"lodash">["differenceBy"];
+}
+
+declare module "lodash/differenceWith" {
+  declare module.exports: $Exports<"lodash">["differenceWith"];
+}
+
+declare module "lodash/drop" {
+  declare module.exports: $Exports<"lodash">["drop"];
+}
+
+declare module "lodash/dropRight" {
+  declare module.exports: $Exports<"lodash">["dropRight"];
+}
+
+declare module "lodash/dropRightWhile" {
+  declare module.exports: $Exports<"lodash">["dropRightWhile"];
+}
+
+declare module "lodash/dropWhile" {
+  declare module.exports: $Exports<"lodash">["dropWhile"];
+}
+
+declare module "lodash/fill" {
+  declare module.exports: $Exports<"lodash">["fill"];
+}
+
+declare module "lodash/findIndex" {
+  declare module.exports: $Exports<"lodash">["findIndex"];
+}
+
+declare module "lodash/findLastIndex" {
+  declare module.exports: $Exports<"lodash">["findLastIndex"];
+}
+
+declare module "lodash/first" {
+  declare module.exports: $Exports<"lodash">["first"];
+}
+
+declare module "lodash/flatten" {
+  declare module.exports: $Exports<"lodash">["flatten"];
+}
+
+declare module "lodash/flattenDeep" {
+  declare module.exports: $Exports<"lodash">["flattenDeep"];
+}
+
+declare module "lodash/flattenDepth" {
+  declare module.exports: $Exports<"lodash">["flattenDepth"];
+}
+
+declare module "lodash/fromPairs" {
+  declare module.exports: $Exports<"lodash">["fromPairs"];
+}
+
+declare module "lodash/head" {
+  declare module.exports: $Exports<"lodash">["head"];
+}
+
+declare module "lodash/indexOf" {
+  declare module.exports: $Exports<"lodash">["indexOf"];
+}
+
+declare module "lodash/initial" {
+  declare module.exports: $Exports<"lodash">["initial"];
+}
+
+declare module "lodash/intersection" {
+  declare module.exports: $Exports<"lodash">["intersection"];
+}
+
+declare module "lodash/intersectionBy" {
+  declare module.exports: $Exports<"lodash">["intersectionBy"];
+}
+
+declare module "lodash/intersectionWith" {
+  declare module.exports: $Exports<"lodash">["intersectionWith"];
+}
+
+declare module "lodash/join" {
+  declare module.exports: $Exports<"lodash">["join"];
+}
+
+declare module "lodash/last" {
+  declare module.exports: $Exports<"lodash">["last"];
+}
+
+declare module "lodash/lastIndexOf" {
+  declare module.exports: $Exports<"lodash">["lastIndexOf"];
+}
+
+declare module "lodash/nth" {
+  declare module.exports: $Exports<"lodash">["nth"];
+}
+
+declare module "lodash/pull" {
+  declare module.exports: $Exports<"lodash">["pull"];
+}
+
+declare module "lodash/pullAll" {
+  declare module.exports: $Exports<"lodash">["pullAll"];
+}
+
+declare module "lodash/pullAllBy" {
+  declare module.exports: $Exports<"lodash">["pullAllBy"];
+}
+
+declare module "lodash/pullAllWith" {
+  declare module.exports: $Exports<"lodash">["pullAllWith"];
+}
+
+declare module "lodash/pullAt" {
+  declare module.exports: $Exports<"lodash">["pullAt"];
+}
+
+declare module "lodash/remove" {
+  declare module.exports: $Exports<"lodash">["remove"];
+}
+
+declare module "lodash/reverse" {
+  declare module.exports: $Exports<"lodash">["reverse"];
+}
+
+declare module "lodash/slice" {
+  declare module.exports: $Exports<"lodash">["slice"];
+}
+
+declare module "lodash/sortedIndex" {
+  declare module.exports: $Exports<"lodash">["sortedIndex"];
+}
+
+declare module "lodash/sortedIndexBy" {
+  declare module.exports: $Exports<"lodash">["sortedIndexBy"];
+}
+
+declare module "lodash/sortedIndexOf" {
+  declare module.exports: $Exports<"lodash">["sortedIndexOf"];
+}
+
+declare module "lodash/sortedLastIndex" {
+  declare module.exports: $Exports<"lodash">["sortedLastIndex"];
+}
+
+declare module "lodash/sortedLastIndexBy" {
+  declare module.exports: $Exports<"lodash">["sortedLastIndexBy"];
+}
+
+declare module "lodash/sortedLastIndexOf" {
+  declare module.exports: $Exports<"lodash">["sortedLastIndexOf"];
+}
+
+declare module "lodash/sortedUniq" {
+  declare module.exports: $Exports<"lodash">["sortedUniq"];
+}
+
+declare module "lodash/sortedUniqBy" {
+  declare module.exports: $Exports<"lodash">["sortedUniqBy"];
+}
+
+declare module "lodash/tail" {
+  declare module.exports: $Exports<"lodash">["tail"];
+}
+
+declare module "lodash/take" {
+  declare module.exports: $Exports<"lodash">["take"];
+}
+
+declare module "lodash/takeRight" {
+  declare module.exports: $Exports<"lodash">["takeRight"];
+}
+
+declare module "lodash/takeRightWhile" {
+  declare module.exports: $Exports<"lodash">["takeRightWhile"];
+}
+
+declare module "lodash/takeWhile" {
+  declare module.exports: $Exports<"lodash">["takeWhile"];
+}
+
+declare module "lodash/union" {
+  declare module.exports: $Exports<"lodash">["union"];
+}
+
+declare module "lodash/unionBy" {
+  declare module.exports: $Exports<"lodash">["unionBy"];
+}
+
+declare module "lodash/unionWith" {
+  declare module.exports: $Exports<"lodash">["unionWith"];
+}
+
+declare module "lodash/uniq" {
+  declare module.exports: $Exports<"lodash">["uniq"];
+}
+
+declare module "lodash/uniqBy" {
+  declare module.exports: $Exports<"lodash">["uniqBy"];
+}
+
+declare module "lodash/uniqWith" {
+  declare module.exports: $Exports<"lodash">["uniqWith"];
+}
+
+declare module "lodash/unzip" {
+  declare module.exports: $Exports<"lodash">["unzip"];
+}
+
+declare module "lodash/unzipWith" {
+  declare module.exports: $Exports<"lodash">["unzipWith"];
+}
+
+declare module "lodash/without" {
+  declare module.exports: $Exports<"lodash">["without"];
+}
+
+declare module "lodash/xor" {
+  declare module.exports: $Exports<"lodash">["xor"];
+}
+
+declare module "lodash/xorBy" {
+  declare module.exports: $Exports<"lodash">["xorBy"];
+}
+
+declare module "lodash/xorWith" {
+  declare module.exports: $Exports<"lodash">["xorWith"];
+}
+
+declare module "lodash/zip" {
+  declare module.exports: $Exports<"lodash">["zip"];
+}
+
+declare module "lodash/zipObject" {
+  declare module.exports: $Exports<"lodash">["zipObject"];
+}
+
+declare module "lodash/zipObjectDeep" {
+  declare module.exports: $Exports<"lodash">["zipObjectDeep"];
+}
+
+declare module "lodash/zipWith" {
+  declare module.exports: $Exports<"lodash">["zipWith"];
+}
+
+declare module "lodash/countBy" {
+  declare module.exports: $Exports<"lodash">["countBy"];
+}
+
+declare module "lodash/each" {
+  declare module.exports: $Exports<"lodash">["each"];
+}
+
+declare module "lodash/eachRight" {
+  declare module.exports: $Exports<"lodash">["eachRight"];
+}
+
+declare module "lodash/every" {
+  declare module.exports: $Exports<"lodash">["every"];
+}
+
+declare module "lodash/filter" {
+  declare module.exports: $Exports<"lodash">["filter"];
+}
+
+declare module "lodash/find" {
+  declare module.exports: $Exports<"lodash">["find"];
+}
+
+declare module "lodash/findLast" {
+  declare module.exports: $Exports<"lodash">["findLast"];
+}
+
+declare module "lodash/flatMap" {
+  declare module.exports: $Exports<"lodash">["flatMap"];
+}
+
+declare module "lodash/flatMapDeep" {
+  declare module.exports: $Exports<"lodash">["flatMapDeep"];
+}
+
+declare module "lodash/flatMapDepth" {
+  declare module.exports: $Exports<"lodash">["flatMapDepth"];
+}
+
+declare module "lodash/forEach" {
+  declare module.exports: $Exports<"lodash">["forEach"];
+}
+
+declare module "lodash/forEachRight" {
+  declare module.exports: $Exports<"lodash">["forEachRight"];
+}
+
+declare module "lodash/groupBy" {
+  declare module.exports: $Exports<"lodash">["groupBy"];
+}
+
+declare module "lodash/includes" {
+  declare module.exports: $Exports<"lodash">["includes"];
+}
+
+declare module "lodash/invokeMap" {
+  declare module.exports: $Exports<"lodash">["invokeMap"];
+}
+
+declare module "lodash/keyBy" {
+  declare module.exports: $Exports<"lodash">["keyBy"];
+}
+
+declare module "lodash/map" {
+  declare module.exports: $Exports<"lodash">["map"];
+}
+
+declare module "lodash/orderBy" {
+  declare module.exports: $Exports<"lodash">["orderBy"];
+}
+
+declare module "lodash/partition" {
+  declare module.exports: $Exports<"lodash">["partition"];
+}
+
+declare module "lodash/reduce" {
+  declare module.exports: $Exports<"lodash">["reduce"];
+}
+
+declare module "lodash/reduceRight" {
+  declare module.exports: $Exports<"lodash">["reduceRight"];
+}
+
+declare module "lodash/reject" {
+  declare module.exports: $Exports<"lodash">["reject"];
+}
+
+declare module "lodash/sample" {
+  declare module.exports: $Exports<"lodash">["sample"];
+}
+
+declare module "lodash/sampleSize" {
+  declare module.exports: $Exports<"lodash">["sampleSize"];
+}
+
+declare module "lodash/shuffle" {
+  declare module.exports: $Exports<"lodash">["shuffle"];
+}
+
+declare module "lodash/size" {
+  declare module.exports: $Exports<"lodash">["size"];
+}
+
+declare module "lodash/some" {
+  declare module.exports: $Exports<"lodash">["some"];
+}
+
+declare module "lodash/sortBy" {
+  declare module.exports: $Exports<"lodash">["sortBy"];
+}
+
+declare module "lodash/now" {
+  declare module.exports: $Exports<"lodash">["now"];
+}
+
+declare module "lodash/after" {
+  declare module.exports: $Exports<"lodash">["after"];
+}
+
+declare module "lodash/ary" {
+  declare module.exports: $Exports<"lodash">["ary"];
+}
+
+declare module "lodash/before" {
+  declare module.exports: $Exports<"lodash">["before"];
+}
+
+declare module "lodash/bind" {
+  declare module.exports: $Exports<"lodash">["bind"];
+}
+
+declare module "lodash/bindKey" {
+  declare module.exports: $Exports<"lodash">["bindKey"];
+}
+
+declare module "lodash/curry" {
+  declare module.exports: $Exports<"lodash">["curry"];
+}
+
+declare module "lodash/curryRight" {
+  declare module.exports: $Exports<"lodash">["curryRight"];
+}
+
+declare module "lodash/debounce" {
+  declare module.exports: $Exports<"lodash">["debounce"];
+}
+
+declare module "lodash/defer" {
+  declare module.exports: $Exports<"lodash">["defer"];
+}
+
+declare module "lodash/delay" {
+  declare module.exports: $Exports<"lodash">["delay"];
+}
+
+declare module "lodash/flip" {
+  declare module.exports: $Exports<"lodash">["flip"];
+}
+
+declare module "lodash/memoize" {
+  declare module.exports: $Exports<"lodash">["memoize"];
+}
+
+declare module "lodash/negate" {
+  declare module.exports: $Exports<"lodash">["negate"];
+}
+
+declare module "lodash/once" {
+  declare module.exports: $Exports<"lodash">["once"];
+}
+
+declare module "lodash/overArgs" {
+  declare module.exports: $Exports<"lodash">["overArgs"];
+}
+
+declare module "lodash/partial" {
+  declare module.exports: $Exports<"lodash">["partial"];
+}
+
+declare module "lodash/partialRight" {
+  declare module.exports: $Exports<"lodash">["partialRight"];
+}
+
+declare module "lodash/rearg" {
+  declare module.exports: $Exports<"lodash">["rearg"];
+}
+
+declare module "lodash/rest" {
+  declare module.exports: $Exports<"lodash">["rest"];
+}
+
+declare module "lodash/spread" {
+  declare module.exports: $Exports<"lodash">["spread"];
+}
+
+declare module "lodash/throttle" {
+  declare module.exports: $Exports<"lodash">["throttle"];
+}
+
+declare module "lodash/unary" {
+  declare module.exports: $Exports<"lodash">["unary"];
+}
+
+declare module "lodash/wrap" {
+  declare module.exports: $Exports<"lodash">["wrap"];
+}
+
+declare module "lodash/castArray" {
+  declare module.exports: $Exports<"lodash">["castArray"];
+}
+
+declare module "lodash/clone" {
+  declare module.exports: $Exports<"lodash">["clone"];
+}
+
+declare module "lodash/cloneDeep" {
+  declare module.exports: $Exports<"lodash">["cloneDeep"];
+}
+
+declare module "lodash/cloneDeepWith" {
+  declare module.exports: $Exports<"lodash">["cloneDeepWith"];
+}
+
+declare module "lodash/cloneWith" {
+  declare module.exports: $Exports<"lodash">["cloneWith"];
+}
+
+declare module "lodash/conformsTo" {
+  declare module.exports: $Exports<"lodash">["conformsTo"];
+}
+
+declare module "lodash/eq" {
+  declare module.exports: $Exports<"lodash">["eq"];
+}
+
+declare module "lodash/gt" {
+  declare module.exports: $Exports<"lodash">["gt"];
+}
+
+declare module "lodash/gte" {
+  declare module.exports: $Exports<"lodash">["gte"];
+}
+
+declare module "lodash/isArguments" {
+  declare module.exports: $Exports<"lodash">["isArguments"];
+}
+
+declare module "lodash/isArray" {
+  declare module.exports: $Exports<"lodash">["isArray"];
+}
+
+declare module "lodash/isArrayBuffer" {
+  declare module.exports: $Exports<"lodash">["isArrayBuffer"];
+}
+
+declare module "lodash/isArrayLike" {
+  declare module.exports: $Exports<"lodash">["isArrayLike"];
+}
+
+declare module "lodash/isArrayLikeObject" {
+  declare module.exports: $Exports<"lodash">["isArrayLikeObject"];
+}
+
+declare module "lodash/isBoolean" {
+  declare module.exports: $Exports<"lodash">["isBoolean"];
+}
+
+declare module "lodash/isBuffer" {
+  declare module.exports: $Exports<"lodash">["isBuffer"];
+}
+
+declare module "lodash/isDate" {
+  declare module.exports: $Exports<"lodash">["isDate"];
+}
+
+declare module "lodash/isElement" {
+  declare module.exports: $Exports<"lodash">["isElement"];
+}
+
+declare module "lodash/isEmpty" {
+  declare module.exports: $Exports<"lodash">["isEmpty"];
+}
+
+declare module "lodash/isEqual" {
+  declare module.exports: $Exports<"lodash">["isEqual"];
+}
+
+declare module "lodash/isEqualWith" {
+  declare module.exports: $Exports<"lodash">["isEqualWith"];
+}
+
+declare module "lodash/isError" {
+  declare module.exports: $Exports<"lodash">["isError"];
+}
+
+declare module "lodash/isFinite" {
+  declare module.exports: $Exports<"lodash">["isFinite"];
+}
+
+declare module "lodash/isFunction" {
+  declare module.exports: $Exports<"lodash">["isFunction"];
+}
+
+declare module "lodash/isInteger" {
+  declare module.exports: $Exports<"lodash">["isInteger"];
+}
+
+declare module "lodash/isLength" {
+  declare module.exports: $Exports<"lodash">["isLength"];
+}
+
+declare module "lodash/isMap" {
+  declare module.exports: $Exports<"lodash">["isMap"];
+}
+
+declare module "lodash/isMatch" {
+  declare module.exports: $Exports<"lodash">["isMatch"];
+}
+
+declare module "lodash/isMatchWith" {
+  declare module.exports: $Exports<"lodash">["isMatchWith"];
+}
+
+declare module "lodash/isNaN" {
+  declare module.exports: $Exports<"lodash">["isNaN"];
+}
+
+declare module "lodash/isNative" {
+  declare module.exports: $Exports<"lodash">["isNative"];
+}
+
+declare module "lodash/isNil" {
+  declare module.exports: $Exports<"lodash">["isNil"];
+}
+
+declare module "lodash/isNull" {
+  declare module.exports: $Exports<"lodash">["isNull"];
+}
+
+declare module "lodash/isNumber" {
+  declare module.exports: $Exports<"lodash">["isNumber"];
+}
+
+declare module "lodash/isObject" {
+  declare module.exports: $Exports<"lodash">["isObject"];
+}
+
+declare module "lodash/isObjectLike" {
+  declare module.exports: $Exports<"lodash">["isObjectLike"];
+}
+
+declare module "lodash/isPlainObject" {
+  declare module.exports: $Exports<"lodash">["isPlainObject"];
+}
+
+declare module "lodash/isRegExp" {
+  declare module.exports: $Exports<"lodash">["isRegExp"];
+}
+
+declare module "lodash/isSafeInteger" {
+  declare module.exports: $Exports<"lodash">["isSafeInteger"];
+}
+
+declare module "lodash/isSet" {
+  declare module.exports: $Exports<"lodash">["isSet"];
+}
+
+declare module "lodash/isString" {
+  declare module.exports: $Exports<"lodash">["isString"];
+}
+
+declare module "lodash/isSymbol" {
+  declare module.exports: $Exports<"lodash">["isSymbol"];
+}
+
+declare module "lodash/isTypedArray" {
+  declare module.exports: $Exports<"lodash">["isTypedArray"];
+}
+
+declare module "lodash/isUndefined" {
+  declare module.exports: $Exports<"lodash">["isUndefined"];
+}
+
+declare module "lodash/isWeakMap" {
+  declare module.exports: $Exports<"lodash">["isWeakMap"];
+}
+
+declare module "lodash/isWeakSet" {
+  declare module.exports: $Exports<"lodash">["isWeakSet"];
+}
+
+declare module "lodash/lt" {
+  declare module.exports: $Exports<"lodash">["lt"];
+}
+
+declare module "lodash/lte" {
+  declare module.exports: $Exports<"lodash">["lte"];
+}
+
+declare module "lodash/toArray" {
+  declare module.exports: $Exports<"lodash">["toArray"];
+}
+
+declare module "lodash/toFinite" {
+  declare module.exports: $Exports<"lodash">["toFinite"];
+}
+
+declare module "lodash/toInteger" {
+  declare module.exports: $Exports<"lodash">["toInteger"];
+}
+
+declare module "lodash/toLength" {
+  declare module.exports: $Exports<"lodash">["toLength"];
+}
+
+declare module "lodash/toNumber" {
+  declare module.exports: $Exports<"lodash">["toNumber"];
+}
+
+declare module "lodash/toPlainObject" {
+  declare module.exports: $Exports<"lodash">["toPlainObject"];
+}
+
+declare module "lodash/toSafeInteger" {
+  declare module.exports: $Exports<"lodash">["toSafeInteger"];
+}
+
+declare module "lodash/toString" {
+  declare module.exports: $Exports<"lodash">["toString"];
+}
+
+declare module "lodash/add" {
+  declare module.exports: $Exports<"lodash">["add"];
+}
+
+declare module "lodash/ceil" {
+  declare module.exports: $Exports<"lodash">["ceil"];
+}
+
+declare module "lodash/divide" {
+  declare module.exports: $Exports<"lodash">["divide"];
+}
+
+declare module "lodash/floor" {
+  declare module.exports: $Exports<"lodash">["floor"];
+}
+
+declare module "lodash/max" {
+  declare module.exports: $Exports<"lodash">["max"];
+}
+
+declare module "lodash/maxBy" {
+  declare module.exports: $Exports<"lodash">["maxBy"];
+}
+
+declare module "lodash/mean" {
+  declare module.exports: $Exports<"lodash">["mean"];
+}
+
+declare module "lodash/meanBy" {
+  declare module.exports: $Exports<"lodash">["meanBy"];
+}
+
+declare module "lodash/min" {
+  declare module.exports: $Exports<"lodash">["min"];
+}
+
+declare module "lodash/minBy" {
+  declare module.exports: $Exports<"lodash">["minBy"];
+}
+
+declare module "lodash/multiply" {
+  declare module.exports: $Exports<"lodash">["multiply"];
+}
+
+declare module "lodash/round" {
+  declare module.exports: $Exports<"lodash">["round"];
+}
+
+declare module "lodash/subtract" {
+  declare module.exports: $Exports<"lodash">["subtract"];
+}
+
+declare module "lodash/sum" {
+  declare module.exports: $Exports<"lodash">["sum"];
+}
+
+declare module "lodash/sumBy" {
+  declare module.exports: $Exports<"lodash">["sumBy"];
+}
+
+declare module "lodash/clamp" {
+  declare module.exports: $Exports<"lodash">["clamp"];
+}
+
+declare module "lodash/inRange" {
+  declare module.exports: $Exports<"lodash">["inRange"];
+}
+
+declare module "lodash/random" {
+  declare module.exports: $Exports<"lodash">["random"];
+}
+
+declare module "lodash/assign" {
+  declare module.exports: $Exports<"lodash">["assign"];
+}
+
+declare module "lodash/assignIn" {
+  declare module.exports: $Exports<"lodash">["assignIn"];
+}
+
+declare module "lodash/assignInWith" {
+  declare module.exports: $Exports<"lodash">["assignInWith"];
+}
+
+declare module "lodash/assignWith" {
+  declare module.exports: $Exports<"lodash">["assignWith"];
+}
+
+declare module "lodash/at" {
+  declare module.exports: $Exports<"lodash">["at"];
+}
+
+declare module "lodash/create" {
+  declare module.exports: $Exports<"lodash">["create"];
+}
+
+declare module "lodash/defaults" {
+  declare module.exports: $Exports<"lodash">["defaults"];
+}
+
+declare module "lodash/defaultsDeep" {
+  declare module.exports: $Exports<"lodash">["defaultsDeep"];
+}
+
+declare module "lodash/entries" {
+  declare module.exports: $Exports<"lodash">["entries"];
+}
+
+declare module "lodash/entriesIn" {
+  declare module.exports: $Exports<"lodash">["entriesIn"];
+}
+
+declare module "lodash/extend" {
+  declare module.exports: $Exports<"lodash">["extend"];
+}
+
+declare module "lodash/extendWith" {
+  declare module.exports: $Exports<"lodash">["extendWith"];
+}
+
+declare module "lodash/findKey" {
+  declare module.exports: $Exports<"lodash">["findKey"];
+}
+
+declare module "lodash/findLastKey" {
+  declare module.exports: $Exports<"lodash">["findLastKey"];
+}
+
+declare module "lodash/forIn" {
+  declare module.exports: $Exports<"lodash">["forIn"];
+}
+
+declare module "lodash/forInRight" {
+  declare module.exports: $Exports<"lodash">["forInRight"];
+}
+
+declare module "lodash/forOwn" {
+  declare module.exports: $Exports<"lodash">["forOwn"];
+}
+
+declare module "lodash/forOwnRight" {
+  declare module.exports: $Exports<"lodash">["forOwnRight"];
+}
+
+declare module "lodash/functions" {
+  declare module.exports: $Exports<"lodash">["functions"];
+}
+
+declare module "lodash/functionsIn" {
+  declare module.exports: $Exports<"lodash">["functionsIn"];
+}
+
+declare module "lodash/get" {
+  declare module.exports: $Exports<"lodash">["get"];
+}
+
+declare module "lodash/has" {
+  declare module.exports: $Exports<"lodash">["has"];
+}
+
+declare module "lodash/hasIn" {
+  declare module.exports: $Exports<"lodash">["hasIn"];
+}
+
+declare module "lodash/invert" {
+  declare module.exports: $Exports<"lodash">["invert"];
+}
+
+declare module "lodash/invertBy" {
+  declare module.exports: $Exports<"lodash">["invertBy"];
+}
+
+declare module "lodash/invoke" {
+  declare module.exports: $Exports<"lodash">["invoke"];
+}
+
+declare module "lodash/keys" {
+  declare module.exports: $Exports<"lodash">["keys"];
+}
+
+declare module "lodash/keysIn" {
+  declare module.exports: $Exports<"lodash">["keysIn"];
+}
+
+declare module "lodash/mapKeys" {
+  declare module.exports: $Exports<"lodash">["mapKeys"];
+}
+
+declare module "lodash/mapValues" {
+  declare module.exports: $Exports<"lodash">["mapValues"];
+}
+
+declare module "lodash/merge" {
+  declare module.exports: $Exports<"lodash">["merge"];
+}
+
+declare module "lodash/mergeWith" {
+  declare module.exports: $Exports<"lodash">["mergeWith"];
+}
+
+declare module "lodash/omit" {
+  declare module.exports: $Exports<"lodash">["omit"];
+}
+
+declare module "lodash/omitBy" {
+  declare module.exports: $Exports<"lodash">["omitBy"];
+}
+
+declare module "lodash/pick" {
+  declare module.exports: $Exports<"lodash">["pick"];
+}
+
+declare module "lodash/pickBy" {
+  declare module.exports: $Exports<"lodash">["pickBy"];
+}
+
+declare module "lodash/result" {
+  declare module.exports: $Exports<"lodash">["result"];
+}
+
+declare module "lodash/set" {
+  declare module.exports: $Exports<"lodash">["set"];
+}
+
+declare module "lodash/setWith" {
+  declare module.exports: $Exports<"lodash">["setWith"];
+}
+
+declare module "lodash/toPairs" {
+  declare module.exports: $Exports<"lodash">["toPairs"];
+}
+
+declare module "lodash/toPairsIn" {
+  declare module.exports: $Exports<"lodash">["toPairsIn"];
+}
+
+declare module "lodash/transform" {
+  declare module.exports: $Exports<"lodash">["transform"];
+}
+
+declare module "lodash/unset" {
+  declare module.exports: $Exports<"lodash">["unset"];
+}
+
+declare module "lodash/update" {
+  declare module.exports: $Exports<"lodash">["update"];
+}
+
+declare module "lodash/updateWith" {
+  declare module.exports: $Exports<"lodash">["updateWith"];
+}
+
+declare module "lodash/values" {
+  declare module.exports: $Exports<"lodash">["values"];
+}
+
+declare module "lodash/valuesIn" {
+  declare module.exports: $Exports<"lodash">["valuesIn"];
+}
+
+declare module "lodash/chain" {
+  declare module.exports: $Exports<"lodash">["chain"];
+}
+
+declare module "lodash/tap" {
+  declare module.exports: $Exports<"lodash">["tap"];
+}
+
+declare module "lodash/thru" {
+  declare module.exports: $Exports<"lodash">["thru"];
+}
+
+declare module "lodash/camelCase" {
+  declare module.exports: $Exports<"lodash">["camelCase"];
+}
+
+declare module "lodash/capitalize" {
+  declare module.exports: $Exports<"lodash">["capitalize"];
+}
+
+declare module "lodash/deburr" {
+  declare module.exports: $Exports<"lodash">["deburr"];
+}
+
+declare module "lodash/endsWith" {
+  declare module.exports: $Exports<"lodash">["endsWith"];
+}
+
+declare module "lodash/escape" {
+  declare module.exports: $Exports<"lodash">["escape"];
+}
+
+declare module "lodash/escapeRegExp" {
+  declare module.exports: $Exports<"lodash">["escapeRegExp"];
+}
+
+declare module "lodash/kebabCase" {
+  declare module.exports: $Exports<"lodash">["kebabCase"];
+}
+
+declare module "lodash/lowerCase" {
+  declare module.exports: $Exports<"lodash">["lowerCase"];
+}
+
+declare module "lodash/lowerFirst" {
+  declare module.exports: $Exports<"lodash">["lowerFirst"];
+}
+
+declare module "lodash/pad" {
+  declare module.exports: $Exports<"lodash">["pad"];
+}
+
+declare module "lodash/padEnd" {
+  declare module.exports: $Exports<"lodash">["padEnd"];
+}
+
+declare module "lodash/padStart" {
+  declare module.exports: $Exports<"lodash">["padStart"];
+}
+
+declare module "lodash/parseInt" {
+  declare module.exports: $Exports<"lodash">["parseInt"];
+}
+
+declare module "lodash/repeat" {
+  declare module.exports: $Exports<"lodash">["repeat"];
+}
+
+declare module "lodash/replace" {
+  declare module.exports: $Exports<"lodash">["replace"];
+}
+
+declare module "lodash/snakeCase" {
+  declare module.exports: $Exports<"lodash">["snakeCase"];
+}
+
+declare module "lodash/split" {
+  declare module.exports: $Exports<"lodash">["split"];
+}
+
+declare module "lodash/startCase" {
+  declare module.exports: $Exports<"lodash">["startCase"];
+}
+
+declare module "lodash/startsWith" {
+  declare module.exports: $Exports<"lodash">["startsWith"];
+}
+
+declare module "lodash/template" {
+  declare module.exports: $Exports<"lodash">["template"];
+}
+
+declare module "lodash/toLower" {
+  declare module.exports: $Exports<"lodash">["toLower"];
+}
+
+declare module "lodash/toUpper" {
+  declare module.exports: $Exports<"lodash">["toUpper"];
+}
+
+declare module "lodash/trim" {
+  declare module.exports: $Exports<"lodash">["trim"];
+}
+
+declare module "lodash/trimEnd" {
+  declare module.exports: $Exports<"lodash">["trimEnd"];
+}
+
+declare module "lodash/trimStart" {
+  declare module.exports: $Exports<"lodash">["trimStart"];
+}
+
+declare module "lodash/truncate" {
+  declare module.exports: $Exports<"lodash">["truncate"];
+}
+
+declare module "lodash/unescape" {
+  declare module.exports: $Exports<"lodash">["unescape"];
+}
+
+declare module "lodash/upperCase" {
+  declare module.exports: $Exports<"lodash">["upperCase"];
+}
+
+declare module "lodash/upperFirst" {
+  declare module.exports: $Exports<"lodash">["upperFirst"];
+}
+
+declare module "lodash/words" {
+  declare module.exports: $Exports<"lodash">["words"];
+}
+
+declare module "lodash/attempt" {
+  declare module.exports: $Exports<"lodash">["attempt"];
+}
+
+declare module "lodash/bindAll" {
+  declare module.exports: $Exports<"lodash">["bindAll"];
+}
+
+declare module "lodash/cond" {
+  declare module.exports: $Exports<"lodash">["cond"];
+}
+
+declare module "lodash/conforms" {
+  declare module.exports: $Exports<"lodash">["conforms"];
+}
+
+declare module "lodash/constant" {
+  declare module.exports: $Exports<"lodash">["constant"];
+}
+
+declare module "lodash/defaultTo" {
+  declare module.exports: $Exports<"lodash">["defaultTo"];
+}
+
+declare module "lodash/flow" {
+  declare module.exports: $Exports<"lodash">["flow"];
+}
+
+declare module "lodash/flowRight" {
+  declare module.exports: $Exports<"lodash">["flowRight"];
+}
+
+declare module "lodash/identity" {
+  declare module.exports: $Exports<"lodash">["identity"];
+}
+
+declare module "lodash/iteratee" {
+  declare module.exports: $Exports<"lodash">["iteratee"];
+}
+
+declare module "lodash/matches" {
+  declare module.exports: $Exports<"lodash">["matches"];
+}
+
+declare module "lodash/matchesProperty" {
+  declare module.exports: $Exports<"lodash">["matchesProperty"];
+}
+
+declare module "lodash/method" {
+  declare module.exports: $Exports<"lodash">["method"];
+}
+
+declare module "lodash/methodOf" {
+  declare module.exports: $Exports<"lodash">["methodOf"];
+}
+
+declare module "lodash/mixin" {
+  declare module.exports: $Exports<"lodash">["mixin"];
+}
+
+declare module "lodash/noConflict" {
+  declare module.exports: $Exports<"lodash">["noConflict"];
+}
+
+declare module "lodash/noop" {
+  declare module.exports: $Exports<"lodash">["noop"];
+}
+
+declare module "lodash/nthArg" {
+  declare module.exports: $Exports<"lodash">["nthArg"];
+}
+
+declare module "lodash/over" {
+  declare module.exports: $Exports<"lodash">["over"];
+}
+
+declare module "lodash/overEvery" {
+  declare module.exports: $Exports<"lodash">["overEvery"];
+}
+
+declare module "lodash/overSome" {
+  declare module.exports: $Exports<"lodash">["overSome"];
+}
+
+declare module "lodash/property" {
+  declare module.exports: $Exports<"lodash">["property"];
+}
+
+declare module "lodash/propertyOf" {
+  declare module.exports: $Exports<"lodash">["propertyOf"];
+}
+
+declare module "lodash/range" {
+  declare module.exports: $Exports<"lodash">["range"];
+}
+
+declare module "lodash/rangeRight" {
+  declare module.exports: $Exports<"lodash">["rangeRight"];
+}
+
+declare module "lodash/runInContext" {
+  declare module.exports: $Exports<"lodash">["runInContext"];
+}
+
+declare module "lodash/stubArray" {
+  declare module.exports: $Exports<"lodash">["stubArray"];
+}
+
+declare module "lodash/stubFalse" {
+  declare module.exports: $Exports<"lodash">["stubFalse"];
+}
+
+declare module "lodash/stubObject" {
+  declare module.exports: $Exports<"lodash">["stubObject"];
+}
+
+declare module "lodash/stubString" {
+  declare module.exports: $Exports<"lodash">["stubString"];
+}
+
+declare module "lodash/stubTrue" {
+  declare module.exports: $Exports<"lodash">["stubTrue"];
+}
+
+declare module "lodash/times" {
+  declare module.exports: $Exports<"lodash">["times"];
+}
+
+declare module "lodash/toPath" {
+  declare module.exports: $Exports<"lodash">["toPath"];
+}
+
+declare module "lodash/uniqueId" {
+  declare module.exports: $Exports<"lodash">["uniqueId"];
+}
+
+declare module "lodash/fp/chunk" {
+  declare module.exports: $Exports<"lodash/fp">["chunk"];
+}
+
+declare module "lodash/fp/compact" {
+  declare module.exports: $Exports<"lodash/fp">["compact"];
+}
+
+declare module "lodash/fp/concat" {
+  declare module.exports: $Exports<"lodash/fp">["concat"];
+}
+
+declare module "lodash/fp/difference" {
+  declare module.exports: $Exports<"lodash/fp">["difference"];
+}
+
+declare module "lodash/fp/differenceBy" {
+  declare module.exports: $Exports<"lodash/fp">["differenceBy"];
+}
+
+declare module "lodash/fp/differenceWith" {
+  declare module.exports: $Exports<"lodash/fp">["differenceWith"];
+}
+
+declare module "lodash/fp/drop" {
+  declare module.exports: $Exports<"lodash/fp">["drop"];
+}
+
+declare module "lodash/fp/dropLast" {
+  declare module.exports: $Exports<"lodash/fp">["dropLast"];
+}
+
+declare module "lodash/fp/dropRight" {
+  declare module.exports: $Exports<"lodash/fp">["dropRight"];
+}
+
+declare module "lodash/fp/dropRightWhile" {
+  declare module.exports: $Exports<"lodash/fp">["dropRightWhile"];
+}
+
+declare module "lodash/fp/dropWhile" {
+  declare module.exports: $Exports<"lodash/fp">["dropWhile"];
+}
+
+declare module "lodash/fp/dropLastWhile" {
+  declare module.exports: $Exports<"lodash/fp">["dropLastWhile"];
+}
+
+declare module "lodash/fp/fill" {
+  declare module.exports: $Exports<"lodash/fp">["fill"];
+}
+
+declare module "lodash/fp/findIndex" {
+  declare module.exports: $Exports<"lodash/fp">["findIndex"];
+}
+
+declare module "lodash/fp/findIndexFrom" {
+  declare module.exports: $Exports<"lodash/fp">["findIndexFrom"];
+}
+
+declare module "lodash/fp/findLastIndex" {
+  declare module.exports: $Exports<"lodash/fp">["findLastIndex"];
+}
+
+declare module "lodash/fp/findLastIndexFrom" {
+  declare module.exports: $Exports<"lodash/fp">["findLastIndexFrom"];
+}
+
+declare module "lodash/fp/first" {
+  declare module.exports: $Exports<"lodash/fp">["first"];
+}
+
+declare module "lodash/fp/flatten" {
+  declare module.exports: $Exports<"lodash/fp">["flatten"];
+}
+
+declare module "lodash/fp/unnest" {
+  declare module.exports: $Exports<"lodash/fp">["unnest"];
+}
+
+declare module "lodash/fp/flattenDeep" {
+  declare module.exports: $Exports<"lodash/fp">["flattenDeep"];
+}
+
+declare module "lodash/fp/flattenDepth" {
+  declare module.exports: $Exports<"lodash/fp">["flattenDepth"];
+}
+
+declare module "lodash/fp/fromPairs" {
+  declare module.exports: $Exports<"lodash/fp">["fromPairs"];
+}
+
+declare module "lodash/fp/head" {
+  declare module.exports: $Exports<"lodash/fp">["head"];
+}
+
+declare module "lodash/fp/indexOf" {
+  declare module.exports: $Exports<"lodash/fp">["indexOf"];
+}
+
+declare module "lodash/fp/indexOfFrom" {
+  declare module.exports: $Exports<"lodash/fp">["indexOfFrom"];
+}
+
+declare module "lodash/fp/initial" {
+  declare module.exports: $Exports<"lodash/fp">["initial"];
+}
+
+declare module "lodash/fp/init" {
+  declare module.exports: $Exports<"lodash/fp">["init"];
+}
+
+declare module "lodash/fp/intersection" {
+  declare module.exports: $Exports<"lodash/fp">["intersection"];
+}
+
+declare module "lodash/fp/intersectionBy" {
+  declare module.exports: $Exports<"lodash/fp">["intersectionBy"];
+}
+
+declare module "lodash/fp/intersectionWith" {
+  declare module.exports: $Exports<"lodash/fp">["intersectionWith"];
+}
+
+declare module "lodash/fp/join" {
+  declare module.exports: $Exports<"lodash/fp">["join"];
+}
+
+declare module "lodash/fp/last" {
+  declare module.exports: $Exports<"lodash/fp">["last"];
+}
+
+declare module "lodash/fp/lastIndexOf" {
+  declare module.exports: $Exports<"lodash/fp">["lastIndexOf"];
+}
+
+declare module "lodash/fp/lastIndexOfFrom" {
+  declare module.exports: $Exports<"lodash/fp">["lastIndexOfFrom"];
+}
+
+declare module "lodash/fp/nth" {
+  declare module.exports: $Exports<"lodash/fp">["nth"];
+}
+
+declare module "lodash/fp/pull" {
+  declare module.exports: $Exports<"lodash/fp">["pull"];
+}
+
+declare module "lodash/fp/pullAll" {
+  declare module.exports: $Exports<"lodash/fp">["pullAll"];
+}
+
+declare module "lodash/fp/pullAllBy" {
+  declare module.exports: $Exports<"lodash/fp">["pullAllBy"];
+}
+
+declare module "lodash/fp/pullAllWith" {
+  declare module.exports: $Exports<"lodash/fp">["pullAllWith"];
+}
+
+declare module "lodash/fp/pullAt" {
+  declare module.exports: $Exports<"lodash/fp">["pullAt"];
+}
+
+declare module "lodash/fp/remove" {
+  declare module.exports: $Exports<"lodash/fp">["remove"];
+}
+
+declare module "lodash/fp/reverse" {
+  declare module.exports: $Exports<"lodash/fp">["reverse"];
+}
+
+declare module "lodash/fp/slice" {
+  declare module.exports: $Exports<"lodash/fp">["slice"];
+}
+
+declare module "lodash/fp/sortedIndex" {
+  declare module.exports: $Exports<"lodash/fp">["sortedIndex"];
+}
+
+declare module "lodash/fp/sortedIndexBy" {
+  declare module.exports: $Exports<"lodash/fp">["sortedIndexBy"];
+}
+
+declare module "lodash/fp/sortedIndexOf" {
+  declare module.exports: $Exports<"lodash/fp">["sortedIndexOf"];
+}
+
+declare module "lodash/fp/sortedLastIndex" {
+  declare module.exports: $Exports<"lodash/fp">["sortedLastIndex"];
+}
+
+declare module "lodash/fp/sortedLastIndexBy" {
+  declare module.exports: $Exports<"lodash/fp">["sortedLastIndexBy"];
+}
+
+declare module "lodash/fp/sortedLastIndexOf" {
+  declare module.exports: $Exports<"lodash/fp">["sortedLastIndexOf"];
+}
+
+declare module "lodash/fp/sortedUniq" {
+  declare module.exports: $Exports<"lodash/fp">["sortedUniq"];
+}
+
+declare module "lodash/fp/sortedUniqBy" {
+  declare module.exports: $Exports<"lodash/fp">["sortedUniqBy"];
+}
+
+declare module "lodash/fp/tail" {
+  declare module.exports: $Exports<"lodash/fp">["tail"];
+}
+
+declare module "lodash/fp/take" {
+  declare module.exports: $Exports<"lodash/fp">["take"];
+}
+
+declare module "lodash/fp/takeRight" {
+  declare module.exports: $Exports<"lodash/fp">["takeRight"];
+}
+
+declare module "lodash/fp/takeLast" {
+  declare module.exports: $Exports<"lodash/fp">["takeLast"];
+}
+
+declare module "lodash/fp/takeRightWhile" {
+  declare module.exports: $Exports<"lodash/fp">["takeRightWhile"];
+}
+
+declare module "lodash/fp/takeLastWhile" {
+  declare module.exports: $Exports<"lodash/fp">["takeLastWhile"];
+}
+
+declare module "lodash/fp/takeWhile" {
+  declare module.exports: $Exports<"lodash/fp">["takeWhile"];
+}
+
+declare module "lodash/fp/union" {
+  declare module.exports: $Exports<"lodash/fp">["union"];
+}
+
+declare module "lodash/fp/unionBy" {
+  declare module.exports: $Exports<"lodash/fp">["unionBy"];
+}
+
+declare module "lodash/fp/unionWith" {
+  declare module.exports: $Exports<"lodash/fp">["unionWith"];
+}
+
+declare module "lodash/fp/uniq" {
+  declare module.exports: $Exports<"lodash/fp">["uniq"];
+}
+
+declare module "lodash/fp/uniqBy" {
+  declare module.exports: $Exports<"lodash/fp">["uniqBy"];
+}
+
+declare module "lodash/fp/uniqWith" {
+  declare module.exports: $Exports<"lodash/fp">["uniqWith"];
+}
+
+declare module "lodash/fp/unzip" {
+  declare module.exports: $Exports<"lodash/fp">["unzip"];
+}
+
+declare module "lodash/fp/unzipWith" {
+  declare module.exports: $Exports<"lodash/fp">["unzipWith"];
+}
+
+declare module "lodash/fp/without" {
+  declare module.exports: $Exports<"lodash/fp">["without"];
+}
+
+declare module "lodash/fp/xor" {
+  declare module.exports: $Exports<"lodash/fp">["xor"];
+}
+
+declare module "lodash/fp/symmetricDifference" {
+  declare module.exports: $Exports<"lodash/fp">["symmetricDifference"];
+}
+
+declare module "lodash/fp/xorBy" {
+  declare module.exports: $Exports<"lodash/fp">["xorBy"];
+}
+
+declare module "lodash/fp/symmetricDifferenceBy" {
+  declare module.exports: $Exports<"lodash/fp">["symmetricDifferenceBy"];
+}
+
+declare module "lodash/fp/xorWith" {
+  declare module.exports: $Exports<"lodash/fp">["xorWith"];
+}
+
+declare module "lodash/fp/symmetricDifferenceWith" {
+  declare module.exports: $Exports<"lodash/fp">["symmetricDifferenceWith"];
+}
+
+declare module "lodash/fp/zip" {
+  declare module.exports: $Exports<"lodash/fp">["zip"];
+}
+
+declare module "lodash/fp/zipAll" {
+  declare module.exports: $Exports<"lodash/fp">["zipAll"];
+}
+
+declare module "lodash/fp/zipObject" {
+  declare module.exports: $Exports<"lodash/fp">["zipObject"];
+}
+
+declare module "lodash/fp/zipObj" {
+  declare module.exports: $Exports<"lodash/fp">["zipObj"];
+}
+
+declare module "lodash/fp/zipObjectDeep" {
+  declare module.exports: $Exports<"lodash/fp">["zipObjectDeep"];
+}
+
+declare module "lodash/fp/zipWith" {
+  declare module.exports: $Exports<"lodash/fp">["zipWith"];
+}
+
+declare module "lodash/fp/countBy" {
+  declare module.exports: $Exports<"lodash/fp">["countBy"];
+}
+
+declare module "lodash/fp/each" {
+  declare module.exports: $Exports<"lodash/fp">["each"];
+}
+
+declare module "lodash/fp/eachRight" {
+  declare module.exports: $Exports<"lodash/fp">["eachRight"];
+}
+
+declare module "lodash/fp/every" {
+  declare module.exports: $Exports<"lodash/fp">["every"];
+}
+
+declare module "lodash/fp/all" {
+  declare module.exports: $Exports<"lodash/fp">["all"];
+}
+
+declare module "lodash/fp/filter" {
+  declare module.exports: $Exports<"lodash/fp">["filter"];
+}
+
+declare module "lodash/fp/find" {
+  declare module.exports: $Exports<"lodash/fp">["find"];
+}
+
+declare module "lodash/fp/findFrom" {
+  declare module.exports: $Exports<"lodash/fp">["findFrom"];
+}
+
+declare module "lodash/fp/findLast" {
+  declare module.exports: $Exports<"lodash/fp">["findLast"];
+}
+
+declare module "lodash/fp/findLastFrom" {
+  declare module.exports: $Exports<"lodash/fp">["findLastFrom"];
+}
+
+declare module "lodash/fp/flatMap" {
+  declare module.exports: $Exports<"lodash/fp">["flatMap"];
+}
+
+declare module "lodash/fp/flatMapDeep" {
+  declare module.exports: $Exports<"lodash/fp">["flatMapDeep"];
+}
+
+declare module "lodash/fp/flatMapDepth" {
+  declare module.exports: $Exports<"lodash/fp">["flatMapDepth"];
+}
+
+declare module "lodash/fp/forEach" {
+  declare module.exports: $Exports<"lodash/fp">["forEach"];
+}
+
+declare module "lodash/fp/forEachRight" {
+  declare module.exports: $Exports<"lodash/fp">["forEachRight"];
+}
+
+declare module "lodash/fp/groupBy" {
+  declare module.exports: $Exports<"lodash/fp">["groupBy"];
+}
+
+declare module "lodash/fp/includes" {
+  declare module.exports: $Exports<"lodash/fp">["includes"];
+}
+
+declare module "lodash/fp/contains" {
+  declare module.exports: $Exports<"lodash/fp">["contains"];
+}
+
+declare module "lodash/fp/includesFrom" {
+  declare module.exports: $Exports<"lodash/fp">["includesFrom"];
+}
+
+declare module "lodash/fp/invokeMap" {
+  declare module.exports: $Exports<"lodash/fp">["invokeMap"];
+}
+
+declare module "lodash/fp/invokeArgsMap" {
+  declare module.exports: $Exports<"lodash/fp">["invokeArgsMap"];
+}
+
+declare module "lodash/fp/keyBy" {
+  declare module.exports: $Exports<"lodash/fp">["keyBy"];
+}
+
+declare module "lodash/fp/indexBy" {
+  declare module.exports: $Exports<"lodash/fp">["indexBy"];
+}
+
+declare module "lodash/fp/map" {
+  declare module.exports: $Exports<"lodash/fp">["map"];
+}
+
+declare module "lodash/fp/pluck" {
+  declare module.exports: $Exports<"lodash/fp">["pluck"];
+}
+
+declare module "lodash/fp/orderBy" {
+  declare module.exports: $Exports<"lodash/fp">["orderBy"];
+}
+
+declare module "lodash/fp/partition" {
+  declare module.exports: $Exports<"lodash/fp">["partition"];
+}
+
+declare module "lodash/fp/reduce" {
+  declare module.exports: $Exports<"lodash/fp">["reduce"];
+}
+
+declare module "lodash/fp/reduceRight" {
+  declare module.exports: $Exports<"lodash/fp">["reduceRight"];
+}
+
+declare module "lodash/fp/reject" {
+  declare module.exports: $Exports<"lodash/fp">["reject"];
+}
+
+declare module "lodash/fp/sample" {
+  declare module.exports: $Exports<"lodash/fp">["sample"];
+}
+
+declare module "lodash/fp/sampleSize" {
+  declare module.exports: $Exports<"lodash/fp">["sampleSize"];
+}
+
+declare module "lodash/fp/shuffle" {
+  declare module.exports: $Exports<"lodash/fp">["shuffle"];
+}
+
+declare module "lodash/fp/size" {
+  declare module.exports: $Exports<"lodash/fp">["size"];
+}
+
+declare module "lodash/fp/some" {
+  declare module.exports: $Exports<"lodash/fp">["some"];
+}
+
+declare module "lodash/fp/any" {
+  declare module.exports: $Exports<"lodash/fp">["any"];
+}
+
+declare module "lodash/fp/sortBy" {
+  declare module.exports: $Exports<"lodash/fp">["sortBy"];
+}
+
+declare module "lodash/fp/now" {
+  declare module.exports: $Exports<"lodash/fp">["now"];
+}
+
+declare module "lodash/fp/after" {
+  declare module.exports: $Exports<"lodash/fp">["after"];
+}
+
+declare module "lodash/fp/ary" {
+  declare module.exports: $Exports<"lodash/fp">["ary"];
+}
+
+declare module "lodash/fp/nAry" {
+  declare module.exports: $Exports<"lodash/fp">["nAry"];
+}
+
+declare module "lodash/fp/before" {
+  declare module.exports: $Exports<"lodash/fp">["before"];
+}
+
+declare module "lodash/fp/bind" {
+  declare module.exports: $Exports<"lodash/fp">["bind"];
+}
+
+declare module "lodash/fp/bindKey" {
+  declare module.exports: $Exports<"lodash/fp">["bindKey"];
+}
+
+declare module "lodash/fp/curry" {
+  declare module.exports: $Exports<"lodash/fp">["curry"];
+}
+
+declare module "lodash/fp/curryN" {
+  declare module.exports: $Exports<"lodash/fp">["curryN"];
+}
+
+declare module "lodash/fp/curryRight" {
+  declare module.exports: $Exports<"lodash/fp">["curryRight"];
+}
+
+declare module "lodash/fp/curryRightN" {
+  declare module.exports: $Exports<"lodash/fp">["curryRightN"];
+}
+
+declare module "lodash/fp/debounce" {
+  declare module.exports: $Exports<"lodash/fp">["debounce"];
+}
+
+declare module "lodash/fp/defer" {
+  declare module.exports: $Exports<"lodash/fp">["defer"];
+}
+
+declare module "lodash/fp/delay" {
+  declare module.exports: $Exports<"lodash/fp">["delay"];
+}
+
+declare module "lodash/fp/flip" {
+  declare module.exports: $Exports<"lodash/fp">["flip"];
+}
+
+declare module "lodash/fp/memoize" {
+  declare module.exports: $Exports<"lodash/fp">["memoize"];
+}
+
+declare module "lodash/fp/negate" {
+  declare module.exports: $Exports<"lodash/fp">["negate"];
+}
+
+declare module "lodash/fp/complement" {
+  declare module.exports: $Exports<"lodash/fp">["complement"];
+}
+
+declare module "lodash/fp/once" {
+  declare module.exports: $Exports<"lodash/fp">["once"];
+}
+
+declare module "lodash/fp/overArgs" {
+  declare module.exports: $Exports<"lodash/fp">["overArgs"];
+}
+
+declare module "lodash/fp/useWith" {
+  declare module.exports: $Exports<"lodash/fp">["useWith"];
+}
+
+declare module "lodash/fp/partial" {
+  declare module.exports: $Exports<"lodash/fp">["partial"];
+}
+
+declare module "lodash/fp/partialRight" {
+  declare module.exports: $Exports<"lodash/fp">["partialRight"];
+}
+
+declare module "lodash/fp/rearg" {
+  declare module.exports: $Exports<"lodash/fp">["rearg"];
+}
+
+declare module "lodash/fp/rest" {
+  declare module.exports: $Exports<"lodash/fp">["rest"];
+}
+
+declare module "lodash/fp/unapply" {
+  declare module.exports: $Exports<"lodash/fp">["unapply"];
+}
+
+declare module "lodash/fp/restFrom" {
+  declare module.exports: $Exports<"lodash/fp">["restFrom"];
+}
+
+declare module "lodash/fp/spread" {
+  declare module.exports: $Exports<"lodash/fp">["spread"];
+}
+
+declare module "lodash/fp/apply" {
+  declare module.exports: $Exports<"lodash/fp">["apply"];
+}
+
+declare module "lodash/fp/spreadFrom" {
+  declare module.exports: $Exports<"lodash/fp">["spreadFrom"];
+}
+
+declare module "lodash/fp/throttle" {
+  declare module.exports: $Exports<"lodash/fp">["throttle"];
+}
+
+declare module "lodash/fp/unary" {
+  declare module.exports: $Exports<"lodash/fp">["unary"];
+}
+
+declare module "lodash/fp/wrap" {
+  declare module.exports: $Exports<"lodash/fp">["wrap"];
+}
+
+declare module "lodash/fp/castArray" {
+  declare module.exports: $Exports<"lodash/fp">["castArray"];
+}
+
+declare module "lodash/fp/clone" {
+  declare module.exports: $Exports<"lodash/fp">["clone"];
+}
+
+declare module "lodash/fp/cloneDeep" {
+  declare module.exports: $Exports<"lodash/fp">["cloneDeep"];
+}
+
+declare module "lodash/fp/cloneDeepWith" {
+  declare module.exports: $Exports<"lodash/fp">["cloneDeepWith"];
+}
+
+declare module "lodash/fp/cloneWith" {
+  declare module.exports: $Exports<"lodash/fp">["cloneWith"];
+}
+
+declare module "lodash/fp/conformsTo" {
+  declare module.exports: $Exports<"lodash/fp">["conformsTo"];
+}
+
+declare module "lodash/fp/where" {
+  declare module.exports: $Exports<"lodash/fp">["where"];
+}
+
+declare module "lodash/fp/conforms" {
+  declare module.exports: $Exports<"lodash/fp">["conforms"];
+}
+
+declare module "lodash/fp/eq" {
+  declare module.exports: $Exports<"lodash/fp">["eq"];
+}
+
+declare module "lodash/fp/identical" {
+  declare module.exports: $Exports<"lodash/fp">["identical"];
+}
+
+declare module "lodash/fp/gt" {
+  declare module.exports: $Exports<"lodash/fp">["gt"];
+}
+
+declare module "lodash/fp/gte" {
+  declare module.exports: $Exports<"lodash/fp">["gte"];
+}
+
+declare module "lodash/fp/isArguments" {
+  declare module.exports: $Exports<"lodash/fp">["isArguments"];
+}
+
+declare module "lodash/fp/isArray" {
+  declare module.exports: $Exports<"lodash/fp">["isArray"];
+}
+
+declare module "lodash/fp/isArrayBuffer" {
+  declare module.exports: $Exports<"lodash/fp">["isArrayBuffer"];
+}
+
+declare module "lodash/fp/isArrayLike" {
+  declare module.exports: $Exports<"lodash/fp">["isArrayLike"];
+}
+
+declare module "lodash/fp/isArrayLikeObject" {
+  declare module.exports: $Exports<"lodash/fp">["isArrayLikeObject"];
+}
+
+declare module "lodash/fp/isBoolean" {
+  declare module.exports: $Exports<"lodash/fp">["isBoolean"];
+}
+
+declare module "lodash/fp/isBuffer" {
+  declare module.exports: $Exports<"lodash/fp">["isBuffer"];
+}
+
+declare module "lodash/fp/isDate" {
+  declare module.exports: $Exports<"lodash/fp">["isDate"];
+}
+
+declare module "lodash/fp/isElement" {
+  declare module.exports: $Exports<"lodash/fp">["isElement"];
+}
+
+declare module "lodash/fp/isEmpty" {
+  declare module.exports: $Exports<"lodash/fp">["isEmpty"];
+}
+
+declare module "lodash/fp/isEqual" {
+  declare module.exports: $Exports<"lodash/fp">["isEqual"];
+}
+
+declare module "lodash/fp/equals" {
+  declare module.exports: $Exports<"lodash/fp">["equals"];
+}
+
+declare module "lodash/fp/isEqualWith" {
+  declare module.exports: $Exports<"lodash/fp">["isEqualWith"];
+}
+
+declare module "lodash/fp/isError" {
+  declare module.exports: $Exports<"lodash/fp">["isError"];
+}
+
+declare module "lodash/fp/isFinite" {
+  declare module.exports: $Exports<"lodash/fp">["isFinite"];
+}
+
+declare module "lodash/fp/isFunction" {
+  declare module.exports: $Exports<"lodash/fp">["isFunction"];
+}
+
+declare module "lodash/fp/isInteger" {
+  declare module.exports: $Exports<"lodash/fp">["isInteger"];
+}
+
+declare module "lodash/fp/isLength" {
+  declare module.exports: $Exports<"lodash/fp">["isLength"];
+}
+
+declare module "lodash/fp/isMap" {
+  declare module.exports: $Exports<"lodash/fp">["isMap"];
+}
+
+declare module "lodash/fp/isMatch" {
+  declare module.exports: $Exports<"lodash/fp">["isMatch"];
+}
+
+declare module "lodash/fp/whereEq" {
+  declare module.exports: $Exports<"lodash/fp">["whereEq"];
+}
+
+declare module "lodash/fp/isMatchWith" {
+  declare module.exports: $Exports<"lodash/fp">["isMatchWith"];
+}
+
+declare module "lodash/fp/isNaN" {
+  declare module.exports: $Exports<"lodash/fp">["isNaN"];
+}
+
+declare module "lodash/fp/isNative" {
+  declare module.exports: $Exports<"lodash/fp">["isNative"];
+}
+
+declare module "lodash/fp/isNil" {
+  declare module.exports: $Exports<"lodash/fp">["isNil"];
+}
+
+declare module "lodash/fp/isNull" {
+  declare module.exports: $Exports<"lodash/fp">["isNull"];
+}
+
+declare module "lodash/fp/isNumber" {
+  declare module.exports: $Exports<"lodash/fp">["isNumber"];
+}
+
+declare module "lodash/fp/isObject" {
+  declare module.exports: $Exports<"lodash/fp">["isObject"];
+}
+
+declare module "lodash/fp/isObjectLike" {
+  declare module.exports: $Exports<"lodash/fp">["isObjectLike"];
+}
+
+declare module "lodash/fp/isPlainObject" {
+  declare module.exports: $Exports<"lodash/fp">["isPlainObject"];
+}
+
+declare module "lodash/fp/isRegExp" {
+  declare module.exports: $Exports<"lodash/fp">["isRegExp"];
+}
+
+declare module "lodash/fp/isSafeInteger" {
+  declare module.exports: $Exports<"lodash/fp">["isSafeInteger"];
+}
+
+declare module "lodash/fp/isSet" {
+  declare module.exports: $Exports<"lodash/fp">["isSet"];
+}
+
+declare module "lodash/fp/isString" {
+  declare module.exports: $Exports<"lodash/fp">["isString"];
+}
+
+declare module "lodash/fp/isSymbol" {
+  declare module.exports: $Exports<"lodash/fp">["isSymbol"];
+}
+
+declare module "lodash/fp/isTypedArray" {
+  declare module.exports: $Exports<"lodash/fp">["isTypedArray"];
+}
+
+declare module "lodash/fp/isUndefined" {
+  declare module.exports: $Exports<"lodash/fp">["isUndefined"];
+}
+
+declare module "lodash/fp/isWeakMap" {
+  declare module.exports: $Exports<"lodash/fp">["isWeakMap"];
+}
+
+declare module "lodash/fp/isWeakSet" {
+  declare module.exports: $Exports<"lodash/fp">["isWeakSet"];
+}
+
+declare module "lodash/fp/lt" {
+  declare module.exports: $Exports<"lodash/fp">["lt"];
+}
+
+declare module "lodash/fp/lte" {
+  declare module.exports: $Exports<"lodash/fp">["lte"];
+}
+
+declare module "lodash/fp/toArray" {
+  declare module.exports: $Exports<"lodash/fp">["toArray"];
+}
+
+declare module "lodash/fp/toFinite" {
+  declare module.exports: $Exports<"lodash/fp">["toFinite"];
+}
+
+declare module "lodash/fp/toInteger" {
+  declare module.exports: $Exports<"lodash/fp">["toInteger"];
+}
+
+declare module "lodash/fp/toLength" {
+  declare module.exports: $Exports<"lodash/fp">["toLength"];
+}
+
+declare module "lodash/fp/toNumber" {
+  declare module.exports: $Exports<"lodash/fp">["toNumber"];
+}
+
+declare module "lodash/fp/toPlainObject" {
+  declare module.exports: $Exports<"lodash/fp">["toPlainObject"];
+}
+
+declare module "lodash/fp/toSafeInteger" {
+  declare module.exports: $Exports<"lodash/fp">["toSafeInteger"];
+}
+
+declare module "lodash/fp/toString" {
+  declare module.exports: $Exports<"lodash/fp">["toString"];
+}
+
+declare module "lodash/fp/add" {
+  declare module.exports: $Exports<"lodash/fp">["add"];
+}
+
+declare module "lodash/fp/ceil" {
+  declare module.exports: $Exports<"lodash/fp">["ceil"];
+}
+
+declare module "lodash/fp/divide" {
+  declare module.exports: $Exports<"lodash/fp">["divide"];
+}
+
+declare module "lodash/fp/floor" {
+  declare module.exports: $Exports<"lodash/fp">["floor"];
+}
+
+declare module "lodash/fp/max" {
+  declare module.exports: $Exports<"lodash/fp">["max"];
+}
+
+declare module "lodash/fp/maxBy" {
+  declare module.exports: $Exports<"lodash/fp">["maxBy"];
+}
+
+declare module "lodash/fp/mean" {
+  declare module.exports: $Exports<"lodash/fp">["mean"];
+}
+
+declare module "lodash/fp/meanBy" {
+  declare module.exports: $Exports<"lodash/fp">["meanBy"];
+}
+
+declare module "lodash/fp/min" {
+  declare module.exports: $Exports<"lodash/fp">["min"];
+}
+
+declare module "lodash/fp/minBy" {
+  declare module.exports: $Exports<"lodash/fp">["minBy"];
+}
+
+declare module "lodash/fp/multiply" {
+  declare module.exports: $Exports<"lodash/fp">["multiply"];
+}
+
+declare module "lodash/fp/round" {
+  declare module.exports: $Exports<"lodash/fp">["round"];
+}
+
+declare module "lodash/fp/subtract" {
+  declare module.exports: $Exports<"lodash/fp">["subtract"];
+}
+
+declare module "lodash/fp/sum" {
+  declare module.exports: $Exports<"lodash/fp">["sum"];
+}
+
+declare module "lodash/fp/sumBy" {
+  declare module.exports: $Exports<"lodash/fp">["sumBy"];
+}
+
+declare module "lodash/fp/clamp" {
+  declare module.exports: $Exports<"lodash/fp">["clamp"];
+}
+
+declare module "lodash/fp/inRange" {
+  declare module.exports: $Exports<"lodash/fp">["inRange"];
+}
+
+declare module "lodash/fp/random" {
+  declare module.exports: $Exports<"lodash/fp">["random"];
+}
+
+declare module "lodash/fp/assign" {
+  declare module.exports: $Exports<"lodash/fp">["assign"];
+}
+
+declare module "lodash/fp/assignAll" {
+  declare module.exports: $Exports<"lodash/fp">["assignAll"];
+}
+
+declare module "lodash/fp/assignInAll" {
+  declare module.exports: $Exports<"lodash/fp">["assignInAll"];
+}
+
+declare module "lodash/fp/extendAll" {
+  declare module.exports: $Exports<"lodash/fp">["extendAll"];
+}
+
+declare module "lodash/fp/assignIn" {
+  declare module.exports: $Exports<"lodash/fp">["assignIn"];
+}
+
+declare module "lodash/fp/assignInWith" {
+  declare module.exports: $Exports<"lodash/fp">["assignInWith"];
+}
+
+declare module "lodash/fp/assignWith" {
+  declare module.exports: $Exports<"lodash/fp">["assignWith"];
+}
+
+declare module "lodash/fp/assignInAllWith" {
+  declare module.exports: $Exports<"lodash/fp">["assignInAllWith"];
+}
+
+declare module "lodash/fp/extendAllWith" {
+  declare module.exports: $Exports<"lodash/fp">["extendAllWith"];
+}
+
+declare module "lodash/fp/assignAllWith" {
+  declare module.exports: $Exports<"lodash/fp">["assignAllWith"];
+}
+
+declare module "lodash/fp/at" {
+  declare module.exports: $Exports<"lodash/fp">["at"];
+}
+
+declare module "lodash/fp/props" {
+  declare module.exports: $Exports<"lodash/fp">["props"];
+}
+
+declare module "lodash/fp/paths" {
+  declare module.exports: $Exports<"lodash/fp">["paths"];
+}
+
+declare module "lodash/fp/create" {
+  declare module.exports: $Exports<"lodash/fp">["create"];
+}
+
+declare module "lodash/fp/defaults" {
+  declare module.exports: $Exports<"lodash/fp">["defaults"];
+}
+
+declare module "lodash/fp/defaultsAll" {
+  declare module.exports: $Exports<"lodash/fp">["defaultsAll"];
+}
+
+declare module "lodash/fp/defaultsDeep" {
+  declare module.exports: $Exports<"lodash/fp">["defaultsDeep"];
+}
+
+declare module "lodash/fp/defaultsDeepAll" {
+  declare module.exports: $Exports<"lodash/fp">["defaultsDeepAll"];
+}
+
+declare module "lodash/fp/entries" {
+  declare module.exports: $Exports<"lodash/fp">["entries"];
+}
+
+declare module "lodash/fp/entriesIn" {
+  declare module.exports: $Exports<"lodash/fp">["entriesIn"];
+}
+
+declare module "lodash/fp/extend" {
+  declare module.exports: $Exports<"lodash/fp">["extend"];
+}
+
+declare module "lodash/fp/extendWith" {
+  declare module.exports: $Exports<"lodash/fp">["extendWith"];
+}
+
+declare module "lodash/fp/findKey" {
+  declare module.exports: $Exports<"lodash/fp">["findKey"];
+}
+
+declare module "lodash/fp/findLastKey" {
+  declare module.exports: $Exports<"lodash/fp">["findLastKey"];
+}
+
+declare module "lodash/fp/forIn" {
+  declare module.exports: $Exports<"lodash/fp">["forIn"];
+}
+
+declare module "lodash/fp/forInRight" {
+  declare module.exports: $Exports<"lodash/fp">["forInRight"];
+}
+
+declare module "lodash/fp/forOwn" {
+  declare module.exports: $Exports<"lodash/fp">["forOwn"];
+}
+
+declare module "lodash/fp/forOwnRight" {
+  declare module.exports: $Exports<"lodash/fp">["forOwnRight"];
+}
+
+declare module "lodash/fp/functions" {
+  declare module.exports: $Exports<"lodash/fp">["functions"];
+}
+
+declare module "lodash/fp/functionsIn" {
+  declare module.exports: $Exports<"lodash/fp">["functionsIn"];
+}
+
+declare module "lodash/fp/get" {
+  declare module.exports: $Exports<"lodash/fp">["get"];
+}
+
+declare module "lodash/fp/prop" {
+  declare module.exports: $Exports<"lodash/fp">["prop"];
+}
+
+declare module "lodash/fp/path" {
+  declare module.exports: $Exports<"lodash/fp">["path"];
+}
+
+declare module "lodash/fp/getOr" {
+  declare module.exports: $Exports<"lodash/fp">["getOr"];
+}
+
+declare module "lodash/fp/propOr" {
+  declare module.exports: $Exports<"lodash/fp">["propOr"];
+}
+
+declare module "lodash/fp/pathOr" {
+  declare module.exports: $Exports<"lodash/fp">["pathOr"];
+}
+
+declare module "lodash/fp/has" {
+  declare module.exports: $Exports<"lodash/fp">["has"];
+}
+
+declare module "lodash/fp/hasIn" {
+  declare module.exports: $Exports<"lodash/fp">["hasIn"];
+}
+
+declare module "lodash/fp/invert" {
+  declare module.exports: $Exports<"lodash/fp">["invert"];
+}
+
+declare module "lodash/fp/invertObj" {
+  declare module.exports: $Exports<"lodash/fp">["invertObj"];
+}
+
+declare module "lodash/fp/invertBy" {
+  declare module.exports: $Exports<"lodash/fp">["invertBy"];
+}
+
+declare module "lodash/fp/invoke" {
+  declare module.exports: $Exports<"lodash/fp">["invoke"];
+}
+
+declare module "lodash/fp/invokeArgs" {
+  declare module.exports: $Exports<"lodash/fp">["invokeArgs"];
+}
+
+declare module "lodash/fp/keys" {
+  declare module.exports: $Exports<"lodash/fp">["keys"];
+}
+
+declare module "lodash/fp/keysIn" {
+  declare module.exports: $Exports<"lodash/fp">["keysIn"];
+}
+
+declare module "lodash/fp/mapKeys" {
+  declare module.exports: $Exports<"lodash/fp">["mapKeys"];
+}
+
+declare module "lodash/fp/mapValues" {
+  declare module.exports: $Exports<"lodash/fp">["mapValues"];
+}
+
+declare module "lodash/fp/merge" {
+  declare module.exports: $Exports<"lodash/fp">["merge"];
+}
+
+declare module "lodash/fp/mergeAll" {
+  declare module.exports: $Exports<"lodash/fp">["mergeAll"];
+}
+
+declare module "lodash/fp/mergeWith" {
+  declare module.exports: $Exports<"lodash/fp">["mergeWith"];
+}
+
+declare module "lodash/fp/mergeAllWith" {
+  declare module.exports: $Exports<"lodash/fp">["mergeAllWith"];
+}
+
+declare module "lodash/fp/omit" {
+  declare module.exports: $Exports<"lodash/fp">["omit"];
+}
+
+declare module "lodash/fp/omitAll" {
+  declare module.exports: $Exports<"lodash/fp">["omitAll"];
+}
+
+declare module "lodash/fp/omitBy" {
+  declare module.exports: $Exports<"lodash/fp">["omitBy"];
+}
+
+declare module "lodash/fp/pick" {
+  declare module.exports: $Exports<"lodash/fp">["pick"];
+}
+
+declare module "lodash/fp/pickAll" {
+  declare module.exports: $Exports<"lodash/fp">["pickAll"];
+}
+
+declare module "lodash/fp/pickBy" {
+  declare module.exports: $Exports<"lodash/fp">["pickBy"];
+}
+
+declare module "lodash/fp/result" {
+  declare module.exports: $Exports<"lodash/fp">["result"];
+}
+
+declare module "lodash/fp/set" {
+  declare module.exports: $Exports<"lodash/fp">["set"];
+}
+
+declare module "lodash/fp/assoc" {
+  declare module.exports: $Exports<"lodash/fp">["assoc"];
+}
+
+declare module "lodash/fp/assocPath" {
+  declare module.exports: $Exports<"lodash/fp">["assocPath"];
+}
+
+declare module "lodash/fp/setWith" {
+  declare module.exports: $Exports<"lodash/fp">["setWith"];
+}
+
+declare module "lodash/fp/toPairs" {
+  declare module.exports: $Exports<"lodash/fp">["toPairs"];
+}
+
+declare module "lodash/fp/toPairsIn" {
+  declare module.exports: $Exports<"lodash/fp">["toPairsIn"];
+}
+
+declare module "lodash/fp/transform" {
+  declare module.exports: $Exports<"lodash/fp">["transform"];
+}
+
+declare module "lodash/fp/unset" {
+  declare module.exports: $Exports<"lodash/fp">["unset"];
+}
+
+declare module "lodash/fp/update" {
+  declare module.exports: $Exports<"lodash/fp">["update"];
+}
+
+declare module "lodash/fp/updateWith" {
+  declare module.exports: $Exports<"lodash/fp">["updateWith"];
+}
+
+declare module "lodash/fp/values" {
+  declare module.exports: $Exports<"lodash/fp">["values"];
+}
+
+declare module "lodash/fp/valuesIn" {
+  declare module.exports: $Exports<"lodash/fp">["valuesIn"];
+}
+
+declare module "lodash/fp/tap" {
+  declare module.exports: $Exports<"lodash/fp">["tap"];
+}
+
+declare module "lodash/fp/thru" {
+  declare module.exports: $Exports<"lodash/fp">["thru"];
+}
+
+declare module "lodash/fp/camelCase" {
+  declare module.exports: $Exports<"lodash/fp">["camelCase"];
+}
+
+declare module "lodash/fp/capitalize" {
+  declare module.exports: $Exports<"lodash/fp">["capitalize"];
+}
+
+declare module "lodash/fp/deburr" {
+  declare module.exports: $Exports<"lodash/fp">["deburr"];
+}
+
+declare module "lodash/fp/endsWith" {
+  declare module.exports: $Exports<"lodash/fp">["endsWith"];
+}
+
+declare module "lodash/fp/escape" {
+  declare module.exports: $Exports<"lodash/fp">["escape"];
+}
+
+declare module "lodash/fp/escapeRegExp" {
+  declare module.exports: $Exports<"lodash/fp">["escapeRegExp"];
+}
+
+declare module "lodash/fp/kebabCase" {
+  declare module.exports: $Exports<"lodash/fp">["kebabCase"];
+}
+
+declare module "lodash/fp/lowerCase" {
+  declare module.exports: $Exports<"lodash/fp">["lowerCase"];
+}
+
+declare module "lodash/fp/lowerFirst" {
+  declare module.exports: $Exports<"lodash/fp">["lowerFirst"];
+}
+
+declare module "lodash/fp/pad" {
+  declare module.exports: $Exports<"lodash/fp">["pad"];
+}
+
+declare module "lodash/fp/padChars" {
+  declare module.exports: $Exports<"lodash/fp">["padChars"];
+}
+
+declare module "lodash/fp/padEnd" {
+  declare module.exports: $Exports<"lodash/fp">["padEnd"];
+}
+
+declare module "lodash/fp/padCharsEnd" {
+  declare module.exports: $Exports<"lodash/fp">["padCharsEnd"];
+}
+
+declare module "lodash/fp/padStart" {
+  declare module.exports: $Exports<"lodash/fp">["padStart"];
+}
+
+declare module "lodash/fp/padCharsStart" {
+  declare module.exports: $Exports<"lodash/fp">["padCharsStart"];
+}
+
+declare module "lodash/fp/parseInt" {
+  declare module.exports: $Exports<"lodash/fp">["parseInt"];
+}
+
+declare module "lodash/fp/repeat" {
+  declare module.exports: $Exports<"lodash/fp">["repeat"];
+}
+
+declare module "lodash/fp/replace" {
+  declare module.exports: $Exports<"lodash/fp">["replace"];
+}
+
+declare module "lodash/fp/snakeCase" {
+  declare module.exports: $Exports<"lodash/fp">["snakeCase"];
+}
+
+declare module "lodash/fp/split" {
+  declare module.exports: $Exports<"lodash/fp">["split"];
+}
+
+declare module "lodash/fp/startCase" {
+  declare module.exports: $Exports<"lodash/fp">["startCase"];
+}
+
+declare module "lodash/fp/startsWith" {
+  declare module.exports: $Exports<"lodash/fp">["startsWith"];
+}
+
+declare module "lodash/fp/template" {
+  declare module.exports: $Exports<"lodash/fp">["template"];
+}
+
+declare module "lodash/fp/toLower" {
+  declare module.exports: $Exports<"lodash/fp">["toLower"];
+}
+
+declare module "lodash/fp/toUpper" {
+  declare module.exports: $Exports<"lodash/fp">["toUpper"];
+}
+
+declare module "lodash/fp/trim" {
+  declare module.exports: $Exports<"lodash/fp">["trim"];
+}
+
+declare module "lodash/fp/trimChars" {
+  declare module.exports: $Exports<"lodash/fp">["trimChars"];
+}
+
+declare module "lodash/fp/trimEnd" {
+  declare module.exports: $Exports<"lodash/fp">["trimEnd"];
+}
+
+declare module "lodash/fp/trimCharsEnd" {
+  declare module.exports: $Exports<"lodash/fp">["trimCharsEnd"];
+}
+
+declare module "lodash/fp/trimStart" {
+  declare module.exports: $Exports<"lodash/fp">["trimStart"];
+}
+
+declare module "lodash/fp/trimCharsStart" {
+  declare module.exports: $Exports<"lodash/fp">["trimCharsStart"];
+}
+
+declare module "lodash/fp/truncate" {
+  declare module.exports: $Exports<"lodash/fp">["truncate"];
+}
+
+declare module "lodash/fp/unescape" {
+  declare module.exports: $Exports<"lodash/fp">["unescape"];
+}
+
+declare module "lodash/fp/upperCase" {
+  declare module.exports: $Exports<"lodash/fp">["upperCase"];
+}
+
+declare module "lodash/fp/upperFirst" {
+  declare module.exports: $Exports<"lodash/fp">["upperFirst"];
+}
+
+declare module "lodash/fp/words" {
+  declare module.exports: $Exports<"lodash/fp">["words"];
+}
+
+declare module "lodash/fp/attempt" {
+  declare module.exports: $Exports<"lodash/fp">["attempt"];
+}
+
+declare module "lodash/fp/bindAll" {
+  declare module.exports: $Exports<"lodash/fp">["bindAll"];
+}
+
+declare module "lodash/fp/cond" {
+  declare module.exports: $Exports<"lodash/fp">["cond"];
+}
+
+declare module "lodash/fp/constant" {
+  declare module.exports: $Exports<"lodash/fp">["constant"];
+}
+
+declare module "lodash/fp/always" {
+  declare module.exports: $Exports<"lodash/fp">["always"];
+}
+
+declare module "lodash/fp/defaultTo" {
+  declare module.exports: $Exports<"lodash/fp">["defaultTo"];
+}
+
+declare module "lodash/fp/flow" {
+  declare module.exports: $Exports<"lodash/fp">["flow"];
+}
+
+declare module "lodash/fp/pipe" {
+  declare module.exports: $Exports<"lodash/fp">["pipe"];
+}
+
+declare module "lodash/fp/flowRight" {
+  declare module.exports: $Exports<"lodash/fp">["flowRight"];
+}
+
+declare module "lodash/fp/compose" {
+  declare module.exports: $Exports<"lodash/fp">["compose"];
+}
+
+declare module "lodash/fp/identity" {
+  declare module.exports: $Exports<"lodash/fp">["identity"];
+}
+
+declare module "lodash/fp/iteratee" {
+  declare module.exports: $Exports<"lodash/fp">["iteratee"];
+}
+
+declare module "lodash/fp/matches" {
+  declare module.exports: $Exports<"lodash/fp">["matches"];
+}
+
+declare module "lodash/fp/matchesProperty" {
+  declare module.exports: $Exports<"lodash/fp">["matchesProperty"];
+}
+
+declare module "lodash/fp/propEq" {
+  declare module.exports: $Exports<"lodash/fp">["propEq"];
+}
+
+declare module "lodash/fp/pathEq" {
+  declare module.exports: $Exports<"lodash/fp">["pathEq"];
+}
+
+declare module "lodash/fp/method" {
+  declare module.exports: $Exports<"lodash/fp">["method"];
+}
+
+declare module "lodash/fp/methodOf" {
+  declare module.exports: $Exports<"lodash/fp">["methodOf"];
+}
+
+declare module "lodash/fp/mixin" {
+  declare module.exports: $Exports<"lodash/fp">["mixin"];
+}
+
+declare module "lodash/fp/noConflict" {
+  declare module.exports: $Exports<"lodash/fp">["noConflict"];
+}
+
+declare module "lodash/fp/noop" {
+  declare module.exports: $Exports<"lodash/fp">["noop"];
+}
+
+declare module "lodash/fp/nthArg" {
+  declare module.exports: $Exports<"lodash/fp">["nthArg"];
+}
+
+declare module "lodash/fp/over" {
+  declare module.exports: $Exports<"lodash/fp">["over"];
+}
+
+declare module "lodash/fp/juxt" {
+  declare module.exports: $Exports<"lodash/fp">["juxt"];
+}
+
+declare module "lodash/fp/overEvery" {
+  declare module.exports: $Exports<"lodash/fp">["overEvery"];
+}
+
+declare module "lodash/fp/allPass" {
+  declare module.exports: $Exports<"lodash/fp">["allPass"];
+}
+
+declare module "lodash/fp/overSome" {
+  declare module.exports: $Exports<"lodash/fp">["overSome"];
+}
+
+declare module "lodash/fp/anyPass" {
+  declare module.exports: $Exports<"lodash/fp">["anyPass"];
+}
+
+declare module "lodash/fp/property" {
+  declare module.exports: $Exports<"lodash/fp">["property"];
+}
+
+declare module "lodash/fp/propertyOf" {
+  declare module.exports: $Exports<"lodash/fp">["propertyOf"];
+}
+
+declare module "lodash/fp/range" {
+  declare module.exports: $Exports<"lodash/fp">["range"];
+}
+
+declare module "lodash/fp/rangeStep" {
+  declare module.exports: $Exports<"lodash/fp">["rangeStep"];
+}
+
+declare module "lodash/fp/rangeRight" {
+  declare module.exports: $Exports<"lodash/fp">["rangeRight"];
+}
+
+declare module "lodash/fp/rangeStepRight" {
+  declare module.exports: $Exports<"lodash/fp">["rangeStepRight"];
+}
+
+declare module "lodash/fp/runInContext" {
+  declare module.exports: $Exports<"lodash/fp">["runInContext"];
+}
+
+declare module "lodash/fp/stubArray" {
+  declare module.exports: $Exports<"lodash/fp">["stubArray"];
+}
+
+declare module "lodash/fp/stubFalse" {
+  declare module.exports: $Exports<"lodash/fp">["stubFalse"];
+}
+
+declare module "lodash/fp/F" {
+  declare module.exports: $Exports<"lodash/fp">["F"];
+}
+
+declare module "lodash/fp/stubObject" {
+  declare module.exports: $Exports<"lodash/fp">["stubObject"];
+}
+
+declare module "lodash/fp/stubString" {
+  declare module.exports: $Exports<"lodash/fp">["stubString"];
+}
+
+declare module "lodash/fp/stubTrue" {
+  declare module.exports: $Exports<"lodash/fp">["stubTrue"];
+}
+
+declare module "lodash/fp/T" {
+  declare module.exports: $Exports<"lodash/fp">["T"];
+}
+
+declare module "lodash/fp/times" {
+  declare module.exports: $Exports<"lodash/fp">["times"];
+}
+
+declare module "lodash/fp/toPath" {
+  declare module.exports: $Exports<"lodash/fp">["toPath"];
+}
+
+declare module "lodash/fp/uniqueId" {
+  declare module.exports: $Exports<"lodash/fp">["uniqueId"];
+}
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js
new file mode 100644
index 0000000000..ea4bb02dd4
--- /dev/null
+++ b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_does-not-fail-on-null-v4.x.x.js
@@ -0,0 +1,518 @@
+// @flow
+import assign from "lodash/assign";
+import assignIn from "lodash/assignIn";
+import assignWith from "lodash/assignWith";
+import at from "lodash/at";
+import bindAll from "lodash/bindAll";
+import bindKey from "lodash/bindKey";
+import castArray from "lodash/castArray";
+import chain from "lodash/chain";
+import chunk from "lodash/chunk";
+import compact from "lodash/compact";
+import concat from "lodash/concat";
+import cond from "lodash/cond";
+import conforms from "lodash/conforms";
+import constant from "lodash/constant";
+import countBy from "lodash/countBy";
+import create from "lodash/create";
+import defaults from "lodash/defaults";
+import defaultsDeep from "lodash/defaultsDeep";
+import difference from "lodash/difference";
+import differenceBy from "lodash/differenceBy";
+import differenceWith from "lodash/differenceWith";
+import drop from "lodash/drop";
+import dropRight from "lodash/dropRight";
+import dropRightWhile from "lodash/dropRightWhile";
+import dropWhile from "lodash/dropWhile";
+import fill from "lodash/fill";
+import filter from "lodash/filter";
+import flatMap from "lodash/flatMap";
+import flatMapDeep from "lodash/flatMapDeep";
+import flatMapDepth from "lodash/flatMapDepth";
+import flatten from "lodash/flatten";
+import flattenDeep from "lodash/flattenDeep";
+import flattenDepth from "lodash/flattenDepth";
+import flow from "lodash/flow";
+import flowRight from "lodash/flowRight";
+import fromPairs from "lodash/fromPairs";
+import functions from "lodash/functions";
+import functionsIn from "lodash/functionsIn";
+import groupBy from "lodash/groupBy";
+import initial from "lodash/initial";
+import intersection from "lodash/intersection";
+import intersectionBy from "lodash/intersectionBy";
+import invert from "lodash/invert";
+import invertBy from "lodash/invertBy";
+import invokeMap from "lodash/invokeMap";
+import iteratee from "lodash/iteratee";
+import keyBy from "lodash/keyBy";
+import keys from "lodash/keys";
+import keysIn from "lodash/keysIn";
+import map from "lodash/map";
+import mapKeys from "lodash/mapKeys";
+import mapValues from "lodash/mapValues";
+import matches from "lodash/matches";
+import matchesProperty from "lodash/matchesProperty";
+import merge from "lodash/merge";
+import mergeWith from "lodash/mergeWith";
+import method from "lodash/method";
+import methodOf from "lodash/methodOf";
+import nthArg from "lodash/nthArg";
+import omit from "lodash/omit";
+import omitBy from "lodash/omitBy";
+import orderBy from "lodash/orderBy";
+import over from "lodash/over";
+import overArgs from "lodash/overArgs";
+import overEvery from "lodash/overEvery";
+import overSome from "lodash/overSome";
+import partition from "lodash/partition";
+import pick from "lodash/pick";
+import pickBy from "lodash/pickBy";
+import property from "lodash/property";
+import propertyOf from "lodash/propertyOf";
+import pull from "lodash/pull";
+import pullAll from "lodash/pullAll";
+import pullAllBy from "lodash/pullAllBy";
+import pullAllWith from "lodash/pullAllWith";
+import pullAt from "lodash/pullAt";
+import rangeRight from "lodash/rangeRight";
+import reject from "lodash/reject";
+import remove from "lodash/remove";
+import reverse from "lodash/reverse";
+import sampleSize from "lodash/sampleSize";
+import set from "lodash/set";
+import setWith from "lodash/setWith";
+import shuffle from "lodash/shuffle";
+import slice from "lodash/slice";
+import sortBy from "lodash/sortBy";
+import sortedUniq from "lodash/sortedUniq";
+import sortedUniqBy from "lodash/sortedUniqBy";
+import split from "lodash/split";
+import tail from "lodash/tail";
+import take from "lodash/take";
+import takeRight from "lodash/takeRight";
+import takeRightWhile from "lodash/takeRightWhile";
+import takeWhile from "lodash/takeWhile";
+import toArray from "lodash/toArray";
+import toPairs from "lodash/toPairs";
+import toPairsIn from "lodash/toPairsIn";
+import toPath from "lodash/toPath";
+import toPlainObject from "lodash/toPlainObject";
+import transform from "lodash/transform";
+import union from "lodash/union";
+import unionBy from "lodash/unionBy";
+import unionWith from "lodash/unionWith";
+import uniq from "lodash/uniq";
+import uniqBy from "lodash/uniqBy";
+import uniqWith from "lodash/uniqWith";
+import unset from "lodash/unset";
+import unzip from "lodash/unzip";
+import unzipWith from "lodash/unzipWith";
+import update from "lodash/update";
+import updateWith from "lodash/updateWith";
+import values from "lodash/values";
+import valuesIn from "lodash/valuesIn";
+import without from "lodash/without";
+import words from "lodash/words";
+import wrap from "lodash/wrap";
+import xor from "lodash/xor";
+import xorBy from "lodash/xorBy";
+import xorWith from "lodash/xorWith";
+import zip from "lodash/zip";
+import zipObject from "lodash/zipObject";
+import zipObjectDeep from "lodash/zipObjectDeep";
+import zipWith from "lodash/zipWith";
+import entries from "lodash/entries";
+import entriesIn from "lodash/entriesIn";
+import extend from "lodash/extend";
+import extendWith from "lodash/extendWith";
+import camelCase from "lodash/camelCase";
+import capitalize from "lodash/capitalize";
+import clamp from "lodash/clamp";
+import clone from "lodash/clone";
+import cloneDeep from "lodash/cloneDeep";
+import cloneDeepWith from "lodash/cloneDeepWith";
+import cloneWith from "lodash/cloneWith";
+import deburr from "lodash/deburr";
+import defaultTo from "lodash/defaultTo";
+import endsWith from "lodash/endsWith";
+import eq from "lodash/eq";
+import escape from "lodash/escape";
+import escapeRegExp from "lodash/escapeRegExp";
+import find from "lodash/find";
+import findIndex from "lodash/findIndex";
+import findKey from "lodash/findKey";
+import findLast from "lodash/findLast";
+import findLastIndex from "lodash/findLastIndex";
+import findLastKey from "lodash/findLastKey";
+import forEach from "lodash/forEach";
+import forEachRight from "lodash/forEachRight";
+import forIn from "lodash/forIn";
+import forInRight from "lodash/forInRight";
+import forOwn from "lodash/forOwn";
+import forOwnRight from "lodash/forOwnRight";
+import get from "lodash/get";
+import gt from "lodash/gt";
+import gte from "lodash/gte";
+import has from "lodash/has";
+import hasIn from "lodash/hasIn";
+import head from "lodash/head";
+import identity from "lodash/identity";
+import includes from "lodash/includes";
+import indexOf from "lodash/indexOf";
+import invoke from "lodash/invoke";
+import isArguments from "lodash/isArguments";
+import isArray from "lodash/isArray";
+import isArrayBuffer from "lodash/isArrayBuffer";
+import isArrayLike from "lodash/isArrayLike";
+import isArrayLikeObject from "lodash/isArrayLikeObject";
+import isBoolean from "lodash/isBoolean";
+import isBuffer from "lodash/isBuffer";
+import isDate from "lodash/isDate";
+import isElement from "lodash/isElement";
+import isEmpty from "lodash/isEmpty";
+import isEqual from "lodash/isEqual";
+import isEqualWith from "lodash/isEqualWith";
+import isError from "lodash/isError";
+import isFinite from "lodash/isFinite";
+import isFunction from "lodash/isFunction";
+import isInteger from "lodash/isInteger";
+import isLength from "lodash/isLength";
+import isMap from "lodash/isMap";
+import isMatch from "lodash/isMatch";
+import isMatchWith from "lodash/isMatchWith";
+import isNaN from "lodash/isNaN";
+import isNative from "lodash/isNative";
+import isNil from "lodash/isNil";
+import isNull from "lodash/isNull";
+import isNumber from "lodash/isNumber";
+import isObject from "lodash/isObject";
+import isObjectLike from "lodash/isObjectLike";
+import isPlainObject from "lodash/isPlainObject";
+import isRegExp from "lodash/isRegExp";
+import isSafeInteger from "lodash/isSafeInteger";
+import isSet from "lodash/isSet";
+import isString from "lodash/isString";
+import isSymbol from "lodash/isSymbol";
+import isTypedArray from "lodash/isTypedArray";
+import isUndefined from "lodash/isUndefined";
+import isWeakMap from "lodash/isWeakMap";
+import isWeakSet from "lodash/isWeakSet";
+import join from "lodash/join";
+import kebabCase from "lodash/kebabCase";
+import last from "lodash/last";
+import lastIndexOf from "lodash/lastIndexOf";
+import lowerCase from "lodash/lowerCase";
+import lowerFirst from "lodash/lowerFirst";
+import lt from "lodash/lt";
+import lte from "lodash/lte";
+import max from "lodash/max";
+import min from "lodash/min";
+import stubArray from "lodash/stubArray";
+import stubFalse from "lodash/stubFalse";
+import stubObject from "lodash/stubObject";
+import stubString from "lodash/stubString";
+import stubTrue from "lodash/stubTrue";
+import nth from "lodash/nth";
+import noop from "lodash/noop";
+import now from "lodash/now";
+import pad from "lodash/pad";
+import padEnd from "lodash/padEnd";
+import padStart from "lodash/padStart";
+import reduce from "lodash/reduce";
+import reduceRight from "lodash/reduceRight";
+import repeat from "lodash/repeat";
+import replace from "lodash/replace";
+import result from "lodash/result";
+import runInContext from "lodash/runInContext";
+import sample from "lodash/sample";
+import snakeCase from "lodash/snakeCase";
+import some from "lodash/some";
+import sortedIndex from "lodash/sortedIndex";
+import sortedIndexBy from "lodash/sortedIndexBy";
+import sortedIndexOf from "lodash/sortedIndexOf";
+import sortedLastIndex from "lodash/sortedLastIndex";
+import sortedLastIndexBy from "lodash/sortedLastIndexBy";
+import sortedLastIndexOf from "lodash/sortedLastIndexOf";
+import startCase from "lodash/startCase";
+import startsWith from "lodash/startsWith";
+import template from "lodash/template";
+import times from "lodash/times";
+import toFinite from "lodash/toFinite";
+import toInteger from "lodash/toInteger";
+import toLength from "lodash/toLength";
+import toLower from "lodash/toLower";
+import toNumber from "lodash/toNumber";
+import toSafeInteger from "lodash/toSafeInteger";
+import toString from "lodash/toString";
+import toUpper from "lodash/toUpper";
+import trim from "lodash/trim";
+import trimEnd from "lodash/trimEnd";
+import trimStart from "lodash/trimStart";
+import truncate from "lodash/truncate";
+import unescape from "lodash/unescape";
+import uniqueId from "lodash/uniqueId";
+import upperCase from "lodash/upperCase";
+import upperFirst from "lodash/upperFirst";
+import each from "lodash/each";
+import eachRight from "lodash/eachRight";
+import first from "lodash/first";
+
+(assign(): {...});
+(assignIn(): {...});
+(assignWith(): {...});
+(at(): Array<any>);
+(bindAll(): void);
+(bindKey(): Function);
+(castArray(): Array<any>);
+(chain(null): null);
+(chunk(null, null): Array<any>);
+(compact(null): Array<any>);
+(concat(): Array<any>);
+(cond(null): Function);
+(conforms(null): Function);
+(constant(null): Function);
+(countBy(null, null): {...});
+(create(null, null): {...});
+(defaults(): {...});
+(defaultsDeep(): {...});
+(difference(): Array<any>);
+(differenceBy(): Array<any>);
+(differenceWith(): Array<any>);
+(drop(null, null): Array<any>);
+(dropRight(null, null): Array<any>);
+(dropRightWhile(null, null): Array<any>);
+(dropWhile(null, null): Array<any>);
+(fill(null, null, null, null): Array<any>);
+(filter(null, null): Array<any>);
+(flatMap(null, null): Array<any>);
+(flatMapDeep(null, null): Array<any>);
+(flatMapDepth(null, null, null): Array<any>);
+(flatten(null): Array<any>);
+(flattenDeep(null): Array<any>);
+(flattenDepth(null, null): Array<any>);
+(flow(): Function);
+(flowRight(): Function);
+(fromPairs(null): {...});
+(functions(null): Array<any>);
+(functionsIn(null): Array<any>);
+(groupBy(null, null): {...});
+(initial(null): Array<any>);
+(intersection(): Array<any>);
+(intersectionBy(): Array<any>);
+(invert(null, null): {...});
+(invertBy(null, null): {...});
+(invokeMap(): Array<any>);
+(iteratee(null): Function);
+(keyBy(null, null): {...});
+(keys(null): Array<any>);
+(keysIn(null): Array<any>);
+(map(null, null): Array<any>);
+(mapKeys(null, null): {...});
+(mapValues(null, null): {...});
+(matches(null): Function);
+(matchesProperty(null, null): Function);
+(merge(): {...});
+(mergeWith(): {...});
+(method(): Function);
+(methodOf(): Function);
+(nthArg(null): Function);
+(omit(): {...});
+(omitBy(null, null): {...});
+(orderBy(null, null, null): Array<any>);
+(over(): Function);
+(overArgs(): Function);
+(overEvery(): Function);
+(overSome(): Function);
+(partition(null, null): [Array<any>,Array<any>]);
+(pick(): {...});
+(pickBy(null, null): {...});
+(property(null): Function);
+(propertyOf(null): Function);
+(pull(): void);
+(pullAll(null, null): null);
+(pullAllBy(null, null, null): null);
+(pullAllWith(null, null, null): null);
+(pullAt(): Array<any>);
+(rangeRight(null, null, null): Array<any>);
+(reject(null, null): Array<any>);
+(remove(null, null): Array<any>);
+(reverse(null): null);
+(sampleSize(null, null): Array<any>);
+(set(null, null, null): null);
+(setWith(null, null, null, null): null);
+(shuffle(null): Array<any>);
+(slice(null, null, null): Array<any>);
+(sortBy(): Array<any>);
+(sortedUniq(null): Array<any>);
+(sortedUniqBy(null, null): Array<any>);
+(split(null, null, null): Array<any>);
+(tail(null): Array<any>);
+(take(null, null): Array<any>);
+(takeRight(null, null): Array<any>);
+(takeRightWhile(null, null): Array<any>);
+(takeWhile(null, null): Array<any>);
+(toArray(null): Array<any>);
+(toPairs(null): Array<any>);
+(toPairsIn(null): Array<any>);
+(toPath(null): Array<any>);
+(toPlainObject(null): {...});
+(transform(null, null, null): {...});
+(union(): Array<any>);
+(unionBy(): Array<any>);
+(unionWith(): Array<any>);
+(uniq(null): Array<any>);
+(uniqBy(null, null): Array<any>);
+(uniqWith(null, null): Array<any>);
+(unset(null, null): true);
+(unzip(null): Array<any>);
+(unzipWith(null, null): Array<any>);
+(update(null, null, null): null);
+(updateWith(null, null, null, null): null);
+(values(null): Array<any>);
+(valuesIn(null): Array<any>);
+(without(): Array<any>);
+(words(null, null): Array<any>);
+(wrap(null, null): Function);
+(xor(): Array<any>);
+(xorBy(): Array<any>);
+(xorWith(): Array<any>);
+(zip(): Array<any>);
+(zipObject(null, null): {...});
+(zipObjectDeep(null, null): {...});
+(zipWith(): Array<any>);
+(entries(null): Array<any>);
+(entriesIn(null): Array<any>);
+(extend(): Object);
+(extendWith(): Object);
+(camelCase(null): '');
+(capitalize(null): '');
+(clamp(null, null, null): 0);
+(clone(null): null);
+(cloneDeep(null): null);
+(cloneDeepWith(null, null): null);
+(cloneWith(null, null): null);
+(deburr(null): '');
+(defaultTo(null, null): null);
+(endsWith(null, null, null): false);
+(eq(null, null): boolean);
+(escape(null): '');
+(escapeRegExp(null): '');
+(find(null, null, null): void);
+(findIndex(null, null, null): -1);
+(findKey(null, null): void);
+(findLast(null, null, null): void);
+(findLastIndex(null, null, null): -1);
+(findLastKey(null, null): void);
+(forEach(null, null): null);
+(forEachRight(null, null): null);
+(forIn(null, null): null);
+(forInRight(null, null): null);
+(forOwn(null, null): null);
+(forOwnRight(null, null): null);
+(get(null, null, null): null);
+(gt(null, null): boolean);
+(gte(null, null): boolean);
+(has(null, null): false);
+(hasIn(null, null): false);
+(head(null): void);
+(identity(null): null);
+(includes(null, null, null): false);
+(indexOf(null, null, null): -1);
+(invoke(): void);
+(isArguments(null): false);
+(isArray(null): false);
+(isArrayBuffer(null): false);
+(isArrayLike(null): false);
+(isArrayLikeObject(null): false);
+(isBoolean(null): false);
+(isBuffer(): false);
+(isDate(null): false);
+(isElement(null): false);
+(isEmpty(null): true);
+(isEqual(null, null): boolean);
+(isEqualWith(null, null, null): boolean);
+(isError(null): false);
+(isFinite(null): false);
+(isFunction(null): boolean);
+(isInteger(null): false);
+(isLength(null): false);
+(isMap(null): false);
+(isMatch(null, null): boolean);
+(isMatchWith(null, null, null): boolean);
+(isNaN(null): false);
+(isNative(null): false);
+(isNil(null): true);
+(isNull(null): true);
+(isNumber(null): false);
+(isObject(null): boolean);
+(isObjectLike(null): false);
+(isPlainObject(null): boolean);
+(isRegExp(null): false);
+(isSafeInteger(null): false);
+(isSet(null): false);
+(isString(null): false);
+(isSymbol(null): false);
+(isTypedArray(null): false);
+(isUndefined(null): false);
+(isWeakMap(null): false);
+(isWeakSet(null): false);
+(join(null, null): '');
+(kebabCase(null): '');
+(last(null): void);
+(lastIndexOf(null, null, null): -1);
+(lowerCase(null): '');
+(lowerFirst(null): '');
+(lt(null, null): boolean);
+(lte(null, null): boolean);
+(max(null): void);
+(min(null): void);
+(stubArray(): Array<any>);
+(stubFalse(): false);
+(stubObject(): {...});
+(stubString(): '');
+(stubTrue(): true);
+(nth(null, null): void);
+(noop(): void);
+(now(): number);
+(pad(null, null, null): string);
+(padEnd(null, null, null): string);
+(padStart(null, null, null): string);
+(reduce(null, null): void | null);
+(reduceRight(null, null): void | null);
+(repeat(null, null): '');
+(replace(): '');
+(result(null, null, null): null);
+(runInContext(null): Function);
+(sample(null): void);
+(snakeCase(null): '');
+(some(null, null): false);
+(sortedIndex(null, null): 0);
+(sortedIndexBy(null, null, null): 0);
+(sortedIndexOf(null, null): -1);
+(sortedLastIndex(null, null): 0);
+(sortedLastIndexBy(null, null, null): 0);
+(sortedLastIndexOf(null, null): -1);
+(startCase(null): '');
+(startsWith(null, null, null): false);
+(template(null, null): Function);
+(times(null, null): Array<any>);
+(toFinite(null): 0);
+(toInteger(null): 0);
+(toLength(null): 0);
+(toLower(null): '');
+(toNumber(null): 0);
+(toSafeInteger(null): 0);
+(toString(null): '');
+(toUpper(null): '');
+(trim(null, null): '');
+(trimEnd(null, null): '');
+(trimStart(null, null): '');
+(truncate(null, null): '');
+(unescape(null): '');
+(uniqueId(null): string);
+(upperCase(null): '');
+(upperFirst(null): '');
+(each(null, null): null);
+(eachRight(null, null): null);
+(first(null): void);
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js
new file mode 100644
index 0000000000..d2cebb3299
--- /dev/null
+++ b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_fails-on-null-v4.x.x.js
@@ -0,0 +1,72 @@
+// @flow
+import debounce from "lodash/debounce";
+import memoize from "lodash/memoize";
+import tap from "lodash/tap";
+import thru from "lodash/thru";
+import after from "lodash/after";
+import ary from "lodash/ary";
+import before from "lodash/before";
+import bind from "lodash/bind";
+import curry from "lodash/curry";
+import curryRight from "lodash/curryRight";
+import defer from "lodash/defer";
+import delay from "lodash/delay";
+import flip from "lodash/flip";
+import negate from "lodash/negate";
+import partial from "lodash/partial";
+import once from "lodash/once";
+import partialRight from "lodash/partialRight";
+import rearg from "lodash/rearg";
+import rest from "lodash/rest";
+import spread from "lodash/spread";
+import throttle from "lodash/throttle";
+import unary from "lodash/unary";
+// These tests are generated with modified script from this issue:
+// https://github.com/flowtype/flow-typed/issues/1639
+
+//$FlowExpectedError[incompatible-call]
+after(null, null);
+//$FlowExpectedError[extra-arg]
+//$FlowExpectedError[incompatible-call]
+ary(null, null, null);
+//$FlowExpectedError[incompatible-call]
+before(null, null);
+//$FlowExpectedError[incompatible-call]
+bind();
+//$FlowExpectedError[incompatible-call]
+curry(null, null, null);
+//$FlowExpectedError[extra-arg]
+//$FlowExpectedError[incompatible-call]
+curryRight(null, null, null);
+//$FlowExpectedError[incompatible-call]
+debounce(null, null, null);
+//$FlowExpectedError[incompatible-call]
+defer();
+//$FlowExpectedError[incompatible-call]
+delay();
+//$FlowExpectedError[incompatible-call]
+flip(null);
+//$FlowExpectedError[incompatible-call]
+memoize(null, null);
+//$FlowExpectedError[incompatible-call]
+negate(null);
+//$FlowExpectedError[incompatible-call]
+once(null);
+//$FlowExpectedError[incompatible-call]
+partial(null, null);
+//$FlowExpectedError[incompatible-call]
+partialRight(null, null);
+//$FlowExpectedError[incompatible-call]
+rearg(null, null);
+//$FlowExpectedError[incompatible-call]
+rest(null, null);
+//$FlowExpectedError[extra-arg]
+spread(null, null);
+//$FlowExpectedError[incompatible-call]
+tap(null, null);
+//$FlowExpectedError[incompatible-call]
+throttle(null, null, null);
+//$FlowExpectedError[incompatible-call]
+thru(null, null);
+//$FlowExpectedError[incompatible-call]
+unary(null);
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-fp-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-fp-v4.x.x.js
new file mode 100644
index 0000000000..31479e662f
--- /dev/null
+++ b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-fp-v4.x.x.js
@@ -0,0 +1,499 @@
+// @flow
+
+import assignIn from "lodash/fp/assignIn";
+import extend from "lodash/fp/extend";
+import sortedLastIndexBy from "lodash/fp/sortedLastIndexBy";
+import sortedIndexBy from "lodash/fp/sortedIndexBy";
+import sortedUniq from "lodash/fp/sortedUniq";
+import sortedUniqBy from "lodash/fp/sortedUniqBy";
+import range from "lodash/fp/range";
+import isEqual from "lodash/fp/isEqual";
+import clone from "lodash/fp/clone";
+import uniqBy from "lodash/fp/uniqBy";
+import unionBy from "lodash/fp/unionBy";
+import pullAllBy from "lodash/fp/pullAllBy";
+import map from "lodash/fp/map";
+import keyBy from "lodash/fp/keyBy";
+import getOr from "lodash/fp/getOr";
+import get from "lodash/fp/get";
+import intersectionBy from "lodash/fp/intersectionBy";
+import groupBy from "lodash/fp/groupBy";
+import findFrom from "lodash/fp/findFrom";
+import find from "lodash/fp/find";
+import differenceBy from "lodash/fp/differenceBy";
+import countBy from "lodash/fp/countBy";
+import attempt from "lodash/fp/attempt";
+import filter from "lodash/fp/filter";
+import xorBy from "lodash/fp/xorBy";
+import zip from "lodash/fp/zip";
+import isString from "lodash/fp/isString";
+import concat from "lodash/fp/concat";
+import first from "lodash/fp/first";
+import conformsTo from "lodash/fp/conformsTo";
+import defaultTo from "lodash/fp/defaultTo";
+import tap from "lodash/fp/tap";
+import thru from "lodash/fp/thru";
+import times from "lodash/fp/times";
+import flatMap from "lodash/fp/flatMap";
+import noop from "lodash/fp/noop";
+import pipe from "lodash/fp/pipe";
+import compose from "lodash/fp/compose";
+import includes from "lodash/fp/includes";
+import pick from "lodash/fp/pick";
+
+/**
+ * filter
+ */
+filter("x", [{ x: 1 }, { x: 2 }]);
+filter("x")([{ x: 1 }, { x: 2 }]);
+filter("x", { a: { x: 1 }, b: { x: 2 } });
+filter("x")({ a: { x: 1 }, b: { x: 2 } });
+filter((v: { y?: number, ... }) => v.y)({ a: { x: 1 }, b: { x: 2 } })[0].x;
+// $FlowExpectedError[incompatible-call]
+filter((v: { y: number, ... }) => v.y)({ a: { x: 1 }, b: { x: 2 } });
+
+/**
+ * attempt
+ */
+attempt(() => void 0);
+attempt(x => x);
+attempt((x, y, z) => {});
+
+/**
+ * countBy
+ */
+countBy(Math.floor, [6.1, 4.2, 6.3]);
+countBy("length", ["one", "two", "three"]);
+countBy("length")(["one", "two", "three"]);
+countBy("length")({ one: "one", two: "two", three: "three" });
+
+/**
+ * differenceBy
+ */
+differenceBy(Math.floor, ([2.1, 1.2]: $ReadOnlyArray<any>), [2.3, 3.4]);
+differenceBy("x", [{ x: 2 }, { x: 1 }], [{ x: 1 }]);
+differenceBy("x")([{ x: 2 }, { x: 1 }], [{ x: 1 }]);
+
+/**
+ * find
+ */
+find(x => x * 1 == 3, [1, 2, 3]);
+findFrom(x => x == 2, 1, [1, 2, 3]);
+// $FlowExpectedError[invalid-compare] number cannot be compared to string
+find(x => x == "a", [1, 2, 3]);
+// $FlowExpectedError[incompatible-call] number. This type is incompatible with function type.
+find(1, [1, 2, 3]);
+// $FlowExpectedError[prop-missing] property `y`. Property not found in object literal
+find(v => v.y == 3, [{ x: 1 }, { x: 2 }, { x: 3 }]);
+find(v => v.x == 3, [{ x: 1 }, { x: 2 }, { x: 3 }]);
+find((a: number, b: string) => a, { x: 1, y: 2 });
+find({ x: 3 }, { x: 1, y: 2 });
+find({ x: 3 })({ x: 1, y: 2 });
+
+// $FlowExpectedError[incompatible-call] undefined. This type is incompatible with object type.
+var result: Object = find("active", users);
+
+/**
+ * find examples from the official doc
+ */
+var users = [
+  { user: "barney", age: 36, active: true },
+  { user: "fred", age: 40, active: false },
+  { user: "pebbles", age: 1, active: true }
+];
+
+find(function(o) {
+  return o.age < 40;
+}, users);
+
+// The `matches` iteratee shorthand.
+find({ age: 1, active: true }, users);
+
+// The `matchesProperty` iteratee shorthand.
+find(["active", false], users);
+
+// The `property` iteratee shorthand.
+find("active", users);
+
+/**
+ * groupBy
+ */
+var numbersGroupedByMathFloor = groupBy(Math.floor, [6.1, 4.2, 6.3]);
+if (numbersGroupedByMathFloor[6]) {
+  numbersGroupedByMathFloor[6][0] / numbersGroupedByMathFloor[6][1];
+}
+var stringsGroupedByLength = groupBy("length", ["one", "two", "three"]);
+if (stringsGroupedByLength[3]) {
+  stringsGroupedByLength[3][0].toLowerCase();
+}
+var numbersObj: { [key: string]: number, ... } = { a: 6.1, b: 4.2, c: 6.3 };
+var numbersGroupedByMathFloor2 = groupBy(Math.floor, numbersObj);
+if (numbersGroupedByMathFloor2[6]) {
+  numbersGroupedByMathFloor2[6][0] / numbersGroupedByMathFloor2[6][1];
+}
+var stringObj: { [key: string]: string, ... } = { a: "one", b: "two", c: "three" };
+var stringsGroupedByLength2 = groupBy("length", stringObj);
+if (stringsGroupedByLength2[3]) {
+  stringsGroupedByLength2[3][0].toLowerCase();
+}
+
+/**
+ * intersectionBy
+ */
+intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
+intersectionBy("x", [{ x: 1 }], [{ x: 2 }, { x: 1 }]);
+
+/**
+ * get
+ */
+
+// Object — examples from lodash docs
+var exampleObjectForGetTest = { a: [{ b: { c: 3 } }] };
+get("a[0].b.c", exampleObjectForGetTest);
+get(["a", "0", "b", "c"], exampleObjectForGetTest);
+getOr("default", "a.b.c", exampleObjectForGetTest);
+
+// Array — not documented, but get does support arrays
+get("0", [1, 2, 3]);
+get(0, [1, 2, 3]);
+get([0], [1, 2, 3]);
+get("[1]", ["foo", "bar", "baz"]);
+get("2", [{ a: "foo" }, { b: "bar" }, { c: "baz" }]);
+get("3", [[1, 2], [3, 4], [5, 6], [7, 8]]);
+get("3")([[1, 2], [3, 4], [5, 6], [7, 8]]);
+
+// Nil - it is safe to perform on nil root values, just like nil values along the "get" path
+get("thing", null);
+get("data", undefined);
+getOr("default", "stuff", null);
+getOr(12345, "info", undefined);
+
+/**
+ * keyBy
+ */
+keyBy(
+  function(o) {
+    return String.fromCharCode(o.code);
+  },
+  [{ dir: "left", code: 97 }, { dir: "right", code: 100 }]
+);
+keyBy("dir", [{ dir: "left", code: 97 }, { dir: "right", code: 100 }]);
+keyBy("dir")(
+  ([{ dir: "left", code: 97 }, { dir: "right", code: 100 }]: $ReadOnlyArray<any>)
+);
+
+// Example of keying a map of objects by a number type
+type KeyByTest$ByNumber<T: Object> = { [number]: T, ... };
+type KeyByTest$ByNumberMaybe<T: ?Object> = { [number]: T, ... };
+type KeyByTest$Record = { id: number, ... };
+var keyByTest_array: Array<KeyByTest$Record> = [
+  { id: 4 },
+  { id: 4 },
+  { id: 7 }
+];
+var keyByTest_map: KeyByTest$ByNumber<KeyByTest$Record> = {
+  [keyByTest_array[0].id]: keyByTest_array[0],
+  [keyByTest_array[1].id]: keyByTest_array[1],
+  [keyByTest_array[2].id]: keyByTest_array[2]
+};
+
+var keyByTest_map2: KeyByTest$ByNumberMaybe<KeyByTest$Record> = keyBy(
+  "id",
+  keyByTest_map
+);
+var keyByTest_map3: KeyByTest$ByNumberMaybe<KeyByTest$Record> = keyBy("id")(
+  keyByTest_map
+);
+
+/**
+ * map examples from the official doc
+ */
+function square(n) {
+  return n * n;
+}
+
+map(square, [4, 8]);
+map(square, { a: 4, b: 8 });
+
+var users = [{ user: "barney" }, { user: "fred" }];
+
+// The `property` iteratee shorthand.
+map("user", users);
+
+/**
+ * pullAllBy
+ */
+pullAllBy("x", [{ x: 1 }, { x: 3 }], [{ x: 1 }, { x: 2 }, { x: 3 }, { x: 1 }]);
+pullAllBy("x")([{ x: 1 }, { x: 3 }])([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 1 }]);
+
+/**
+ * unionBy
+ */
+unionBy(Math.floor, [2.1], [1.2, 2.3]);
+unionBy("x", [{ x: 1 }], [{ x: 2 }, { x: 1 }]);
+
+/**
+ * uniqBy
+ */
+uniqBy(Math.floor, [2.1, 1.2, 2.3]);
+uniqBy("x", [{ x: 1 }, { x: 2 }, { x: 1 }]);
+
+/**
+ * clone
+ */
+clone({ a: 1 }).a == 1;
+// $FlowExpectedError[prop-missing] property `b`. Property not found in object literal
+clone({ a: 1 }).b == 1;
+// $FlowExpectedError[invalid-compare] number. This type is incompatible with function type.
+clone({ a: 1 }).a == "c";
+
+/**
+ * isEqual
+ */
+isEqual("a", "b");
+isEqual({ x: 1 }, { y: 2 });
+isEqual({ x: 1 })({ y: 2 });
+
+// $FlowExpectedError[incompatible-call] function type expects no more than 2 arguments
+isEqual(1, 2, 3);
+
+/**
+ * range
+ */
+range(0, 10)[4] == 4;
+range(0)(10)[4] == 4;
+// $FlowExpectedError[incompatible-call] string. This type is incompatible with number
+range(0, "a");
+// $FlowExpectedError[invalid-compare] string cannot be compared to number
+range(0, 10)[4] == "a";
+
+/**
+ * sortedIndexBy
+ */
+sortedIndexBy(
+  function(o) {
+    return o.x;
+  },
+  { x: 4 },
+  [{ x: 4 }, { x: 5 }]
+);
+sortedIndexBy("x", { x: 4 }, [{ x: 4 }, { x: 5 }]);
+sortedIndexBy("x")({ x: 4 }, [{ x: 4 }, { x: 5 }]);
+
+/**
+ * sortedLastIndexBy
+ */
+sortedLastIndexBy(
+  function(o) {
+    return o.x;
+  },
+  { x: 4 },
+  [{ x: 4 }, { x: 5 }]
+);
+sortedLastIndexBy("x", { x: 4 }, [{ x: 4 }, { x: 5 }]);
+
+/**
+ * sortedUniq
+ */
+sortedUniq([1, 1, 2]);
+sortedUniq(["a", "b", "b"]);
+
+/**
+ * sortedUniqBy
+ */
+sortedUniqBy(Math.floor, [1.2, 2.1, 2.3]);
+sortedUniqBy("x", [{ x: 1 }, { x: 1 }, { x: 2 }]);
+
+/**
+ * extend
+ */
+extend({ a: 1 }, { b: 2 }).a;
+extend({ a: 1 })({ b: 2 }).a;
+extend({ a: 1 }, { b: 2 }).b;
+// $FlowExpectedError[incompatible-use] property `c`. Property not found in object literal
+extend({ a: 1 }, { b: 2 }).c;
+// $FlowExpectedError[incompatible-use] property `c`. Poperty not found in object literal
+assignIn({ a: 1 }, { b: 2 }).c;
+// $FlowExpectedError[incompatible-use] property `c`. Poperty not found in object literal
+assignIn({ a: 1 })({ b: 2 }).c;
+
+/**
+ * xorBy
+ */
+xorBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
+xorBy("x", [{ x: 1 }], [{ x: 2 }, { x: 1 }]);
+
+/**
+ * zip
+ */
+zip(["a", "b", "c"], ["d", "e", "f"])[0].length;
+zip(["a", "b", "c"], [1, 2, 3])[0].length;
+zip(["a", "b", "c"], [1, 2, 3])[0][0] + "a";
+zip(["a", "b", "c"], [1, 2, 3])[0][1] * 10;
+// $FlowExpectedError[prop-missing] `x` property not found in Array
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0].x;
+// $FlowExpectedError[prop-missing] `y` property not found in object literal
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][0].y;
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][1].y;
+// $FlowExpectedError[invalid-tuple-index] Flow could potentially catch this -- the tuple only has two elements.
+zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][2];
+
+/**
+ * isString
+ */
+
+var boolTrue: true;
+var boolFalse: false;
+
+boolTrue = isString("foo");
+boolFalse = isString([""]);
+boolFalse = isString({});
+boolFalse = isString(5);
+boolFalse = isString(function(f) {
+  return f;
+});
+boolFalse = isString();
+boolFalse = isString(true);
+
+// $FlowExpectedError[incompatible-type]
+boolFalse = isString("");
+// $FlowExpectedError[incompatible-type]
+boolTrue = isString(undefined);
+
+/**
+ * find
+ */
+find(x => x == 1, [1, 2, 3]);
+// $FlowExpectedError[incompatible-call] number. This type is incompatible with function type.
+find(1, [1, 2, 3]);
+
+// Copy pasted tests from iflow-lodash
+var nums: number[] = [1, 2, 3, 4, 5, 6];
+var num: number;
+var string: string;
+var bool: boolean;
+
+var nativeSquares: number[];
+var directSquares: number[];
+
+var nativeStrings: string[];
+var directStrings: string[];
+
+var allNums: number[];
+var numsAndStrList: Array<number | string>;
+var mixedList: Array<mixed>;
+allNums = concat(nums, nums);
+numsAndStrList = concat(nums, "123");
+numsAndStrList = concat(nums)("123");
+numsAndStrList = concat(nums)(["123"]);
+numsAndStrList = concat(nums, ["123", "456"]);
+numsAndStrList = concat(nums, [1, 2, 3, "456"]);
+mixedList = concat(nums, [[1, 2, 3], "456"]);
+(concat(1, 2): number[]);
+(concat(1, [2]): number[]);
+(concat([1], [2]): number[]);
+(concat([1], 2): number[]);
+
+// Array#map, lodash.map, lodash#map
+nativeSquares = nums.map(function(num) {
+  return num * num;
+});
+directSquares = map(function(num) {
+  return num * num;
+}, nums);
+
+num = first(nums);
+
+// return type of iterator is reflected in result and chain
+nativeStrings = nums.map(function(num) {
+  return JSON.stringify(num);
+});
+directStrings = map(function(num) {
+  return JSON.stringify(num);
+}, nums);
+
+var obj = { a: 1, b: 2 };
+bool = conformsTo(
+  {
+    a: function(x: number) {
+      return true;
+    }
+  },
+  obj
+);
+
+num = defaultTo(2, undefined);
+string = defaultTo("str", undefined);
+bool = defaultTo("str", true);
+string = defaultTo(true, "str");
+
+num = tap(function(n) {
+  return false;
+}, 1);
+bool = thru(function(n) {
+  return false;
+}, 1);
+
+var timesNums: number[];
+
+timesNums = times((i: number) => i, 5);
+timesNums = times((i: number) => i)(5);
+// $FlowExpectedError[incompatible-type] string. This type is incompatible with number
+var strings: string[] = times(i => i, 5);
+timesNums = times(function(i: number) {
+  return i + 1;
+}, 5);
+// $FlowExpectedError[incompatible-type] string. This type is incompatible with number
+timesNums = times((i: number) => JSON.stringify(i), 5);
+
+// lodash.flatMap for collections and objects
+// this arrow function needs a type annotation due to a bug in flow
+// https://github.com/facebook/flow/issues/1948
+flatMap((n): number[] => [n, n], [1, 2, 3]);
+flatMap(n => [n, n], { a: 1, b: 2 });
+
+/**
+ * noop
+ */
+noop();
+noop(1);
+noop("a", 2, [], null);
+(noop: string => void);
+(noop: (number, string) => void);
+// $FlowExpectedError[incompatible-cast] functions are contravariant in return types
+(noop: string => string);
+
+const ab = (a: number) => `${a}`;
+const bc = (b: string) => ({ b });
+const cd = (c: { b: string, ... }) => [c.b];
+const pipedResult: string[] = pipe(
+  ab,
+  bc,
+  cd
+)(1);
+const composedResult: string[] = compose(
+  cd,
+  bc,
+  ab
+)(1);
+
+/**
+ * includes
+ */
+includes("test")({ a: "test2", b: "test" });
+
+/**
+ * pick
+ */
+pick('a', { a: 1, b: 2 })
+pick('a', 'b', { a: 1, b: 2 })
+pick(['a'], { a: 1, b: 2 })
+pick(['a', 'b'], { a: 1, b: 2 })
+// Curried
+pick('a')
+pick('a', 'b')
+pick(['a'])
+pick(['a', 'b'])
+
+// $FlowExpectedError[incompatible-call]
+pick(1)({ a: 1});
diff --git a/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-v4.x.x.js b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-v4.x.x.js
new file mode 100644
index 0000000000..5080ae0930
--- /dev/null
+++ b/definitions/npm/lodash_v4.x.x/flow_v0.201.x-/test_lodash-v4.x.x.js
@@ -0,0 +1,939 @@
+// @flow
+
+/**
+ * Please add tests for new functions in the same order as they are in the main file and lodash documentation.
+ */
+
+import { describe, it } from "flow-typed-test";
+import assignIn from "lodash/assignIn";
+import attempt from "lodash/attempt";
+import castArray from "lodash/castArray";
+import chunk from "lodash/chunk";
+import clone from "lodash/clone";
+import compact from "lodash/compact";
+import concat from "lodash/concat";
+import conformsTo from "lodash/conformsTo";
+import countBy from "lodash/countBy";
+import debounce from "lodash/debounce";
+import defaultTo from "lodash/defaultTo";
+import difference from "lodash/difference";
+import differenceBy from "lodash/differenceBy";
+import differenceWith from "lodash/differenceWith";
+import each from "lodash/each";
+import eachRight from "lodash/eachRight";
+import every from "lodash/every";
+import extend from "lodash/extend";
+import filter from "lodash/filter";
+import find from "lodash/find";
+import findLast from "lodash/findLast";
+import first from "lodash/first";
+import flatMap from "lodash/flatMap";
+import flatMapDeep from "lodash/flatMapDeep";
+import flatMapDepth from "lodash/flatMapDepth";
+import forEach from "lodash/forEach";
+import forEachRight from "lodash/forEachRight";
+import get from "lodash/get";
+import groupBy from "lodash/groupBy";
+import includes from "lodash/includes";
+import intersectionBy from "lodash/intersectionBy";
+import invokeMap from "lodash/invokeMap";
+import isEqual from "lodash/isEqual";
+import isString from "lodash/isString";
+import keyBy from "lodash/keyBy";
+import keys from "lodash/keys";
+import map from "lodash/map";
+import memoize from "lodash/memoize";
+import noop from "lodash/noop";
+import omitBy from "lodash/omitBy";
+import orderBy from 'lodash/orderBy';
+import partition from 'lodash/partition';
+import pick from 'lodash/pick';
+import pickBy from "lodash/pickBy";
+import pullAllBy from "lodash/pullAllBy";
+import range from "lodash/range";
+import reduce from "lodash/reduce";
+import reduceRight from "lodash/reduceRight";
+import reject from "lodash/reject";
+import sample from "lodash/sample";
+import sampleSize from "lodash/sampleSize";
+import shuffle from "lodash/shuffle";
+import size from "lodash/size";
+import some from "lodash/some";
+import sortBy from "lodash/sortBy";
+import sortedIndexBy from "lodash/sortedIndexBy";
+import sortedLastIndexBy from "lodash/sortedLastIndexBy";
+import sortedUniq from "lodash/sortedUniq";
+import sortedUniqBy from "lodash/sortedUniqBy";
+import take from "lodash/take";
+import takeRight from "lodash/takeRight";
+import tap from "lodash/tap";
+import thru from "lodash/thru";
+import times from "lodash/times";
+import toPairs from "lodash/toPairs";
+import toPairsIn from "lodash/toPairsIn";
+import unionBy from "lodash/unionBy";
+import uniqBy from "lodash/uniqBy";
+import xorBy from "lodash/xorBy";
+import zip from "lodash/zip";
+import zipWith from "lodash/zipWith";
+
+// Ideally, there should be a test for each of the variables below. To verify that these use cases do not break on code changes.
+// Test arrays
+type ReadOnlyArray = $ReadOnlyArray<number>
+const readOnlyArray : ReadOnlyArray = Object.freeze([1, 2, 3, 4]);
+
+type ArrayOrNullOrVoid = number[] | null | void;
+const arrayOrNullOrVoid: ArrayOrNullOrVoid = readOnlyArray[0] > 100 ? [1, 2, 3] : readOnlyArray[1] > 100 ? null : undefined;
+
+// Test objects
+type IndexerObject = { [string]: number, ... };
+const indexerObject: IndexerObject = { a: 1, b: 2, c: 3 };
+
+type ExactObject = {| a: number, b: number, c: number; |};
+const exactObject: ExactObject = { a: 1, b: 2, c: 3 };
+
+type ExactHeterogeneousObject = {| a: number, b: string, c: boolean; |};
+type ExactHeterogeneousObjectValue = number | string | boolean;
+const exactHeterogeneousObject: ExactHeterogeneousObject = { a: 1, b: 'abc', c: true };
+
+type ReadOnlyIndexerObject = $ReadOnly<IndexerObject>
+const readOnlyIndexerObject: ReadOnlyIndexerObject = { ...indexerObject }; // example of inexact object
+
+type ReadOnlyExactObject = $ReadOnly<ExactObject>
+const readOnlyExactObject: ReadOnlyExactObject = { ...exactObject };
+
+type ObjectOrNullOrVoid = IndexerObject | null | void;
+const objectOrNullOrVoid: ObjectOrNullOrVoid = readOnlyArray[0] > 100 ? indexerObject : readOnlyArray[1] > 100 ? null : undefined;
+
+type ArrayOrObjectOrString = number[] | ExactObject | string;
+const arrayOrObjectOrString: ArrayOrObjectOrString = readOnlyArray[0] > 100 ? [1, 2, 3] : (readOnlyArray[1] > 100 ? exactObject : 'abc');
+
+
+describe('Array', () => {
+  it('chunk', () => {
+    chunk(readOnlyArray, 2);
+  });
+
+  it('compact', () => {
+    compact(readOnlyArray);
+  });
+
+  it('concat', () => {
+    concat(readOnlyArray, readOnlyArray, readOnlyArray);
+  // Copy pasted tests from iflow-lodash
+    const nums: number[] = [1, 2, 3, 4, 5, 6];
+    (concat(nums, "123", "456"): Array<number | string>);
+    (concat(nums, ["123", "456"]): Array<number | string>);
+    (concat(nums, [[1, 2, 3], "456"]): Array<number | string>);
+    (concat(nums, [[1, 2, 3], "456"]): Array<mixed>);
+  });
+
+  it('difference', () => {
+    difference(
+      (["a", "b"]: $ReadOnlyArray<string>),
+      (["b"]: $ReadOnlyArray<string>)
+    );
+    difference(
+      (["a", "b"]: $ReadOnlyArray<string>),
+      (["b"]: $ReadOnlyArray<string>),
+      (["a"]: $ReadOnlyArray<string>)
+    );
+  });
+
+  it('differenceBy', () => {
+    differenceBy(([2.1, 1.2]: $ReadOnlyArray<number>), [2.3, 3.4], Math.floor);
+    differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], "x");
+    differenceBy(([2.1, 1.2]: $ReadOnlyArray<number>), [2.3, 3.4], Math.floor);
+    type A = {| a: 1 |};
+    type B = {| b: 1 |};
+    differenceBy(([{ a: 1 }, { a: 1 }]: $ReadOnlyArray<A>), ([{ b: 1 }, { b: 1 }]: $ReadOnlyArray<B>), (x: A | B) => {
+      return x.a || x.b;
+    });
+  });
+
+  it('differenceWith', () => {
+    type A = {| a: 1 |};
+    type B = {| b: 1 |};
+    differenceWith(([{ a: 1 }, { a: 1 }]: $ReadOnlyArray<A>), ([{ b: 1 }, { b: 1 }]: $ReadOnlyArray<B>), (x: A, y: B) => {
+      return x.a === y.b;
+    });
+  });
+
+  it('first', () => {
+    (first([1, 2, 3, 4]): number);
+  });
+
+  it('intersectionBy', () => {
+    intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+    intersectionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+  });
+
+  it('pullAllBy', () => {
+    pullAllBy([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 1 }], [{ x: 1 }, { x: 3 }], "x");
+  });
+
+  it('sortedIndexBy', () => {
+    sortedIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, function(o) {
+      return o.x;
+    });
+    sortedIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, "x");
+  });
+
+  it('sortedLastIndexBy', () => {
+    sortedLastIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, function(o) {
+      return o.x;
+    });
+    sortedLastIndexBy([{ x: 4 }, { x: 5 }], { x: 4 }, "x");
+  });
+
+  it('sortedUniq', () => {
+    sortedUniq([1, 2, 2]);
+    sortedUniq(["a", "b", "b"]);
+  });
+
+  it('sortedUniqBy', () => {
+    sortedUniqBy([1.2, 2.1, 2.3], Math.floor);
+    sortedUniqBy([{ x: 1 }, { x: 1 }, { x: 2 }], "x");
+  });
+
+  it('take / _.takeRight', () => {
+    (take((["abc", "123"]: $ReadOnlyArray<string>), 3): string[]);
+    (takeRight((["abc", "123"]: $ReadOnlyArray<string>)): string[]);
+  });
+
+  it('unionBy', () => {
+    unionBy([2.1], [1.2, 2.3], Math.floor);
+    unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+  });
+
+  it('uniqBy', () => {
+    uniqBy([2.1, 1.2, 2.3], Math.floor);
+    uniqBy([{ x: 1 }, { x: 2 }, { x: 1 }], "x");
+  });
+
+  it('xorBy', () => {
+    xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+    xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
+  });
+
+  it('zip', () => {
+    zip(["a", "b", "c"], ["d", "e", "f"])[0].length;
+    zip(["a", "b", "c"], [1, 2, 3])[0].length;
+    zip(["a", "b", "c"], [1, 2, 3])[0][0] + "a";
+    zip(["a", "b", "c"], [1, 2, 3])[0][1] * 10;
+    // $FlowExpectedError[prop-missing] `x` property not found in Array
+    zip([{ x: 1 }], [{ x: 2, y: 1 }])[0].x;
+    // $FlowExpectedError[prop-missing] `y` property not found in object literal
+    zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][0].y;
+    zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][1].y;
+    // $FlowExpectedError[invalid-tuple-index] Flow could potentially catch this -- the tuple only has two elements.
+    zip([{ x: 1 }], [{ x: 2, y: 1 }])[0][2];
+  });
+
+  it('zipWith', () => {
+    zipWith(["a", "b", "c"], [1, 2, 3], (str: string, num) => ({ [str]: num }));
+    zipWith((["a", "b", "c"]: $ReadOnlyArray<string>), ([1, 2, 3]: $ReadOnlyArray<number>), (str: string, num) => ({ [str]: num }));
+    zipWith(readOnlyArray, readOnlyArray, readOnlyArray);
+    zipWith(readOnlyArray, readOnlyArray, readOnlyArray, (a: number, b: number, c: number) => [a, b, c]);
+    zipWith(readOnlyArray, readOnlyArray, readOnlyArray, readOnlyArray);
+    zipWith(readOnlyArray, readOnlyArray, readOnlyArray, readOnlyArray, (a: number, b: number, c: number, d: number) => [a, b, c, d]);
+    // $FlowExpectedError[unsafe-addition] `x` should be a `string`, `y` a `number`
+    zipWith(["a", "b", "c"], [1, 2, 3]).map(([x, y]) => x * y);
+  });
+});
+
+describe('Collection', () => {
+  it('countBy', () => {
+    (countBy([6.1, 4.2, 6.3], Math.floor): { [string]: number, ... });
+    (countBy(["one", "two", "three"], "length"): { [string]: number, ... });
+
+    (countBy(readOnlyArray, (v: number) => v): { [string]: number, ... });
+    (countBy(readOnlyArray, (v: number | string| boolean) => v): { [string]: number, ... });
+    (countBy(arrayOrNullOrVoid, (v: number) => v): { [string]: number, ... });
+
+    (countBy(indexerObject, (v: number) => v): { [string]: number, ... });
+    (countBy(exactObject, (v: number) => v): { [string]: number, ... });
+    (countBy(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue) => v): { [string]: number, ... });
+    // $FlowExpectedError[incompatible-call] wrong value type
+    (countBy(exactHeterogeneousObject, (v: number) => v): { [string]: number, ... });
+    (countBy(readOnlyIndexerObject, (v: number) => v): { [string]: number, ... });
+    (countBy(readOnlyExactObject, (v: number) => v): { [string]: number, ... });
+    (countBy(objectOrNullOrVoid, (v: number) => v): { [string]: number, ... });
+    (countBy(arrayOrObjectOrString, (v: number | string) => v): { [string]: number, ... });
+
+    // $FlowExpectedError[incompatible-cast] wrong return type
+    (countBy(["one", "two", "three"], "length"): { [string]: string, ... });
+    // $FlowExpectedError[incompatible-call] wrong first argument
+    countBy(123, "length");
+    // $FlowExpectedError[incompatible-call] wrong value type
+    countBy(["one", "two", "three"], (v: boolean) => v);
+    // $FlowExpectedError[incompatible-call] wrong indexer type
+    countBy(["one", "two", "three"], (v, arg2: number) => arg2);
+  });
+
+  /**
+   * Reusing such functions allows to:
+   * 1) Ensure all tests are run and up to date for each function
+   * 2) Enforce that type definitions for all related functions (e.g. each, eachRight, forEach, forEachRight) are the same, as they should be by the docs.
+   */
+  const testForEachFunction = (f: typeof forEach) => {
+    (f('123', (char: string) => {}): string);
+
+    (f(readOnlyArray, (v: number) => false): $ReadOnlyArray<number>);
+    // $FlowExpectedError[incompatible-cast] forEach returns its first argument, therefore, if it was readonly, it should remain readonly
+    (f(readOnlyArray, (v) => {}): number[]);
+    (f(arrayOrNullOrVoid, (v: number) => !!v): ArrayOrNullOrVoid);
+
+    (f(indexerObject, (v: number, k: string, c: IndexerObject) => {}): IndexerObject);
+    (f(exactObject, (v: number, k: string, c: ExactObject) => !!v): ExactObject);
+    (f(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => !!v): ExactHeterogeneousObject);
+    // $FlowExpectedError[incompatible-call] wrong iteratee argument type
+    f(exactHeterogeneousObject, (v: number) => false);
+    (f(readOnlyIndexerObject, (v: number, k: string, c: ReadOnlyIndexerObject) => {}): ReadOnlyIndexerObject);
+    (f(readOnlyExactObject, (v: number, k: string, c: ReadOnlyExactObject) => {}): ReadOnlyExactObject);
+    // $FlowExpectedError[incompatible-variance] forEach returns its first argument, therefore, if it was readonly, it should remain readonly
+    (f(readOnlyExactObject, (v) => {}): ExactObject);
+    (f(objectOrNullOrVoid, (v: number, k: string, c: ObjectOrNullOrVoid) => {}): ObjectOrNullOrVoid);
+    (f(arrayOrObjectOrString, (v: number | string, key: string, c: ArrayOrObjectOrString) => !!v): ArrayOrObjectOrString);
+    // $FlowExpectedError[incompatible-call] wrong iteratee argument type,
+    (f(arrayOrObjectOrString, (v: string) => !!v): ArrayOrObjectOrString);
+
+    // $FlowExpectedError[incompatible-call] wrong iteratee return value
+    f(exactObject, (v) => ({ a: 1, b: 2}));
+    // $FlowExpectedError[incompatible-cast] wrong return type: forEach() returns collection passed in the first argument
+    (f(exactObject, (v) => false): void);
+    // $FlowExpectedError[incompatible-call] wrong iteratee return type
+    f(exactObject, (v) => v + 2);
+    // $FlowExpectedError[incompatible-call] wrong iteratee type, should be function
+    f(exactObject, {a: 1});
+  }
+
+  it('each', () => {
+    testForEachFunction(each);
+  });
+
+  it('eachRight', () => {
+    testForEachFunction(eachRight);
+  });
+
+  it('every', () => {
+    const users = [
+      { 'user': 'barney', 'age': 36, 'active': false },
+      { 'user': 'fred',   'age': 40, 'active': false }
+    ];
+
+    (every([true, 1, null, 'yes'], Boolean): boolean);
+    (every(users, { 'user': 'barney', 'active': false }): boolean);
+    (every(users, ['active', false]): boolean);
+    (every(users, 'active'): boolean);
+
+    (every(readOnlyArray, (v: number) => false): boolean);
+    (every(arrayOrNullOrVoid, (v: number) => !!v): boolean);
+
+    (every(indexerObject, (v: number, k: string, c: IndexerObject) => {}): boolean);
+    (every(exactObject, (v: number, k: string, c: ExactObject) => !!v): boolean);
+    (every(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => !!v): boolean);
+    (every(readOnlyIndexerObject, (v: number, k: string, c: ReadOnlyIndexerObject) => {}): boolean);
+    (every(readOnlyExactObject, (v: number, k: string, c: ReadOnlyExactObject) => {}): boolean);
+    (every(objectOrNullOrVoid, (v: number, k: string, c: ObjectOrNullOrVoid) => {}): boolean);
+    (every(arrayOrObjectOrString, (v: number | string, key: string, c: ArrayOrObjectOrString) => !!v): boolean);
+  });
+
+  const testFilterFunction = (f: typeof filter) => {
+    type User = {| user: string, age: number, active: boolean; |}
+    const users : User[] = [
+      { 'user': 'barney', 'age': 36, 'active': true },
+      { 'user': 'fred',   'age': 40, 'active': false }
+    ];
+
+    (f(users, (u: User, i: number, collection: User[]) => !u.active ): User[]);
+    (f(users, { 'age': 36, 'active': true }): User[]);
+    (f(users, ['active', false]): User[]);
+    (f(users, 'active'): User[]);
+
+    (f(readOnlyArray, (v: number) => false): number[]);
+    (f(arrayOrNullOrVoid, (v: number) => !!v): number[]);
+
+    (f(indexerObject, (v: number, k: string, c: IndexerObject) => {}): number[]);
+    (f(exactObject, (v: number, k: string, c: ExactObject) => !!v): number[]);
+    (f(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => !!v): ExactHeterogeneousObjectValue[]);
+    (f(readOnlyIndexerObject, (v: number, k: string, c: ReadOnlyIndexerObject) => {}): number[]);
+    (f(readOnlyExactObject, (v: number, k: string, c: ReadOnlyExactObject) => {}): number[]);
+    (f(objectOrNullOrVoid, (v: number, k: string, c: ObjectOrNullOrVoid) => {}): number[]);
+
+    // $FlowExpectedError[incompatible-call] first arg should be array or object type is wrong
+    f(123, function(o) { return !o.active; });
+    // $FlowExpectedError[incompatible-cast] return type is wrong
+    (f(users, function(o) { return !o.active; }): boolean);
+  };
+
+  it('filter', () => {
+    testFilterFunction(filter);
+  });
+
+  const testFindFunction = (f: typeof find) => {
+    // examples from the official doc
+    type User = {| user: string, age: number, active: boolean |};
+    const users: User[] = [
+      { user: "barney", age: 36, active: true },
+      { user: "fred", age: 40, active: false },
+      { user: "pebbles", age: 1, active: true }
+    ];
+    (f(users, function(o) { return o.age < 40; }): User | void);
+    (f(users, { age: 1, active: true }): User | void);
+    (f(users, ["active", false]): User | void);
+    (f(users, "active"): User | void);
+    (f(users, "active"): User | void);
+
+    (f([1, 2, 3], x => x * 1 == 3): number | void);
+    (f([1, 2, 3], x => x == 2, 1): number | void);
+
+    (f([{ x: 1 }, { x: 2 }, { x: 3 }], v => v.x == 3): {| x: number |} | void);
+    (f({ x: 1, y: 2 }, (v: number, key: string) => v): number | void);
+
+    (f((["a", "b"]: $ReadOnlyArray<string>), "c"): string | void);
+    (f([1, 2, 3], x => x == 1): number | void);
+
+    (f(readOnlyArray, (v: number) => false): number | void);
+    (f(arrayOrNullOrVoid, v => !!v, null): number | void);
+
+    (f(indexerObject, (v: number, k: string, c: IndexerObject) => {}): number | void);
+    (f(exactObject, (v: number, k: string, c: ExactObject) => !!v): number | void);
+    (f(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => !!v): ExactHeterogeneousObjectValue[]);
+    (f(readOnlyIndexerObject, (v: number, k: string, c: ReadOnlyIndexerObject) => {}): number | void);
+    (f(readOnlyExactObject, (v: number, k: string, c: ReadOnlyExactObject) => {}): number | void);
+    (f(objectOrNullOrVoid, (v: number, k: string, c: ObjectOrNullOrVoid) => !!v): number | void);
+
+    // $FlowExpectedError[invalid-compare] number cannot be compared to string
+    f([1, 2, 3], x => x == "a");
+    // $FlowExpectedError[incompatible-call] number is incompatible with function type.
+    f([1, 2, 3], 1);
+    // $FlowExpectedError[prop-missing] property `y` not found in object literal
+    f([{ x: 1 }, { x: 2 }, { x: 3 }], v => v.y == 3);
+    // $FlowExpectedError[incompatible-cast] function may not find the item, therefore `void` is always a valid result
+    (f(users, function(o) { return o.age < 40; }): User);
+  }
+
+  it('find', () => {
+    testFindFunction(find);
+  });
+
+  it('findLast', () => {
+    testFindFunction(findLast);
+  });
+
+  it('flatMap', () => {
+    // this arrow function needs a type annotation due to a bug in flow: https://github.com/facebook/flow/issues/1948
+    (flatMap([1, 2, 3], (n: number) => [n, n]): number[]);
+
+    (flatMap([1, 2, 3], (n: number, i: number, c: number[]) => n): number[]);
+    (flatMap(['a', 'b', 'c'], (v: string, i: number, c: string[]) => [v, c[0], i]): (number | string)[]);
+    // $FlowExpectedError[incompatible-call] array index is a number
+    (flatMap(['a', 'b', 'c'], (v, i: string) => [v, v]));
+
+    (flatMap(['a', 'b', 'c'], (v: string, i: number, c: string[]) => [{ v, i }]): ({| v: string, i: number |})[]);
+    flatMap([{ a: [1, 2] }, { a: [3,4] }], 'a');
+    (flatMap({ a: 1, b: 2 }, (n: number, k: string, c: {| a: number, b: number |}) => [n, k]): (number| string)[]);
+
+    (flatMap(readOnlyArray, (n: number, i: number, c: ReadOnlyArray) => [n, n]): number[]);
+    (flatMap(arrayOrNullOrVoid, (n: number, i: number, c: ArrayOrNullOrVoid): number[] => [n, n]): number[]);
+
+    (flatMap(indexerObject, (v: number, k: string, c: IndexerObject) => [v, v]): number[]);
+    (flatMap(exactObject, (v: number, k: string, c: ExactObject) => [v, v]): number[]);
+    (flatMap(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => [v, v]): ExactHeterogeneousObjectValue[]);
+    (flatMap(readOnlyIndexerObject, (n: number, k: string, c: ReadOnlyIndexerObject) => [n, n]): number[]);
+    (flatMap(readOnlyExactObject, (n: number, k: string, c: ReadOnlyExactObject) => [n, n]): number[]);
+    (flatMap(objectOrNullOrVoid, (n: number, k: string, c: ObjectOrNullOrVoid) => [n, n]): number[]);
+    (flatMap(arrayOrObjectOrString, (n: number| string, k: number | string, c: ArrayOrObjectOrString) => [n, n]): (number| string)[]);
+    // $FlowExpectedError[incompatible-call] key cannot be only string since index is `number` for array
+    flatMap(arrayOrObjectOrString, (n, k: string) => [n, n]);
+  });
+
+  it('flatMapDeep', () => {
+    (flatMapDeep([1, 2, 3], (n: number) => [[[n, n]]]): number[]);
+
+    (flatMapDeep(['a', 'b', 'c'], (v: string, i: number, c: string[]) => [[[v, c[0], i]]]): (number | string)[]);
+    (flatMapDeep(readOnlyArray, (n: number, i: number, c: ReadOnlyArray) => [[[n, n]]]): number[]);
+    (flatMapDeep(arrayOrNullOrVoid, (n: number, i: number, c: ArrayOrNullOrVoid) => [[[n, n]]]): number[]);
+
+    (flatMapDeep({ a: 1, b: 2 }, (n: number, k: string, c: {| a: number, b: number |}) => [[[n, k]]]): (number| string)[]);
+    (flatMapDeep(indexerObject, (v: number, k: string, c: IndexerObject) => [[[v, v]]]): number[]);
+    (flatMapDeep(exactObject, (v: number, k: string, c: ExactObject) => [[[v, v]]]): number[]);
+    (flatMapDeep(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => [[[v, v]]]): ExactHeterogeneousObjectValue[]);
+    (flatMapDeep(readOnlyIndexerObject, (n: number, k: string, c: ReadOnlyIndexerObject) => [[[n, n]]]): number[]);
+    (flatMapDeep(readOnlyExactObject, (n: number, k: string, c: ReadOnlyExactObject) => [[[n, n]]]): number[]);
+    (flatMapDeep(objectOrNullOrVoid, (n: number, k: string, c: ObjectOrNullOrVoid) => [[[n, n]]]): number[]);
+    (flatMapDeep(arrayOrObjectOrString, (n: number| string, k: number | string, c: ArrayOrObjectOrString) => [[[n, n]]]): (number| string)[]);
+    // $FlowExpectedError[incompatible-call] key cannot be only string since index is `number` for array
+    flatMapDeep(arrayOrObjectOrString, (n, k: string) => [[[n, n]]]);
+  });
+
+  it('flatMapDepth', () => {
+    (flatMapDepth([1, 2, 3], (n) => [[[n, n]]], 2): number[]);
+
+    (flatMapDepth(['a', 'b', 'c'], (v: string, i: number, c: string[]) => [[[v, c[0], i]]], 2): (number | string)[]);
+    (flatMapDepth(readOnlyArray, (n: number, i: number, c: ReadOnlyArray) => [[[n, n]]], 2): number[]);
+    (flatMapDepth(arrayOrNullOrVoid, (n: number, i: number, c: ArrayOrNullOrVoid) => [[[n, n]]], 2): number[]);
+
+    (flatMapDepth({ a: 1, b: 2 }, (n: number, k: string, c: {| a: number, b: number |}) => [[[n, k]]], 2): (number| string)[]);
+    (flatMapDepth(indexerObject, (v: number, k: string, c: IndexerObject) => [[[v, v]]], 2): number[]);
+    (flatMapDepth(exactObject, (v: number, k: string, c: ExactObject) => [[[v, v]]], 2): number[]);
+    (flatMapDepth(exactHeterogeneousObject, (v: ExactHeterogeneousObjectValue, k: string, c: ExactHeterogeneousObject) => [[[v, v]]], 2): ExactHeterogeneousObjectValue[]);
+    (flatMapDepth(readOnlyIndexerObject, (n: number, k: string, c: ReadOnlyIndexerObject) => [[[n, n]]], 2): number[]);
+    (flatMapDepth(readOnlyExactObject, (n: number, k: string, c: ReadOnlyExactObject) => [[[n, n]]], 2): number[]);
+    (flatMapDepth(objectOrNullOrVoid, (n: number, k: string, c: ObjectOrNullOrVoid) => [[[n, n]]], 2): number[]);
+    (flatMapDepth(arrayOrObjectOrString, (n: number| string, k: number | string, c: ArrayOrObjectOrString) => [[[n, n]]], 2): (number| string)[]);
+    // $FlowExpectedError[incompatible-call] key cannot be only string since index is `number` for array
+    flatMapDepth(arrayOrObjectOrString, (n, k: string) => [[[n, n]]], 2);
+  });
+
+  it('forEach', () => {
+    testForEachFunction(forEach);
+  });
+
+  it('forEachRight', () => {
+    testForEachFunction(forEachRight);
+  });
+
+  it('groupBy', () => {
+    const numbersGroupedByMathFloor = groupBy([6.1, 4.2, 6.3], Math.floor);
+    if (numbersGroupedByMathFloor[6]) {
+      numbersGroupedByMathFloor[6][0] / numbersGroupedByMathFloor[6][1];
+    }
+
+    const stringsGroupedByLength = groupBy(["one", "two", "three"], "length");
+    if (stringsGroupedByLength[3]) {
+      stringsGroupedByLength[3][0].toLowerCase();
+    }
+
+    const numbersObj: { [key: string]: number, ... } = { a: 6.1, b: 4.2, c: 6.3 };
+    const numbersGroupedByMathFloor2 = groupBy(numbersObj, Math.floor);
+    if (numbersGroupedByMathFloor2[6]) {
+      numbersGroupedByMathFloor2[6][0] / numbersGroupedByMathFloor2[6][1];
+    }
+
+    const stringObj: { [key: string]: string, ... } = { a: "one", b: "two", c: "three" };
+    const stringsGroupedByLength2 = groupBy(stringObj, "length");
+    if (stringsGroupedByLength2[3]) {
+      stringsGroupedByLength2[3][0].toLowerCase();
+    }
+  });
+
+  it('includes', function () {
+    (includes([1, 2, 3], 1): boolean);
+    (includes([1, 2, 3], 1, 2): boolean);
+    (includes({ 'a': 1, 'b': 2 }, 1): boolean);
+    (includes('abcd', 'bc'): boolean);
+  })
+
+  it('invokeMap', function () {
+    (invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'): number[][]);
+    // $FlowExpectedError[incompatible-call]
+    // $FlowExpectedError[method-unbinding] caused using string split function
+    (invokeMap(['123', '456'], String.prototype.split, ''): string[][]);
+
+    // $FlowExpectedError[incompatible-call]
+    // $FlowExpectedError[method-unbinding] caused using string split function
+    invokeMap([123, 456], String.prototype.split, '');
+  })
+
+  it('keyBy', () => {
+    keyBy([{ dir: "left", code: 97 }, { dir: "right", code: 100 }], function(o) {
+      return String.fromCharCode(o.code);
+    });
+    keyBy([{ dir: "left", code: 97 }, { dir: "right", code: 100 }], "dir");
+
+    // Example of keying a map of objects by a number type
+    type KeyByTest$ByNumber<T: Object> = { [number]: T, ... };
+    type KeyByTest$ByNumberMaybe<T: ?Object> = { [number]: T, ... };
+    type KeyByTest$Record = { id: number, ... };
+    const keyByTest_array: Array<KeyByTest$Record> = [
+      { id: 4 },
+      { id: 4 },
+      { id: 7 }
+    ];
+    const keyByTest_map: KeyByTest$ByNumber<KeyByTest$Record> = {
+      [keyByTest_array[0].id]: keyByTest_array[0],
+      [keyByTest_array[1].id]: keyByTest_array[1],
+      [keyByTest_array[2].id]: keyByTest_array[2]
+    };
+    (keyBy(keyByTest_map, "id"): KeyByTest$ByNumberMaybe<KeyByTest$Record>);
+  });
+
+  it('map', () => {
+    // examples from the official doc
+    function square(n: number): number {
+      return n * n;
+    }
+    (map([4, 8], square): number[]);
+    (map({ a: 4, b: 8 }, square): number[]);
+    (map([{ user: "barney" }, { user: "fred" }], "user"): string[]);
+    (map([{ user: "barney", anotherProp: 1 }, { user: "fred", anotherProp: 2 }], "user"): string[]);
+
+    //accepts tuple types
+    const tuple: [number, number] = [1, 2];
+    (map(tuple, val => val + 2): number[]);
+    //$FlowExpectedError[prop-missing] cannot push to tuple
+    map(tuple, (val, nothing, tupleArray) => tupleArray.push(123));
+    //$FlowExpectedError[invalid-tuple-arity] wrong return type
+    (map(tuple, val => val + 2): [number, number]);
+
+    // Array#map, lodash.map, lodash#map
+    const nums: number[] = [1, 2, 3, 4, 5, 6];
+    (nums.map(num => num * num): number[]);
+    (map(nums, num => num * num): number[]);
+
+    // return type of iterator is reflected in result and chain
+    (nums.map(num => JSON.stringify(num)): string[]);
+    (map(nums, num => JSON.stringify(num)): string[]);
+  });
+
+  it('orderBy', () => {
+    type User = {| user: string, age: number |};
+    const users: User[] = [
+      { 'user': 'fred',   'age': 48 },
+      { 'user': 'barney', 'age': 34 },
+      { 'user': 'fred',   'age': 40 },
+      { 'user': 'barney', 'age': 36 }
+    ];
+    (orderBy(users, ['user', 'age'], ['asc', 'desc']): User[]);
+
+    type Item = {| a: number, b: number |};
+    (orderBy([{a: 1, b: 2}, {a: 2, b: 1}, {a: 3, b: 0}], ['a']): Item[]);
+    (orderBy([{a: 1, b: 2}, {a: 2, b: 1}, {a: 3, b: 0}], [x => x.a]): Item[]);
+    (orderBy({[0]: {a: 1, b: 2}, [2]: {a: 2, b: 1}, [1]: {a: 3, b: 0}}, ['a']): Item[]);
+    (orderBy({[0]: {a: 1, b: 2}, [2]: {a: 2, b: 1}, [1]: {a: 3, b: 0}}, [x => x.a]): Item[]);
+  });
+
+  it('partition', () => {
+    type User = {| user: string, age: number, active: boolean |}
+    const users: User[] = [
+      { 'user': 'barney',  'age': 36, 'active': false },
+      { 'user': 'fred',    'age': 40, 'active': true },
+      { 'user': 'pebbles', 'age': 1,  'active': false }
+    ];
+    (partition(users, function(o) { return o.active; }): [User[], User[]] );
+    (partition(users, { 'age': 1, 'active': false }): [User[], User[]]);
+    (partition(users, ['active', false]): [User[], User[]]);
+    (partition(users, 'active'): [User[], User[]]);
+  });
+
+  const testReduceFunction = (f: typeof reduce) => {
+    (f([1, 2], function(sum: number, n: number) { return sum + n;}, 0): number);
+
+    type Result = {[number]: string[], ...};
+    (f({ 'a': 1, 'b': 2, 'c': 1 }, function(result: Result, value: number, key: string) {
+      (result[value] || (result[value] = [])).push(key);
+      return result;
+    }, {}): Result);
+
+    (f([[0, 1], [2, 3], [4, 5]], function(flattened: number[], other: number[]) {
+      return flattened.concat(other);
+    }, []): number[]);
+
+    // $FlowExpectedError[incompatible-cast] return type
+    (f([1, 2], function(sum, n) { return sum + n;}, 0): string);
+
+    (f(readOnlyArray, (r: number, v: number, i: number) => r + v, 0): number);
+    (f(arrayOrNullOrVoid, (r: number, v: number, i: number) => r + (v != null ? v : 0), 0): number);
+
+    (f(indexerObject, (r: number, v: number, k: string) => r + v, 0): number);
+    (f(exactObject, (r: number, v: number, k: string) => r + v, 0): number);
+    (f(exactHeterogeneousObject, (r: ExactHeterogeneousObjectValue[], v: ExactHeterogeneousObjectValue, k: string) => [...r, v], []): ExactHeterogeneousObjectValue[]);
+    (f(readOnlyIndexerObject, (r: number, v: number, k: string) => r + v, 0): number);
+    (f(readOnlyExactObject, (r: number, v: number, k: string) => r + v, 0): number);
+    (f(objectOrNullOrVoid, (r: number, v: number, k: string) => r + v, 0): number);
+  };
+
+  it('reduce', () => {
+    testReduceFunction(reduce);
+  });
+
+  it('reduceRight', () => {
+    testReduceFunction(reduceRight);
+  });
+
+  it('reject', () => {
+    testFilterFunction(reject);
+  });
+
+  it('sample', () => {
+    (sample([1, 2, 3, 4]): number);
+    (sample(readOnlyArray): number);
+    (sample(readOnlyIndexerObject): number);
+    (sample({ a: 1, b: 'abc' }): number| string);
+
+    // $FlowExpectedError[incompatible-cast]
+    (sample({ a: 1, b: 'abc' }): number);
+  });
+
+  it('sampleSize', () => {
+    (sampleSize([1, 2, 3], 4): number[]);
+    (sampleSize(readOnlyArray, 2): number[]);
+    (sampleSize(readOnlyIndexerObject, 2): number[]);
+    (sampleSize({ a: 1, b: 'abc' }, 2): (number| string)[]);
+
+    // $FlowExpectedError[incompatible-cast]
+    // $FlowExpectedError[extra-arg]
+    (shuffle({ a: 1, b: 'abc' }, 2): number[]);
+  });
+
+  it('shuffle', () => {
+    (shuffle([1, 2, 3, 4]): number[]);
+    (shuffle(readOnlyArray): number[]);
+    (shuffle(readOnlyIndexerObject): number[]);
+    (shuffle(readOnlyIndexerObject): (number | string)[]);
+
+    // $FlowExpectedError[incompatible-cast]
+    (shuffle({ a: 1, b: 'abc' }): number[]);
+  });
+
+  it('size', () => {
+    (size([1, 2, 3]): number);
+    (size({ 'a': 1, 'b': 2 }): number);
+    (size('pebbles'): number);
+
+    (size(readOnlyArray): number);
+    (size(readOnlyIndexerObject): number);
+  });
+
+  it('some', () => {
+    const users = [
+      { 'user': 'barney', 'active': true },
+      { 'user': 'fred',   'active': false }
+    ];
+    (some([null, 0, 'yes', false], Boolean): boolean);
+    (some(users, { 'user': 'barney', 'active': false }): boolean);
+    (some(users, ['active', false]): boolean);
+    (some(users, 'active'): boolean);
+
+    (some(readOnlyArray, Boolean): boolean);
+    (some(readOnlyIndexerObject, Boolean): boolean);
+  });
+
+  it('sortBy', () => {
+    const users = [
+      { 'user': 'fred',   'age': 48 },
+      { 'user': 'barney', 'age': 36 },
+      { 'user': 'fred',   'age': 40 },
+      { 'user': 'barney', 'age': 34 }
+    ];
+    (sortBy(users, [function(o) { return o.user; }]): typeof users);
+    (sortBy(users, ['user', 'age']): typeof users);
+
+    (sortBy(readOnlyArray, (v) => v): typeof readOnlyArray);
+  });
+});
+
+describe('Date', () => {
+});
+
+describe('Function', () => {
+  it('debounce', () => {
+    var debounced = debounce((a: number) => "foo");
+    debounced(1);
+    debounced.cancel();
+    debounced.flush();
+    // $FlowExpectedError[incompatible-call] string is incompatible with number
+    debounced("a");
+  });
+
+  it('memoize', () => {
+    var memoized: (a: number) => string = memoize((a: number) => "foo");
+    // $FlowExpectedError[incompatible-call] memoize retains type information
+    memoized = memoize(() => {});
+  });
+});
+
+describe('Lang', () => {
+  it('castArray', () => {
+    (castArray(1): Array<number>);
+    (castArray({ 'a': 1 }): Array<{...}>);
+    (castArray('abc'): Array<string>);
+    (castArray(null): Array<null>);
+    (castArray(undefined): Array<void>);
+    (castArray(): Array<mixed>);
+    var array = [1, 2, 3];
+    (castArray(array): typeof array);
+  });
+
+  it('clone', () => {
+    clone({ a: 1 }).a == 1;
+    // $FlowExpectedError[prop-missing] property `b`. Property not found in object literal
+    clone({ a: 1 }).b == 1;
+    // $FlowExpectedError[invalid-compare] number. This type is incompatible with function type.
+    clone({ a: 1 }).a == "c";
+  });
+
+  it('isEqual', () => {
+    isEqual("a", "b");
+    isEqual({ x: 1 }, { y: 2 });
+
+    // Flow considers this compatible with isEqual(a: any, b: any).
+    // Reasonable people disagree about whether this should be considered a legal call.
+    // See https://github.com/splodingsocks/FlowTyped/pull/1#issuecomment-149345275
+    // and https://github.com/facebook/flow/issues/956
+    isEqual(1);
+
+    // $FlowExpectedError[extra-arg] function type expects no more than 2 arguments
+    isEqual(1, 2, 3);
+  });
+
+  it('isString', () => {
+    var boolTrue: true;
+    var boolFalse: false;
+    boolTrue = isString("foo");
+    boolFalse = isString([""]);
+    boolFalse = isString({});
+    boolFalse = isString(5);
+    boolFalse = isString(function(f) {
+      return f;
+    });
+    boolFalse = isString();
+    boolFalse = isString(true);
+
+    // $FlowExpectedError[incompatible-type]
+    boolFalse = isString("");
+    // $FlowExpectedError[incompatible-type]
+    boolTrue = isString(undefined);
+  });
+
+  it('conformsTo', () => {
+    (conformsTo({ a: 1, b: 2 }, { b: function(n: number) { return true; }}): boolean);
+  });
+});
+
+describe('Math', () => {
+});
+
+describe('Number', () => {
+});
+
+describe('Object', () => {
+  it('extend', () => {
+    extend({ a: 1 }, { b: 2 }).a;
+    extend({ a: 1 }, { b: 2 }).b;
+    // $FlowExpectedError[incompatible-use] property `c`. Property not found in object literal
+    extend({ a: 1 }, { b: 2 }).c;
+    // $FlowExpectedError[incompatible-use] property `c`. Poperty not found in object literal
+    assignIn({ a: 1 }, { b: 2 }).c;
+  });
+
+  it('get', () => {
+    // Object — examples from lodash docs
+    var exampleObjectForGetTest = { a: [{ b: { c: 3 } }] };
+    get(exampleObjectForGetTest, "a[0].b.c");
+    get(exampleObjectForGetTest, ["a", "0", "b", "c"]);
+    get(exampleObjectForGetTest, "a.b.c", "default");
+
+    // Array — not documented, but _.get does support arrays
+    get([1, 2, 3], "0");
+    get([1, 2, 3], 0);
+    get([1, 2, 3], [0]);
+    get(["foo", "bar", "baz"], "[1]");
+    get([{ a: "foo" }, { b: "bar" }, { c: "baz" }], "2");
+    get([[1, 2], [3, 4], [5, 6], [7, 8]], "3");
+
+    // Nil - it is safe to perform on nil root values, just like nil values along the "get" path
+    get(null, "thing");
+    get(undefined, "data");
+  });
+
+  it('keys', () => {
+    function Foo() {
+      this.a = 1;
+      this.b = 2;
+    }
+    Foo.prototype.c = 3;
+
+    (keys(new Foo): string[]);
+    (keys('hi'): string[]);
+  });
+
+  it('omitBy', () => {
+    (omitBy({ a: 2, b: 3, c: 4 }, num => num % 2): { [prop: string]: number, ... });
+    (omitBy(null, num => num % 2): {...});
+    (omitBy(undefined, num => num % 2): {...});
+    (omitBy({ [1]: 1, [2]: 2 }, num => num === 2): { [prop: number]: number, ... });
+  });
+
+  it('pick', () => {
+    (pick({ a: 2, b: 3, c: 4 }, 'a'): { [prop: string]: number, ... });
+    (pick(null, 'a'): {...});
+    (pick(undefined, 'a'): {...});
+    (pick({ [1]: 1, [2]: 2 }, 'a'): { [prop: number]: number, ... });
+
+    // $FlowExpectedError[incompatible-call]
+    pick({ a: 2 }, 1);
+  });
+
+  it('pickBy', () => {
+    (pickBy({ a: 2, b: 3, c: 4 }, num => num % 2): { [prop: string]: number, ... });
+    (pickBy(null, num => num % 2): {...});
+    (pickBy(undefined, num => num % 2): {...});
+    (pickBy({ [1]: 1, [2]: 2 }, num => num === 2): { [prop: number]: number, ... });
+    (pickBy(readOnlyIndexerObject, num => num === 2): { [prop: number]: number, ... });
+  });
+
+  it('toPairs / _.toPairsIn', () => {
+    var pairs: [string, number][];
+    pairs = toPairs({ a: 12, b: 100 });
+    pairs = toPairsIn({ a: 12, b: 100 });
+  });
+});
+
+describe('Seq', () => {
+  it('tap', () => {
+    (tap(1, n => false): number);
+  });
+
+  it('thru', () => {
+    (thru(1, n => false): boolean);
+  });
+});
+
+describe('String', () => {
+})
+
+describe('Util', () => {
+  it('attempt', () => {
+    attempt(() => void 0);
+    attempt(x => x);
+    attempt(x => x, "first arg");
+    attempt((x, y, z) => {}, null, {}, []);
+  });
+
+  it('defaultTo', () => {
+    (defaultTo(undefined, 2): number);
+    (defaultTo(undefined, "str"): string);
+    (defaultTo(true, "str"): boolean);
+    (defaultTo("str", true): string);
+  });
+
+  it('noop', () => {
+    noop();
+    noop(1);
+    noop("a", 2, [], null);
+    (noop: string => void);
+    (noop: (number, string) => void);
+    // $FlowExpectedError[incompatible-cast] functions are contravariant in return types
+    (noop: string => string);
+  });
+
+  it('range', () => {
+    range(0, 10)[4] == 4;
+    // $FlowExpectedError[incompatible-call] string. This type is incompatible with number
+    range(0, "a");
+    // $FlowExpectedError[invalid-compare] string cannot be compared to number
+    range(0, 10)[4] == "a";
+  });
+
+  it('times', () => {
+    (times(5): number[]);
+    // $FlowExpectedError[incompatible-cast] string. This type is incompatible with number
+    (times(5): string[]);
+    (times(5, (i: number) => i + 1): number[]);
+    // $FlowExpectedError[incompatible-cast] string. This type is incompatible with number
+    (times(5, (i: number) => JSON.stringify(i)): number[]);
+  });
+});
diff --git a/definitions/npm/memory-cache_v0.x.x/flow_v0.201.x-/memory-cache_v0.x.x.js b/definitions/npm/memory-cache_v0.x.x/flow_v0.201.x-/memory-cache_v0.x.x.js
new file mode 100644
index 0000000000..ab17c331d1
--- /dev/null
+++ b/definitions/npm/memory-cache_v0.x.x/flow_v0.201.x-/memory-cache_v0.x.x.js
@@ -0,0 +1,19 @@
+declare module 'memory-cache' {
+  declare class MemoryCache {
+  	put(key: string, value: any, time?: number, timeoutCallback?: (key: string, value: any) => void): void;
+    : (key: string) => any;
+    del(key: string): boolean;
+    clear(): void;
+    size(): number;
+    memsize(): number;
+    debug(debug: boolean): void;
+    hits(): number;
+    misses(): number;
+    keys(): string[];
+    exportJson(): string;
+    importJson(json: string, options?: { skipDuplicates: boolean, ... }): number;
+    Cache(): MemoryCache;
+  }
+
+  declare export default MemoryCache;
+}
diff --git a/definitions/npm/memory-cache_v0.x.x/flow_v0.99.x-/memory-cache_v0.x.x.js b/definitions/npm/memory-cache_v0.x.x/flow_v0.99.x-v.200.x/memory-cache_v0.x.x.js
similarity index 100%
rename from definitions/npm/memory-cache_v0.x.x/flow_v0.99.x-/memory-cache_v0.x.x.js
rename to definitions/npm/memory-cache_v0.x.x/flow_v0.99.x-v.200.x/memory-cache_v0.x.x.js
diff --git a/definitions/npm/mongoose_v4.x.x/flow_v0.104.x-/mongoose_v4.x.x.js b/definitions/npm/mongoose_v4.x.x/flow_v0.104.x-v.200.x/mongoose_v4.x.x.js
similarity index 100%
rename from definitions/npm/mongoose_v4.x.x/flow_v0.104.x-/mongoose_v4.x.x.js
rename to definitions/npm/mongoose_v4.x.x/flow_v0.104.x-v.200.x/mongoose_v4.x.x.js
diff --git a/definitions/npm/mongoose_v4.x.x/flow_v0.104.x-/test_mongoose-v4.js b/definitions/npm/mongoose_v4.x.x/flow_v0.104.x-v.200.x/test_mongoose-v4.js
similarity index 100%
rename from definitions/npm/mongoose_v4.x.x/flow_v0.104.x-/test_mongoose-v4.js
rename to definitions/npm/mongoose_v4.x.x/flow_v0.104.x-v.200.x/test_mongoose-v4.js
diff --git a/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/mongoose_v4.x.x.js b/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/mongoose_v4.x.x.js
new file mode 100644
index 0000000000..350f65391c
--- /dev/null
+++ b/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/mongoose_v4.x.x.js
@@ -0,0 +1,560 @@
+/*** FIX broken globals import 'bson' (((( ***/
+// import 'bson';
+declare class bson$ObjectId {
+  constructor(id?: string | number | bson$ObjectId): this;
+  generationTime: number;
+  static createFromHexString(hexString: string): bson$ObjectId;
+  static createFromTime(time: number): bson$ObjectId;
+  static isValid(id?: string | number | bson$ObjectId | null | void): boolean;
+  equals(otherID: bson$ObjectId): boolean;
+  generate(time?: number): string;
+  getTimestamp(): Date;
+  toHexString(): string;
+  toString(): string;
+  inspect(): string;
+  toJSON(): string;
+}
+declare class bson$Decimal128 {
+  constructor(bytes: Buffer): this;
+  static fromString(string: string): bson$Decimal128;
+  toString(): string;
+  toJSON(): { $numberDecimal: string, ... };
+}
+/*** end FIX broken globals import 'bson' (((( ***/
+
+type MongoId = bson$ObjectId | string | number;
+
+type Mongoose$Types = {|
+  ObjectId: Class<bson$ObjectId>,
+  Mixed: Object,
+  Embedded: Object,
+  Document: Object,
+  DocumentArray: Object,
+  Subdocument: Object,
+  Array: Object,
+  Buffer: Object,
+  Decimal128: Class<bson$Decimal128>
+|};
+
+type SchemaFields = { [fieldName: string]: any, ... };
+
+type ToObjectOpts<Doc> = {
+  getters?: boolean,
+  virtuals?: boolean,
+  minimize?: boolean,
+  transform?: (doc: Doc, ret: Object, options: Object) => any,
+  depopulate?: boolean,
+  versionKey?: boolean,
+  retainKeyOrder?: boolean,
+  ...
+};
+
+type SchemaOpts<Doc> = {
+  autoIndex?: boolean,
+  bufferCommands?: boolean,
+  capped?: boolean,
+  collection?: string,
+  emitIndexErrors?: boolean,
+  id?: boolean,
+  _id?: boolean,
+  minimize?: boolean,
+  read?: string,
+  safe?: boolean,
+  shardKey?: boolean,
+  strict?: boolean,
+  toJSON?: ToObjectOpts<Doc>,
+  toObject?: ToObjectOpts<Doc>,
+  typeKey?: string,
+  useNestedStrict?: boolean,
+  validateBeforeSave?: boolean,
+  versionKey?: string | false,
+  timestamps?:
+    | boolean
+    | {
+    createdAt?: string,
+    updatedAt?: string,
+    ...
+  },
+  discriminatorKey?: string,
+  ...
+};
+
+type IndexFields = { [fieldName: string]: 1 | -1 | true | false | string, ... };
+
+type IndexOpts = {|
+  background?: boolean,
+  unique?: boolean,
+  sparse?: boolean,
+  partialFilterExpression?: Object,
+  name?: string,
+  default_language?: string,
+  weights?: Object
+|};
+
+type Mongoose$SchemaMethods = { [name: string]: Function, ... };
+
+type Mongoose$SchemaStatics = { [name: string]: Function, ... };
+
+type VirtualType = Object;
+
+type Mongoose$SchemaHookTypes =
+  | "save"
+  | "validate"
+  | "find"
+  | "findOne"
+  | "count"
+  | "update"
+  | "remove"
+  | "findOneAndRemove"
+  | "findOneAndUpdate"
+  | "init";
+
+type Mongoose$SchemaPlugin<Opts> = (
+  schema: Mongoose$Schema<any>,
+  opts: Opts
+) => void;
+
+declare class Mongoose$Schema<Doc> {
+  static Types: Mongoose$Types;
+  constructor(
+    fields: SchemaFields,
+    opts?: SchemaOpts<Doc>
+  ): Mongoose$Schema<Doc>;
+  index(fields: IndexFields, opts?: IndexOpts): this;
+  methods: Mongoose$SchemaMethods;
+  statics: Mongoose$SchemaStatics;
+  virtual(fieldName: string): Mongoose$SchemaVirtualField;
+  pre(
+    hookType: Mongoose$SchemaHookTypes,
+    serialCb: (next: Function) => any
+  ): void;
+  pre(
+    hookType: Mongoose$SchemaHookTypes,
+    true,
+    parallelCb: (next: Function, done: Function) => any
+  ): void;
+  // post(hookType: Mongoose$SchemaHookTypes, parallelCb: (doc: Doc) => any): void;
+  post(
+    hookType: Mongoose$SchemaHookTypes,
+    serialCb: (doc: Doc, next: Function) => any
+  ): void;
+  // post(hookType: Mongoose$SchemaHookTypes, serialCb: (error: Error, doc: Doc, next: Function) => any): void;
+  plugin<Opts>(plugin: Mongoose$SchemaPlugin<Opts>, opts: Opts): void;
+  add(fields: SchemaFields, prefix?: string): void;
+  loadClass(cls: Class<Doc>): void;
+  paths: { [name: string]: Mongoose$SchemaField<this>, ... };
+  clone(): Mongoose$Schema<Doc>;
+  eachPath(fn: (path: string, fieldOpts: Object) => void): this;
+  get(optionKey: string): any;
+  set(optionKey: string, value: any): void;
+  indexes(): ?Array<[string, IndexOpts]>;
+  path(path: string): Object;
+  path(path: string, schemaType: Object): void;
+  pathType(path: string): string;
+  remove(path: string | string[]): void;
+  requiredPaths(invalidate?: boolean): string[];
+  method(method: string, fn: Function): this;
+  method(methods: { [method: string]: Function, ... }): this;
+  static (method: string, fn: Function): this;
+  static (methods: { [method: string]: Function, ... }): this;
+  virtual(name: string, opts?: Object): VirtualType;
+  virtualpath(name: string): ?VirtualType;
+  indexTypes(): string[];
+  reserved: string[];
+  obj: SchemaOpts<Doc>;
+  _indexes: Array<
+    [{ [fieldName: string]: number | string, ... }, { [optionName: string]: mixed, ... }]
+  >;
+}
+
+type Mongoose$SchemaField<Schema> = {
+  path?: string,
+  instance: string,
+  caster?: ?Mongoose$SchemaField<Schema>,
+  options?: ?{ description: ?string, ... },
+  enumValues?: ?(string[]),
+  schema?: Schema,
+  _index?: ?{ [optionName: string]: mixed, ... },
+  ...
+};
+
+declare class Mongoose$SchemaVirtualField {
+  get(() => any): this;
+  set((value: any) => any): this;
+}
+
+type MongooseProjection = Object | string;
+
+type UpdateResult = {
+  nMatched: number,
+  nUpserted: number,
+  nModified: number,
+  ok?: boolean,
+  ...
+};
+
+declare class Mongoose$Document {
+  static find(
+    criteria?: Object,
+    projection?: MongooseProjection,
+    options?: Object
+  ): Mongoose$Query<Array<this>, this>;
+  static findOne(
+    criteria?: Object,
+    projection?: MongooseProjection
+  ): Mongoose$Query<?this, this>;
+  static findById(
+    id: MongoId,
+    projection?: MongooseProjection,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findOneAndRemove(
+    criteria: ?Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findOneAndUpdate(
+    criteria: ?Object,
+    data: Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findByIdAndRemove(
+    id: MongoId,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findByIdAndUpdate(
+    id: MongoId,
+    data: Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static count(criteria?: Object): Promise<number>;
+  static remove(criteria: Object): Promise<mixed>;
+  static update(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static updateOne(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static updateMany(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static create(doc: $Shape<this> | Array<$Shape<this>>): Promise<this>;
+  static where(criteria?: Object): Mongoose$Query<this, this>;
+  static aggregate(pipeline: Object[]): Aggregate$Query;
+  static bulkWrite(ops: Object[]): Promise<any>;
+  static deleteMany(criteria: Object): Promise<any>;
+  static deleteOne(criteria: Object): Promise<any>;
+  static distinct(field: string, criteria?: Object): Promise<any>;
+  static ensureIndexes(opts?: Object): Promise<any>;
+  static hydrate(data: Object): Mongoose$Document;
+  static insertMany(docs: Object | Object[], opts?: Object): Promise<any>;
+  static mapReduce(o: Object): Promise<any>;
+  static collection: Mongoose$Collection;
+  static db: any;
+  static modelName: string;
+  static schema: Mongoose$Schema<this>;
+  static on(type: string, cb: Function): void;
+  static discriminator(name: string, schema: Mongoose$Schema<any>): Class<this>;
+
+  collection: Mongoose$Collection;
+  constructor(data?: $Shape<this>): this;
+  id: string | number;
+  _id: bson$ObjectId | string | number;
+  __v?: number;
+  save(): Promise<this>;
+  update(update: Object, options?: Object): Promise<UpdateResult>;
+  set(data: $Shape<this>): this;
+  set(path: string, val: any, type?: any, options?: Object): this;
+  isSelected(fieldName: string): boolean;
+  validate(opts?: Object): Promise<any>;
+  validateSync(pathsToValidate: string | string[]): Error | void;
+  errors: Object;
+  isNew: boolean;
+  schema: Mongoose$Schema<this>;
+
+  $ignore(path: string): void;
+  $isDefault(path: string): boolean;
+  depopulate(path: string): this;
+  equals(doc: Mongoose$Document): boolean;
+  get(path: string, type?: Object): any;
+
+  inspect(): Object;
+  invalidate(
+    path: string,
+    errorMsg: string | Error,
+    value?: any,
+    kind?: string
+  ): ValidationError;
+  isDirectModified(path: string): boolean;
+  isDirectSelected(path: string): boolean;
+  isInit(path: string): boolean;
+  isModified(path?: string): boolean;
+  isSelected(path: string): boolean;
+  markModified(path: string): void;
+  modifiedPaths(): string[];
+
+  populate(path?: string | Object, cb?: (err: Error, doc: this) => void): void;
+  execPopulate(): Promise<this>;
+  populated(path: string): ?MongoId;
+  toJSON(options?: ToObjectOpts<this>): Object;
+  toObject(options?: ToObjectOpts<this>): Object;
+  toString(): string;
+  unmarkModified(path: string): void;
+
+  increment(): void;
+  remove(): Promise<this>;
+}
+
+type ValidationError = Object;
+
+// Try to replace `Mongoose$Query<Result, Doc>` on `this` in Flow above v0.53
+// For better dropdown suggesting used `Mongoose$Query<Result, Doc>`
+//   Fast check: `User.find().limit(5).` does not suggest if used `this`
+declare class Mongoose$Query<Result, Doc> extends Promise<Result> {
+  exec(): Promise<Result>;
+  where(criteria: Object): Mongoose$Query<Result, Doc>;
+  sort(fields: Object | string): Mongoose$Query<Result, Doc>;
+  limit(n: number): Mongoose$Query<Result, Doc>;
+  skip(n: number): Mongoose$Query<Result, Doc>;
+  select(fields: MongooseProjection): Mongoose$Query<Result, Doc>;
+  setOptions(opts: Object): Mongoose$Query<Result, Doc>;
+  update(data: Object): Mongoose$Query<any, Doc>;
+  update(
+    criteria: Object,
+    data: Object,
+    opts?: {
+      safe?: boolean,
+      upsert?: boolean,
+      multi?: boolean,
+      runValidators?: boolean,
+      setDefaultsOnInsert?: boolean,
+      strict?: boolean,
+      overwrite?: boolean,
+      ...
+    }
+  ): Mongoose$Query<any, Doc>;
+  updateMany(
+    criteria: Object,
+    data: Object,
+    opts?: Object
+  ): Mongoose$Query<any, Doc>;
+  updateOne(
+    criteria: Object,
+    data: Object,
+    opts?: Object
+  ): Mongoose$Query<any, Doc>;
+  remove(criteria?: Object): Mongoose$Query<?Doc, Doc>;
+  count(criteria?: Object): Promise<number>;
+  schema: Mongoose$Schema<Doc>;
+  $where(fn: Function): Mongoose$Query<Result, Doc>;
+  batchSize(n: number): Mongoose$Query<Result, Doc>;
+  collation(value: Object): Mongoose$Query<Result, Doc>;
+  comment(val: string): Mongoose$Query<Result, Doc>;
+  cursor(opts?: Object): Mongoose$QueryCursor<Doc>;
+  deleteMany(criteria?: Object): Mongoose$Query<any, Doc>;
+  deleteOne(criteria?: Object): Mongoose$Query<any, Doc>;
+  distinct(field: string, criteria?: Object): Mongoose$Query<Result, Doc>;
+  find(criteria: Object): Mongoose$Query<Result, Doc>;
+  findOne(criteria?: Object, projection?: Object): Mongoose$Query<?Doc, Doc>;
+  findOneAndRemove(
+    criteria: Object,
+    opts?: {
+      sort?: Object,
+      maxTimeMS?: number,
+      passRawResult?: boolean,
+      ...
+    }
+  ): Mongoose$Query<?Doc, Doc>;
+  findOneAndUpdate(
+    criteria: Object,
+    data: Object,
+    opts?: {
+      new?: boolean,
+      upsert?: boolean,
+      fields?: Object | string,
+      maxTimeMS?: number,
+      runValidators?: boolean,
+      setDefaultsOnInsert?: boolean,
+      passRawResult?: boolean,
+      runSettersOnQuery?: boolean,
+      ...
+    }
+  ): Mongoose$Query<?Doc, Doc>;
+  getQuery(): Object;
+  getUpdate(): Object;
+  hint(index: Object): Mongoose$Query<Result, Doc>;
+  lean(passPlainObject?: boolean): Mongoose$Query<any, Doc>;
+  maxScan(n: number): Mongoose$Query<Result, Doc>;
+  populate(path: string): Mongoose$Query<Result, Doc>;
+  populate(obj: {
+    path: string,
+    select?: string,
+    match?: Object,
+    options?: Object,
+    ...
+  }): Mongoose$Query<Result, Doc>;
+  read(
+    pref:
+      | "primary"
+      | "secondary"
+      | "primaryPreferred"
+      | "secondaryPreferred"
+      | "nearest",
+    tags?: Object[]
+  ): Mongoose$Query<Result, Doc>;
+  selected(): boolean;
+  selectedExclusively(): boolean;
+  selectedInclusively(): boolean;
+  setOptions(options: Object): Mongoose$Query<Result, Doc>;
+  slice(
+    path: string,
+    val: number | [number, number]
+  ): Mongoose$Query<Result, Doc>;
+  snapshot(bool: boolean): Mongoose$Query<Result, Doc>;
+  stream(opts?: Object): Mongoose$QueryStream;
+  tailable(bool: boolean, opts?: Object): Mongoose$Query<Result, Doc>;
+  toConstructor(): Class<Mongoose$Query<Result, Doc>>;
+}
+
+declare class Aggregate$Query extends Promise<any> {
+  exec(): Promise<any>;
+  allowDiskUse(bool: boolean): Aggregate$Query;
+  addCursorFlag(str: string, bool: boolean): Aggregate$Query;
+  addFields(opts?: Object): Aggregate$Query;
+  append(opts?: Object): Aggregate$Query;
+  collation(opts?: Object): Aggregate$Query;
+  count(str: string): Promise<number>;
+  cursor(opts?: Object): Mongoose$QueryCursor<Object>;
+  exec(cb?:Function): Promise<any>;
+  explain(cb?:Function): Aggregate$Query;
+  facet(opts?: Object): Aggregate$Query;
+  graphLookup(opts?: Object): Aggregate$Query;
+  group(opts?: Object): Aggregate$Query;
+  hint(opts?: Object): Aggregate$Query;
+  limit(n: number): Aggregate$Query;
+  lookup(opts?: Object): Aggregate$Query;
+  match(opts?: Object): Aggregate$Query;
+  model(opts?: Object): Aggregate$Query;
+  near(opts?: Object): Aggregate$Query;
+  option(opts?: Object): Aggregate$Query;
+  pipeline(): Object[];
+  project(opts?: Object): Aggregate$Query;
+  read(str: string): Aggregate$Query;
+  replaceRoot(opts?: Object): Aggregate$Query;
+  sample(n: number): Aggregate$Query;
+  skip(n: number): Aggregate$Query;
+  sort(options: {...} | string): Aggregate$Query;
+  sortByCount(options: {...} | string): Aggregate$Query;
+  unwind(str: string): Aggregate$Query;
+}
+
+declare class Mongoose$QueryCursor<Doc> {
+  on(type: "data" | "end" | string, cb: Function): void;
+  next(cb?: (err: Error, doc: Doc) => void): Promise<?Doc>;
+}
+
+declare class Mongoose$QueryStream {
+  destroy(): void;
+  pause(): void;
+  pipe(): void;
+  resume(): void;
+  paused: boolean;
+  readable: boolean;
+  on(event: "data" | "error" | "close", cb: Function): void;
+}
+
+declare class Mongoose$Collection {
+  constructor(name: string, conn: Mongoose$Connection, opts?: Object): this;
+  ensureIndex(): any;
+  find(): any;
+  findAndModify(): any;
+  findOne(): any;
+  getIndexes(): any;
+  insert(): any;
+  mapReduce(): any;
+  save(): any;
+  update(): any;
+  collectionName: string;
+  conn: Mongoose$Connection;
+  name: string;
+}
+
+type ConnectionConnectOpts = {
+  promiseLibrary?: any,
+  autoReconnect?: boolean,
+  reconnectTries?: number,
+  reconnectInterval?: number,
+  useMongoClient?: boolean,
+  config?: { autoIndex?: boolean, ... },
+  ...
+};
+type ConnectionEventTypes = "error" | "open" | "disconnected" | string;
+
+declare class Mongoose$Connection {
+  constructor(): this;
+  close(): Promise<any>;
+  connect(uri: string, opts?: ConnectionConnectOpts): void;
+  openUri(uri: string, opts?: ConnectionConnectOpts): void;
+  model<Doc>(
+    name: string | Doc,
+    schema?: Mongoose$Schema<Doc>,
+    collection?: Mongoose$Collection
+  ): Class<Doc>;
+  collection(name: string): Mongoose$Collection;
+  modelNames(): string[];
+  config: Object;
+  db: any;
+  collections: Mongoose$Collection[];
+  readyState: number;
+  models: { [name: string]: Mongoose$Document, ... };
+
+  // EventEmitter
+  addListener(event: ConnectionEventTypes, listener: Function): this;
+  emit(event: ConnectionEventTypes, ...args: Array<any>): boolean;
+  eventNames(): Array<ConnectionEventTypes>;
+  listeners(event: ConnectionEventTypes): Array<Function>;
+  listenerCount(event: ConnectionEventTypes): number;
+  on(event: ConnectionEventTypes, listener: Function): this;
+  once(event: ConnectionEventTypes, listener: Function): this;
+  prependListener(event: ConnectionEventTypes, listener: Function): this;
+  prependOnceListener(event: ConnectionEventTypes, listener: Function): this;
+  removeAllListeners(event?: ConnectionEventTypes): this;
+  removeListener(event: ConnectionEventTypes, listener: Function): this;
+  setMaxListeners(n: number): this;
+  getMaxListeners(): number;
+}
+
+declare module "mongoose" {
+  declare export type MongooseConnection = Mongoose$Connection;
+  declare export type MongoId = MongoId;
+  declare export type BSONObjectId = bson$ObjectId;
+  declare export type ObjectId = bson$ObjectId;
+  declare export type MongooseQuery<Result, Doc> = Mongoose$Query<Result, Doc>;
+  declare export type MongooseDocument = Mongoose$Document;
+  declare export type MongooseModel = typeof Mongoose$Document;
+  declare export type MongooseSchema<Doc> = Mongoose$Schema<Doc>;
+  declare export type MongooseSchemaField<Schema> = Mongoose$SchemaField<
+    Schema
+  >;
+
+  declare module.exports: {
+    Schema: typeof Mongoose$Schema,
+    Types: Mongoose$Types,
+    Promise: any,
+    model: $PropertyType<Mongoose$Connection, "model">,
+    createConnection(uri?: string, options?: Object): Mongoose$Connection,
+    set: (key: string, value: string | Function | boolean) => void,
+    connect: (uri: string, options?: Object) => void,
+    connection: Mongoose$Connection,
+    connections: Mongoose$Connection[],
+    Query: typeof Mongoose$Query,
+    disconnect: (fn?: (error: any) => void) => Promise<void>,
+    Model: typeof Mongoose$Document,
+    ...
+  };
+}
diff --git a/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/test_mongoose-v4.js b/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/test_mongoose-v4.js
new file mode 100644
index 0000000000..ddbaa42961
--- /dev/null
+++ b/definitions/npm/mongoose_v4.x.x/flow_v0.201.x-/test_mongoose-v4.js
@@ -0,0 +1,136 @@
+// @flow
+
+import mongoose, { Schema } from "mongoose";
+
+export const AdminSchema = new Schema(
+  {
+    _id: String,
+    email: {
+      type: String,
+      set: (v: string) => v.toLowerCase().trim(),
+      required: true
+    },
+    token: {
+      type: String,
+      required: true
+    },
+    name: String
+  },
+  {
+    timestamps: true,
+    collection: "admin"
+  }
+);
+
+AdminSchema.index({ email: 1 }, { background: true });
+
+AdminSchema.pre("save", function(next) {
+  this._id = this.email;
+  next();
+});
+
+export class AdminDoc /*:: extends Mongoose$Document */ {
+  email: string;
+  token: string;
+  name: ?string;
+
+  // internal properties
+  _plainPassword: ?string;
+
+  static test(ok: number): string {
+    return ok.toString();
+  }
+
+  // NOT SUPPORTED in flow-typed tests
+  // But will work with your code if you add in your .flowconfig
+  //   [options]
+  //   unsafe.enable_getters_and_setters=true
+  //
+  // get password(): ?string {
+  //   return this._plainPassword;
+  // }
+  //
+  // set password(password: string): void {
+  //   this._plainPassword = password;
+  //   this.token = this.encryptPassword(password);
+  // }
+  //
+  // get fullname(): string {
+  //   const fullname = [];
+  //   if (this.lastname) fullname.push(this.lastname);
+  //   if (this.name) fullname.push(this.name);
+  //   if (this.middlename) fullname.push(this.middlename);
+  //   return fullname.join(' ');
+  // }
+
+  encryptPassword(password: string): string {
+    return "bcrypt.hashSync(password, 13)";
+  }
+
+  checkPassword(password: string): boolean {
+    return !!"bcrypt.compareSync(password, this.token)";
+  }
+}
+
+AdminSchema.loadClass(AdminDoc);
+
+AdminSchema.post("save", (doc, next) => {
+  doc.name = "Abc";
+  // $FlowExpectedError
+  doc.name = 123;
+  next();
+});
+
+export const Admin = mongoose.model("Admin", AdminSchema);
+
+Admin.findById(1).then(d => {
+  if (d) {
+    // $FlowExpectedError
+    d.checkPassword(123);
+  }
+});
+
+Admin.test(123);
+// $FlowExpectedError
+Admin.test("123");
+
+const a = Admin.findOne({})
+  .exec()
+  .then(ddd => {
+    if (ddd) {
+      ddd.checkPassword("123");
+      // $FlowExpectedError
+      ddd.checkPassword(123);
+    }
+  });
+
+const a1 = new Admin({ email: "123", token: "www" });
+// $FlowExpectedError
+const a2 = new Admin({ email: 123, token: "www" });
+
+
+Admin.aggregate([ { $project : { email : 1 } } ]).allowDiskUse(true).exec()
+
+//
+export const UserSchema = new Schema(
+  {
+    email: {
+      type: String,
+      match: /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/,
+      set: (v: string) => v.toLowerCase().trim(),
+      required: true
+    },
+    name: String
+  },
+  {
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at"
+    },
+    collection: "admin"
+  }
+);
+
+mongoose.disconnect(err => console.log("err"));
+
+mongoose.disconnect().then(data => console.log(data));
diff --git a/definitions/npm/mongoose_v5.x.x/flow_v0.104.x-/mongoose_v5.x.x.js b/definitions/npm/mongoose_v5.x.x/flow_v0.104.x-v.200.x/mongoose_v5.x.x.js
similarity index 100%
rename from definitions/npm/mongoose_v5.x.x/flow_v0.104.x-/mongoose_v5.x.x.js
rename to definitions/npm/mongoose_v5.x.x/flow_v0.104.x-v.200.x/mongoose_v5.x.x.js
diff --git a/definitions/npm/mongoose_v5.x.x/flow_v0.104.x-/test_mongoose-v5.js b/definitions/npm/mongoose_v5.x.x/flow_v0.104.x-v.200.x/test_mongoose-v5.js
similarity index 100%
rename from definitions/npm/mongoose_v5.x.x/flow_v0.104.x-/test_mongoose-v5.js
rename to definitions/npm/mongoose_v5.x.x/flow_v0.104.x-v.200.x/test_mongoose-v5.js
diff --git a/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/mongoose_v5.x.x.js b/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/mongoose_v5.x.x.js
new file mode 100644
index 0000000000..b791c1ff66
--- /dev/null
+++ b/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/mongoose_v5.x.x.js
@@ -0,0 +1,607 @@
+/*** FIX broken globals import 'bson' (((( ***/
+// import 'bson';
+declare class bson$ObjectId {
+  constructor(id?: string | number | bson$ObjectId): this;
+  generationTime: number;
+  static createFromHexString(hexString: string): bson$ObjectId;
+  static createFromTime(time: number): bson$ObjectId;
+  static isValid(id?: string | number | bson$ObjectId | null | void): boolean;
+  equals(otherID: bson$ObjectId): boolean;
+  generate(time?: number): string;
+  getTimestamp(): Date;
+  toHexString(): string;
+  toString(): string;
+  inspect(): string;
+  toJSON(): string;
+}
+declare class bson$Decimal128 {
+  constructor(bytes: Buffer): this;
+  static fromString(string: string): bson$Decimal128;
+  toString(): string;
+  toJSON(): { $numberDecimal: string, ... };
+}
+/*** end FIX broken globals import 'bson' (((( ***/
+
+type MongoId = bson$ObjectId | string | number;
+
+type Mongoose$Types = {|
+  ObjectId: Class<bson$ObjectId>,
+  Mixed: Object,
+  Embedded: Object,
+  Document: Object,
+  DocumentArray: Object,
+  Subdocument: Object,
+  Array: Object,
+  Buffer: Object,
+  Decimal128: Class<bson$Decimal128>
+|};
+
+type SchemaFields = { [fieldName: string]: any, ... };
+
+type ToObjectOpts<Doc> = {
+  getters?: boolean,
+  virtuals?: boolean,
+  minimize?: boolean,
+  transform?: (doc: Doc, ret: Object, options: Object) => any,
+  depopulate?: boolean,
+  versionKey?: boolean,
+  retainKeyOrder?: boolean,
+  ...
+};
+
+type SchemaOpts<Doc> = {
+  autoIndex?: boolean,
+  bufferCommands?: boolean,
+  capped?: boolean,
+  collection?: string,
+  emitIndexErrors?: boolean,
+  id?: boolean,
+  _id?: boolean,
+  minimize?: boolean,
+  read?: string,
+  safe?: boolean,
+  shardKey?: boolean,
+  strict?: boolean | 'throw',
+  strictQuery?: boolean | 'throw',
+  toJSON?: ToObjectOpts<Doc>,
+  toObject?: ToObjectOpts<Doc>,
+  typeKey?: string,
+  useNestedStrict?: boolean,
+  validateBeforeSave?: boolean,
+  versionKey?: string | false,
+  timestamps?:
+    | boolean
+    | {
+    createdAt?: string,
+    updatedAt?: string,
+    ...
+  },
+  discriminatorKey?: string,
+  ...
+};
+
+type IndexFields = { [fieldName: string]: 1 | -1 | true | false | string, ... };
+
+type IndexOpts = {|
+  background?: boolean,
+  unique?: boolean,
+  sparse?: boolean,
+  partialFilterExpression?: Object,
+  name?: string,
+  default_language?: string,
+  weights?: Object
+|};
+
+type Mongoose$SchemaMethods = { [name: string]: Function, ... };
+
+type Mongoose$SchemaStatics = { [name: string]: Function, ... };
+
+type VirtualType = Object;
+
+type Mongoose$SchemaHookTypes =
+  | "save"
+  | "validate"
+  | "find"
+  | "findOne"
+  | "count"
+  | "update"
+  | "remove"
+  | "findOneAndRemove"
+  | "findOneAndUpdate"
+  | "init";
+
+type Mongoose$SchemaPlugin<Opts> = (
+  schema: Mongoose$Schema<any>,
+  opts: Opts
+) => void;
+
+declare class MongoDBClientSession {
+  id: string;
+  abortTransaction(): Promise<any>;
+  advanceOperationTime(operationTime: any): void;
+  commitTransaction(): Promise<any>;
+  endSession(opts?: Object): Promise<any>;
+  equals(session: MongoDBClientSession): boolean;
+  incrementTransactionNumber(): void;
+  inTransaction(): boolean;
+  startTransaction(opts?: Object): void;
+}
+
+declare class Mongoose$Schema<Doc> {
+  static Types: Mongoose$Types;
+  constructor(
+    fields: SchemaFields,
+    opts?: SchemaOpts<Doc>
+  ): Mongoose$Schema<Doc>;
+  index(fields: IndexFields, opts?: IndexOpts): this;
+  methods: Mongoose$SchemaMethods;
+  statics: Mongoose$SchemaStatics;
+  virtual(fieldName: string): Mongoose$SchemaVirtualField;
+  pre(
+    hookType: Mongoose$SchemaHookTypes,
+    serialCb: (next: Function) => any
+  ): void;
+  pre(
+    hookType: Mongoose$SchemaHookTypes,
+    true,
+    parallelCb: (next: Function, done: Function) => any
+  ): void;
+  // post(hookType: Mongoose$SchemaHookTypes, parallelCb: (doc: Doc) => any): void;
+  post(
+    hookType: Mongoose$SchemaHookTypes,
+    serialCb: (doc: Doc, next: Function) => any
+  ): void;
+  // post(hookType: Mongoose$SchemaHookTypes, serialCb: (error: Error, doc: Doc, next: Function) => any): void;
+  plugin<Opts>(plugin: Mongoose$SchemaPlugin<Opts>, opts: Opts): void;
+  add(fields: SchemaFields, prefix?: string): void;
+  loadClass(cls: Class<Doc>): void;
+  paths: { [name: string]: Mongoose$SchemaField<this>, ... };
+  clone(): Mongoose$Schema<Doc>;
+  eachPath(fn: (path: string, fieldOpts: Object) => void): this;
+  get(optionKey: string): any;
+  set(optionKey: string, value: any): void;
+  indexes(): ?Array<[string, IndexOpts]>;
+  path(path: string): Object;
+  path(path: string, schemaType: Object): void;
+  pathType(path: string): string;
+  remove(path: string | string[]): void;
+  requiredPaths(invalidate?: boolean): string[];
+  method(method: string, fn: Function): this;
+  method(methods: { [method: string]: Function, ... }): this;
+  static (method: string, fn: Function): this;
+  static (methods: { [method: string]: Function, ... }): this;
+  virtual(name: string, opts?: Object): VirtualType;
+  virtualpath(name: string): ?VirtualType;
+  indexTypes(): string[];
+  reserved: string[];
+  obj: SchemaOpts<Doc>;
+  _indexes: Array<
+    [{ [fieldName: string]: number | string, ... }, { [optionName: string]: mixed, ... }]
+  >;
+}
+
+type Mongoose$SchemaField<Schema> = {
+  path?: string,
+  instance: string,
+  caster?: ?Mongoose$SchemaField<Schema>,
+  options?: ?{ description: ?string, ... },
+  enumValues?: ?(string[]),
+  schema?: Schema,
+  _index?: ?{ [optionName: string]: mixed, ... },
+  ...
+};
+
+declare class Mongoose$SchemaVirtualField {
+  get(() => any): this;
+  set((value: any) => any): this;
+}
+
+type MongooseProjection = Object | string;
+
+type UpdateResult = {
+  nMatched: number,
+  nUpserted: number,
+  nModified: number,
+  ok?: boolean,
+  ...
+};
+
+// A list of Model static methods: http://mongoosejs.com/docs/api.html#Model
+declare class Mongoose$Document {
+  static aggregate(pipeline: Object[]): Aggregate$Query;
+  static bulkWrite(opts: Object[]): Promise<any>;
+  static count(criteria?: Object): Promise<number>;
+  static countDocuments(criteria?: Object): Promise<number>;
+  static create(doc: $Shape<this> | Array<$Shape<this>>): Promise<this>;
+  static deleteMany(criteria: Object): Promise<any>;
+  static deleteOne(criteria: Object): Promise<any>;
+  static discriminator(name: string, schema: Mongoose$Schema<any>): Class<this>;
+  static distinct(field: string, criteria?: Object): Promise<any>;
+  static ensureIndexes(opts?: Object): Promise<any>;
+  static estimatedDocumentCount(opts?: Object): Promise<number>;
+  static find(
+    criteria?: Object,
+    projection?: MongooseProjection,
+    options?: Object
+  ): Mongoose$Query<Array<this>, this>;
+  static findById(
+    id: MongoId,
+    projection?: MongooseProjection,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findByIdAndDelete(
+    id: MongoId,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findByIdAndRemove(
+    id: MongoId,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findByIdAndUpdate(
+    id: MongoId,
+    data: Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findOne(
+    criteria?: Object,
+    projection?: MongooseProjection
+  ): Mongoose$Query<?this, this>;
+  static findOneAndDelete(
+    criteria: ?Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findOneAndRemove(
+    criteria: ?Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static findOneAndUpdate(
+    criteria: ?Object,
+    data: Object,
+    options?: Object
+  ): Mongoose$Query<?this, this>;
+  static geoSearch(
+    conditions: Object,
+    opts: {
+      near: [number, number],
+      maxDistance: number,
+      limit?: number,
+      lean?: boolean,
+      ...
+    }
+  ): Promise<Array<this>>;
+  static hydrate(data: Object): Mongoose$Document;
+  static init(): Promise<Object>;
+  static insertMany(docs: Object | Object[], opts?: Object): Promise<any>;
+  static listIndexes(): Promise<Array<any>>;
+  static mapReduce(o: Object): Promise<any>;
+  static populate(
+    doc: Mongoose$Document | Array<Mongoose$Document>,
+    options: Object
+  ): Promise<Mongoose$Document | Array<Mongoose$Document>>;
+  static remove(criteria: Object): Promise<mixed>;
+  static replaceOne(
+    conditions: Object,
+    doc: Mongoose$Document
+  ): Mongoose$Query<?this, this>;
+  static startSession(opts?: Object): Promise<MongoDBClientSession>;
+  static syncIndexes(opts?: Object): Promise<any>;
+  static update(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static updateMany(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static updateOne(
+    criteria: Object,
+    update: Object,
+    options?: Object
+  ): Promise<UpdateResult> & { exec(): Promise<UpdateResult>, ... };
+  static watch(pipeline?: Array<any>, opts?: Object): events$EventEmitter;
+  static where(criteria?: Object): Mongoose$Query<this, this>;
+  static collection: Mongoose$Collection;
+  static db: any;
+  static modelName: string;
+  static schema: Mongoose$Schema<this>;
+  static on(type: string, cb: Function): void;
+
+  collection: Mongoose$Collection;
+  constructor(data?: $Shape<this>): this;
+  id: string | number;
+  _id: bson$ObjectId | string | number;
+  __v?: number;
+  save(): Promise<this>;
+  update(update: Object, options?: Object): Promise<UpdateResult>;
+  set(data: $Shape<this>): this;
+  set(path: string, val: any, type?: any, options?: Object): this;
+  isSelected(fieldName: string): boolean;
+  validate(opts?: Object): Promise<any>;
+  validateSync(pathsToValidate: string | string[]): Error | void;
+  errors: Object;
+  isNew: boolean;
+  schema: Mongoose$Schema<this>;
+
+  $ignore(path: string): void;
+  $isDefault(path: string): boolean;
+  depopulate(path: string): this;
+  equals(doc: Mongoose$Document): boolean;
+  get(path: string, type?: Object): any;
+
+  inspect(): Object;
+  invalidate(
+    path: string,
+    errorMsg: string | Error,
+    value?: any,
+    kind?: string
+  ): ValidationError;
+  isDirectModified(path: string): boolean;
+  isDirectSelected(path: string): boolean;
+  isInit(path: string): boolean;
+  isModified(path?: string): boolean;
+  isSelected(path: string): boolean;
+  markModified(path: string): void;
+  modifiedPaths(): string[];
+
+  populate(path?: string | Object, cb?: (err: Error, doc: this) => void): void;
+  execPopulate(): Promise<this>;
+  populated(path: string): ?MongoId;
+  toJSON(options?: ToObjectOpts<this>): Object;
+  toObject(options?: ToObjectOpts<this>): Object;
+  toString(): string;
+  unmarkModified(path: string): void;
+
+  increment(): void;
+  remove(): Promise<this>;
+}
+
+type ValidationError = Object;
+
+// Try to replace `Mongoose$Query<Result, Doc>` on `this` in Flow above v0.53
+// For better dropdown suggesting used `Mongoose$Query<Result, Doc>`
+//   Fast check: `User.find().limit(5).` does not suggest if used `this`
+declare class Mongoose$Query<Result, Doc> extends Promise<Result> {
+  exec(): Promise<Result>;
+  where(criteria: Object): Mongoose$Query<Result, Doc>;
+  sort(fields: Object | string): Mongoose$Query<Result, Doc>;
+  limit(n: number): Mongoose$Query<Result, Doc>;
+  skip(n: number): Mongoose$Query<Result, Doc>;
+  select(fields: MongooseProjection): Mongoose$Query<Result, Doc>;
+  setOptions(opts: Object): Mongoose$Query<Result, Doc>;
+  update(data: Object): Mongoose$Query<any, Doc>;
+  update(
+    criteria: Object,
+    data: Object,
+    opts?: {
+      safe?: boolean,
+      upsert?: boolean,
+      multi?: boolean,
+      runValidators?: boolean,
+      setDefaultsOnInsert?: boolean,
+      strict?: boolean,
+      overwrite?: boolean,
+      ...
+    }
+  ): Mongoose$Query<any, Doc>;
+  updateMany(
+    criteria: Object,
+    data: Object,
+    opts?: Object
+  ): Mongoose$Query<any, Doc>;
+  updateOne(
+    criteria: Object,
+    data: Object,
+    opts?: Object
+  ): Mongoose$Query<any, Doc>;
+  remove(criteria?: Object): Mongoose$Query<?Doc, Doc>;
+  count(criteria?: Object): Promise<number>;
+  schema: Mongoose$Schema<Doc>;
+  $where(fn: Function): Mongoose$Query<Result, Doc>;
+  batchSize(n: number): Mongoose$Query<Result, Doc>;
+  collation(value: Object): Mongoose$Query<Result, Doc>;
+  comment(val: string): Mongoose$Query<Result, Doc>;
+  cursor(opts?: Object): Mongoose$QueryCursor<Doc>;
+  deleteMany(criteria?: Object): Mongoose$Query<any, Doc>;
+  deleteOne(criteria?: Object): Mongoose$Query<any, Doc>;
+  distinct(field: string, criteria?: Object): Mongoose$Query<Result, Doc>;
+  find(criteria: Object): Mongoose$Query<Result, Doc>;
+  findOne(criteria?: Object, projection?: Object): Mongoose$Query<?Doc, Doc>;
+  findOneAndRemove(
+    criteria: Object,
+    opts?: {
+      sort?: Object,
+      maxTimeMS?: number,
+      passRawResult?: boolean,
+      ...
+    }
+  ): Mongoose$Query<?Doc, Doc>;
+  findOneAndUpdate(
+    criteria: Object,
+    data: Object,
+    opts?: {
+      new?: boolean,
+      upsert?: boolean,
+      fields?: Object | string,
+      maxTimeMS?: number,
+      runValidators?: boolean,
+      setDefaultsOnInsert?: boolean,
+      passRawResult?: boolean,
+      runSettersOnQuery?: boolean,
+      ...
+    }
+  ): Mongoose$Query<?Doc, Doc>;
+  getQuery(): Object;
+  getUpdate(): Object;
+  hint(index: Object): Mongoose$Query<Result, Doc>;
+  lean(passPlainObject?: boolean): Mongoose$Query<any, Doc>;
+  maxScan(n: number): Mongoose$Query<Result, Doc>;
+  populate(path: string): Mongoose$Query<Result, Doc>;
+  populate(obj: {
+    path: string,
+    select?: string,
+    match?: Object,
+    options?: Object,
+    ...
+  }): Mongoose$Query<Result, Doc>;
+  read(
+    pref:
+      | "primary"
+      | "secondary"
+      | "primaryPreferred"
+      | "secondaryPreferred"
+      | "nearest",
+    tags?: Object[]
+  ): Mongoose$Query<Result, Doc>;
+  selected(): boolean;
+  selectedExclusively(): boolean;
+  selectedInclusively(): boolean;
+  setOptions(options: Object): Mongoose$Query<Result, Doc>;
+  slice(
+    path: string,
+    val: number | [number, number]
+  ): Mongoose$Query<Result, Doc>;
+  snapshot(bool: boolean): Mongoose$Query<Result, Doc>;
+  stream(opts?: Object): Mongoose$QueryStream;
+  tailable(bool: boolean, opts?: Object): Mongoose$Query<Result, Doc>;
+  toConstructor(): Class<Mongoose$Query<Result, Doc>>;
+}
+
+declare class Aggregate$Query extends Promise<any> {
+  exec(): Promise<any>;
+  allowDiskUse(bool: boolean): Aggregate$Query;
+  addCursorFlag(str: string, bool: boolean): Aggregate$Query;
+  addFields(opts?: Object): Aggregate$Query;
+  append(opts?: Object): Aggregate$Query;
+  collation(opts?: Object): Aggregate$Query;
+  count(str: string): Promise<number>;
+  cursor(opts?: Object): Mongoose$QueryCursor<Object>;
+  exec(cb?: Function): Promise<any>;
+  explain(cb?: Function): Aggregate$Query;
+  facet(opts?: Object): Aggregate$Query;
+  graphLookup(opts?: Object): Aggregate$Query;
+  group(opts?: Object): Aggregate$Query;
+  hint(opts?: Object): Aggregate$Query;
+  limit(n: number): Aggregate$Query;
+  lookup(opts?: Object): Aggregate$Query;
+  match(opts?: Object): Aggregate$Query;
+  model(opts?: Object): Aggregate$Query;
+  near(opts?: Object): Aggregate$Query;
+  option(opts?: Object): Aggregate$Query;
+  pipeline(): Object[];
+  project(opts?: Object): Aggregate$Query;
+  read(str: string): Aggregate$Query;
+  replaceRoot(opts?: Object): Aggregate$Query;
+  sample(n: number): Aggregate$Query;
+  skip(n: number): Aggregate$Query;
+  sort(options: {...} | string): Aggregate$Query;
+  sortByCount(options: {...} | string): Aggregate$Query;
+  unwind(str: string): Aggregate$Query;
+}
+
+declare class Mongoose$QueryCursor<Doc> {
+  on(type: "data" | "end" | string, cb: Function): void;
+  next(cb?: (err: Error, doc: Doc) => void): Promise<?Doc>;
+}
+
+declare class Mongoose$QueryStream {
+  destroy(): void;
+  pause(): void;
+  pipe(): void;
+  resume(): void;
+  paused: boolean;
+  readable: boolean;
+  on(event: "data" | "error" | "close", cb: Function): void;
+}
+
+declare class Mongoose$Collection {
+  constructor(name: string, conn: Mongoose$Connection, opts?: Object): this;
+  ensureIndex(): any;
+  find(): any;
+  findAndModify(): any;
+  findOne(): any;
+  getIndexes(): any;
+  insert(): any;
+  mapReduce(): any;
+  save(): any;
+  update(): any;
+  collectionName: string;
+  conn: Mongoose$Connection;
+  name: string;
+}
+
+type ConnectionConnectOpts = {
+  promiseLibrary?: any,
+  autoReconnect?: boolean,
+  reconnectTries?: number,
+  reconnectInterval?: number,
+  useMongoClient?: boolean,
+  config?: { autoIndex?: boolean, ... },
+  ...
+};
+type ConnectionEventTypes = "error" | "open" | "disconnected" | string;
+
+declare class Mongoose$Connection {
+  constructor(): this;
+  close(): Promise<any>;
+  connect(uri: string, opts?: ConnectionConnectOpts, fn?: (error: any) => void): Promise<Mongoose$Connection>;
+  openUri(uri: string, opts?: ConnectionConnectOpts): void;
+  model<Doc>(
+    name: string | Doc,
+    schema?: Mongoose$Schema<Doc>,
+    collection?: Mongoose$Collection
+  ): Class<Doc>;
+  collection(name: string): Mongoose$Collection;
+  modelNames(): string[];
+  config: Object;
+  db: any;
+  collections: Mongoose$Collection[];
+  readyState: number;
+  models: { [name: string]: Mongoose$Document, ... };
+
+  // EventEmitter
+  addListener(event: ConnectionEventTypes, listener: Function): this;
+  emit(event: ConnectionEventTypes, ...args: Array<any>): boolean;
+  eventNames(): Array<ConnectionEventTypes>;
+  listeners(event: ConnectionEventTypes): Array<Function>;
+  listenerCount(event: ConnectionEventTypes): number;
+  on(event: ConnectionEventTypes, listener: Function): this;
+  once(event: ConnectionEventTypes, listener: Function): this;
+  prependListener(event: ConnectionEventTypes, listener: Function): this;
+  prependOnceListener(event: ConnectionEventTypes, listener: Function): this;
+  removeAllListeners(event?: ConnectionEventTypes): this;
+  removeListener(event: ConnectionEventTypes, listener: Function): this;
+  setMaxListeners(n: number): this;
+  getMaxListeners(): number;
+}
+
+declare module "mongoose" {
+  declare export type MongooseConnection = Mongoose$Connection;
+  declare export type MongoId = MongoId;
+  declare export type BSONObjectId = bson$ObjectId;
+  declare export type ObjectId = bson$ObjectId;
+  declare export type MongooseQuery<Result, Doc> = Mongoose$Query<Result, Doc>;
+  declare export type MongooseDocument = Mongoose$Document;
+  declare export type MongooseModel = typeof Mongoose$Document;
+  declare export type MongooseSchema<Doc> = Mongoose$Schema<Doc>;
+  declare export type MongooseSchemaField<Schema> = Mongoose$SchemaField<
+    Schema
+  >;
+
+  declare module.exports: {
+    Schema: typeof Mongoose$Schema,
+    Types: Mongoose$Types,
+    Promise: any,
+    model: $PropertyType<Mongoose$Connection, "model">,
+    createConnection(uri?: string, options?: Object): Mongoose$Connection,
+    set: (key: string, value: string | Function | boolean) => void,
+    connect: (uri: string, options?: ConnectionConnectOpts, fn?: (error: any) => void) => Promise<Mongoose$Connection>,
+    connection: Mongoose$Connection,
+    connections: Mongoose$Connection[],
+    Query: typeof Mongoose$Query,
+    disconnect: (fn?: (error: any) => void) => Promise<void>,
+    Model: typeof Mongoose$Document,
+    ...
+  };
+}
diff --git a/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/test_mongoose-v5.js b/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/test_mongoose-v5.js
new file mode 100644
index 0000000000..5ffa3f9b0e
--- /dev/null
+++ b/definitions/npm/mongoose_v5.x.x/flow_v0.201.x-/test_mongoose-v5.js
@@ -0,0 +1,142 @@
+// @flow
+
+import mongoose, { Schema } from "mongoose";
+
+mongoose.connect('mongodb://host:port/dbname', error => {
+  console.log(error)
+})
+
+mongoose.connect('mongodb://host:port/dbname').then(data => (data: Mongoose$Connection))
+
+export const AdminSchema = new Schema(
+  {
+    _id: String,
+    email: {
+      type: String,
+      set: (v: string) => v.toLowerCase().trim(),
+      required: true
+    },
+    token: {
+      type: String,
+      required: true
+    },
+    name: String
+  },
+  {
+    timestamps: true,
+    collection: "admin"
+  }
+);
+
+AdminSchema.index({ email: 1 }, { background: true });
+
+AdminSchema.pre("save", function(next) {
+  this._id = this.email;
+  next();
+});
+
+export class AdminDoc /*:: extends Mongoose$Document */ {
+  email: string;
+  token: string;
+  name: ?string;
+
+  // internal properties
+  _plainPassword: ?string;
+
+  static test(ok: number): string {
+    return ok.toString();
+  }
+
+  // NOT SUPPORTED in flow-typed tests
+  // But will work with your code if you add in your .flowconfig
+  //   [options]
+  //   unsafe.enable_getters_and_setters=true
+  //
+  // get password(): ?string {
+  //   return this._plainPassword;
+  // }
+  //
+  // set password(password: string): void {
+  //   this._plainPassword = password;
+  //   this.token = this.encryptPassword(password);
+  // }
+  //
+  // get fullname(): string {
+  //   const fullname = [];
+  //   if (this.lastname) fullname.push(this.lastname);
+  //   if (this.name) fullname.push(this.name);
+  //   if (this.middlename) fullname.push(this.middlename);
+  //   return fullname.join(' ');
+  // }
+
+  encryptPassword(password: string): string {
+    return "bcrypt.hashSync(password, 13)";
+  }
+
+  checkPassword(password: string): boolean {
+    return !!"bcrypt.compareSync(password, this.token)";
+  }
+}
+
+AdminSchema.loadClass(AdminDoc);
+
+AdminSchema.post("save", (doc, next) => {
+  doc.name = "Abc";
+  // $FlowExpectedError
+  doc.name = 123;
+  next();
+});
+
+export const Admin = mongoose.model("Admin", AdminSchema);
+
+Admin.findById(1).then(d => {
+  if (d) {
+    // $FlowExpectedError
+    d.checkPassword(123);
+  }
+});
+
+Admin.test(123);
+// $FlowExpectedError
+Admin.test("123");
+
+const a = Admin.findOne({})
+  .exec()
+  .then(ddd => {
+    if (ddd) {
+      ddd.checkPassword("123");
+      // $FlowExpectedError
+      ddd.checkPassword(123);
+    }
+  });
+
+const a1 = new Admin({ email: "123", token: "www" });
+// $FlowExpectedError
+const a2 = new Admin({ email: 123, token: "www" });
+
+
+Admin.aggregate([ { $project : { email : 1 } } ]).allowDiskUse(true).exec()
+
+//
+export const UserSchema = new Schema(
+  {
+    email: {
+      type: String,
+      match: /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/,
+      set: (v: string) => v.toLowerCase().trim(),
+      required: true
+    },
+    name: String
+  },
+  {
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at"
+    },
+    collection: "admin"
+  }
+);
+
+mongoose.disconnect(err => console.log("err"));
+
+mongoose.disconnect().then(data => console.log(data));
diff --git a/definitions/npm/mysql_v2.x.x/flow_v0.104.x-/mysql_v2.x.x.js b/definitions/npm/mysql_v2.x.x/flow_v0.104.x-v.200.x/mysql_v2.x.x.js
similarity index 100%
rename from definitions/npm/mysql_v2.x.x/flow_v0.104.x-/mysql_v2.x.x.js
rename to definitions/npm/mysql_v2.x.x/flow_v0.104.x-v.200.x/mysql_v2.x.x.js
diff --git a/definitions/npm/mysql_v2.x.x/flow_v0.201.x-/mysql_v2.x.x.js b/definitions/npm/mysql_v2.x.x/flow_v0.201.x-/mysql_v2.x.x.js
new file mode 100644
index 0000000000..236f2cd6e1
--- /dev/null
+++ b/definitions/npm/mysql_v2.x.x/flow_v0.201.x-/mysql_v2.x.x.js
@@ -0,0 +1,191 @@
+// TODO: Events on event emitters
+// TODO: Ssl structure type in ConnectionOptions
+// TODO: PoolNamespace internal structure
+// TODO: Packets internal structure
+
+declare module "mysql" {
+  declare type TypeCastField = {
+    db: string,
+    table: string,
+    name: string,
+    type: string,
+    length: number,
+    string: () => string,
+    buffer: () => Buffer,
+    ...
+  }
+
+  declare type ConnectionOptions = {
+    host?: string,
+    port?: number,
+    localAddress?: string,
+    socketPath?: string,
+    user: string,
+    password: string,
+    database?: string,
+    charset?: string,
+    timezone?: string,
+    connectTimeout?: number,
+    stringifyObjects?: boolean,
+    insecureAuth?: boolean,
+    typeCast?: boolean | ((field: TypeCastField, next: () => mixed) => any),
+    queryFormat?: (query: string, values: ?mixed, timezone: string) => string,
+    supportBigNumbers?: boolean,
+    bigNumberStrings?: boolean,
+    dateStrings?: boolean | Array<string>,
+    // Array form contains ids of packets for logging
+    debug?: boolean | Array<string>,
+    trace?: boolean,
+    multipleStatements?: boolean,
+    flags?: string,
+    ssl?: string | {...},
+    ...
+  };
+
+  declare type QueryOptions = {
+    sql: string,
+    typeCast?: boolean | ((field: TypeCastField, next: () => mixed) => any),
+    // string form is a separator used to produce column names
+    nestTables?: boolean | string,
+    values?: Array<mixed>,
+    timeout?: number,
+    ...
+  } | string;
+
+  declare type QueryResults = Array<Object> & {
+    insertId?: string | number,
+    affectedRows?: number,
+    changedRows?: number,
+    ...
+  };
+
+  declare type QueryField = {
+    name: string,
+    type: string,
+    length: number,
+    table: string,
+    db: string,
+    ...
+  };
+
+  declare class Query extends events$EventEmitter {
+    // readableStreamOptions declared in Flow /lib/node.js
+    stream(options?: readableStreamOptions): stream$Readable;
+  }
+
+  declare class Connection extends events$EventEmitter {
+    threadId: number;
+    connect(callback?: (error: ?Error) => any): void;
+
+    release(): void;
+    destroy(): void;
+
+    end(callback?: (error: ?Error) => any): void;
+
+    query(
+      sql: QueryOptions,
+      values?: Array<mixed> | {...},
+      callback?: QueryCallback
+    ): Query;
+    query(sql: QueryOptions, callback?: QueryCallback): Query;
+
+    changeUser(
+      options: {
+        user?: string,
+        password?: string,
+        charset?: string,
+        database?: string,
+        ...
+      },
+      callback: (error: ?Error) => any
+    ): void;
+
+    beginTransaction(options: QueryOptions, callback: QueryCallback): void;
+    beginTransaction(callback: QueryCallback): void;
+    commit(options: QueryOptions, callback: QueryCallback): void;
+    commit(callback: QueryCallback): void;
+    rollback(options: QueryOptions, callback: QueryCallback): void;
+    rollback(callback: QueryCallback): void;
+
+    ping(options: QueryOptions, callback: QueryCallback): void;
+    ping(callback: QueryCallback): void;
+
+    escapeId(val: mixed, forbidQualified?: boolean): string;
+    escape(val: mixed, stringifyObjects?: boolean, timeZone?: string): string;
+    format(sql: string, valus: Array<mixed>): string;
+  }
+
+  declare class Pool extends events$EventEmitter {
+    getConnection(
+      callback: (error: ?Error, connection?: Connection) => any
+    ): void;
+    end(callback?: (error: ?Error) => any): void;
+    query(
+      sql: QueryOptions,
+      values?: Array<mixed>,
+      callback?: QueryCallback
+    ): Query;
+    query(sql: QueryOptions, callback?: QueryCallback): Query;
+
+    escapeId(val: mixed, forbidQualified?: boolean): string;
+    escape(val: mixed, stringifyObjects?: boolean, timeZone?: string): string;
+  }
+
+  declare type PoolOptions = ConnectionOptions & {
+    acquireTimeout?: number,
+    connectionLimit?: number,
+    waitForConnections?: boolean,
+    queueLimit?: number,
+    ...
+  };
+
+  declare type PoolClusterSelector = "RR" | "ORDER" | "RANDOM";
+
+  declare type PoolClusterOptions = {
+    defaultSelector?: PoolClusterSelector,
+    canRetry?: boolean,
+    removeNodeErrorCount?: number,
+    restoreNodeTimeout?: number,
+    ...
+  };
+
+  declare type QueryCallback = (error: ?Error, results: QueryResults, fields?: Array<QueryField>) => any;
+
+  declare class PoolCluster extends events$EventEmitter {
+    add(config: PoolOptions | string): void;
+    add(name: string, config: PoolOptions | string): void;
+    remove(name: string): void;
+
+    getConnection(
+      pattern: string | RegExp,
+      selector: PoolClusterSelector,
+      callback: (error: ?Error, connection?: Connection) => any
+    ): void;
+    getConnection(
+      pattern: string | RegExp,
+      callback: (error: ?Error, connection?: Connection) => any
+    ): void;
+    getConnection(
+      callback: (error: ?Error, connection?: Connection) => any
+    ): void;
+
+    // Truth to be told, of returns not a Pool, but PoolNamespace instance but it is the same for the most part
+    of(pattern: string | RegExp, selector?: PoolClusterSelector): Pool;
+
+    end(callback?: (error: ?Error) => any): void;
+  }
+
+  declare function escapeId(val: mixed, forbidQualified?: boolean): string;
+  declare function escape(
+    val: mixed,
+    stringifyObjects?: boolean,
+    timeZone?: string
+  ): string;
+  declare function format(sql: string, valus: Array<mixed>): string;
+  declare function createConnection(
+    options: ConnectionOptions | string
+  ): Connection;
+  declare function createPool(options: PoolOptions | string): Pool;
+  declare function createPoolCluster(options?: PoolClusterOptions): PoolCluster;
+  declare function raw(sql: string): { toSqlString: () => string, ... };
+}
diff --git a/definitions/npm/parse_v1.9.x/flow_v0.104.x-/parse_v1.9.x.js b/definitions/npm/parse_v1.9.x/flow_v0.104.x-v.200.x/parse_v1.9.x.js
similarity index 100%
rename from definitions/npm/parse_v1.9.x/flow_v0.104.x-/parse_v1.9.x.js
rename to definitions/npm/parse_v1.9.x/flow_v0.104.x-v.200.x/parse_v1.9.x.js
diff --git a/definitions/npm/parse_v1.9.x/flow_v0.201.x-/parse_v1.9.x.js b/definitions/npm/parse_v1.9.x/flow_v0.201.x-/parse_v1.9.x.js
new file mode 100644
index 0000000000..04380559e1
--- /dev/null
+++ b/definitions/npm/parse_v1.9.x/flow_v0.201.x-/parse_v1.9.x.js
@@ -0,0 +1,396 @@
+declare module 'parse/node' {
+  declare module.exports: $npm$parse$Parse
+}
+
+declare module 'parse/react-native' {
+  declare module.exports: $npm$parse$Parse
+}
+
+declare module 'parse' {
+  declare module.exports: $npm$parse$Parse
+}
+
+declare type $npm$parse$Parse = {
+  initialize(applicationId: string, javaScriptKey: ?string): void,
+  // TODO
+  Analytics: any,
+  ACL: Class<$npm$parse$ParseACL>,
+  Cloud: $npm$parse$ParseCloud,
+  // TODO
+  CoreManager: any,
+  Config: Class<$npm$parse$ParseConfig>,
+  Error: Class<$npm$parse$ParseError>,
+  // TODO
+  FacebookUtils: any,
+  File: Class<$npm$parse$ParseFile>,
+  GeoPoint: Class<$npm$parse$ParseGeoPoint>,
+  // TODO
+  Installation: any,
+  LiveQuery: any,
+  LiveQueryClient: any,
+  Object: Class<$npm$parse$ParseObject>,
+  // TODO
+  Promise: any,
+  // TODO
+  Push: any,
+  Relation: Class<$npm$parse$ParseRelation>,
+  Role: Class<$npm$parse$ParseRole>,
+  // TODO
+  Session: any,
+  // TODO
+  Storage: any,
+  Query: Class<$npm$parse$ParseQuery<any>>,
+  User: Class<$npm$parse$ParseUser>,
+  masterKey: ?string,
+  serverURL: ?string,
+  ...
+}
+
+declare type $npm$parse$AttributeMap = { [attr: string]: any, ... }
+
+declare type $npm$parse$RequestOptions = {
+  useMasterKey?: boolean,
+  sessionToken?: string,
+  installationId?: string,
+  ...
+}
+
+declare type $npm$parse$FullOptions = {
+  success?: any,
+  error?: any,
+  useMasterKey?: boolean,
+  sessionToken?: string,
+  installationId?: string,
+  ...
+}
+
+declare type $npm$parse$Pointer = {
+  __type: string,
+  className: string,
+  objectId: string,
+  ...
+}
+
+// =========================
+// ParseConfig
+// =========================
+declare class $npm$parse$ParseConfig {
+  static(): $npm$parse$ParseConfig,
+  constructor(): $npm$parse$ParseConfig,
+  attributes: { [key: string]: any, ... },
+  get(attr: string): any,
+  escape(attr: string): string,
+  static current(): $npm$parse$ParseConfig,
+  static get(options?: Object): Promise<$npm$parse$ParseConfig>
+}
+
+// =========================
+// ParseCloud
+// =========================
+declare type $npm$parse$ParseCloud = {
+  run(name: string, data?: mixed, options?: { [key: string]: mixed, ... }): Promise<any>,
+  define(name: string, cloudFunction: (request: $npm$parse$ParseCloud$FunctionRequest, response: $npm$parse$ParseCloud$FunctionResponse) => any): any,
+  beforeSave(className: string, trigger: any): any,
+  afterSave(className: string, trigger: any): any,
+  beforeDelete(className: string, trigger: any): any,
+  afterDelete(className: string, trigger: any): any,
+  beforeFind(className: string, trigger: any): any,
+  afterFind(className: string, trigger: any): any,
+  FunctionRequest: Class<$npm$parse$ParseCloud$FunctionRequest>,
+  FunctionResponse: Class<$npm$parse$ParseCloud$FunctionResponse>,
+  ...
+}
+
+declare class $npm$parse$ParseCloud$FunctionRequest {
+  installationId: string,
+  user: $npm$parse$ParseUser,
+  params: Object,
+  master: boolean,
+}
+
+declare class $npm$parse$ParseCloud$FunctionResponse {
+  error: Function,
+  success: Function
+}
+
+// =========================
+// ParseGeoPoint
+// =========================
+declare class $npm$parse$ParseGeoPoint {
+  static(arg1: Array<number> | {
+    latitude: number,
+    longitude: number,
+    ...
+  } | number, arg2?: number): $npm$parse$ParseGeoPoint,
+  constructor(arg1: Array<number> | {
+    latitude: number,
+    longitude: number,
+    ...
+  } | number, arg2?: number): $npm$parse$ParseGeoPoint,
+  toJSON(): {
+    __type: string,
+    latitude: number,
+    longitude: number,
+    ...
+  },
+  equals(other: mixed): boolean,
+  radiansTo(point: $npm$parse$ParseGeoPoint): number,
+  kilometersTo(point: $npm$parse$ParseGeoPoint): number,
+  milesTo(point: $npm$parse$ParseGeoPoint): number,
+  static current(options?: Object): void
+}
+
+// =========================
+// ParseQuery
+// =========================
+declare type $npm$parse$QueryJSON = {
+  where: { [attr: string]: mixed, ... },
+  include?: string,
+  keys?: string,
+  limit?: number,
+  skip?: number,
+  order?: string,
+  className?: string,
+  count?: number,
+  ...
+}
+
+declare class $npm$parse$ParseQuery<T> {
+  static(objectClass: string | T): $npm$parse$ParseQuery<T>,
+  constructor(objectClass: string | T): $npm$parse$ParseQuery<T>,
+  className: string,
+  toJSON(): $npm$parse$QueryJSON,
+  get(objectId: string, options?: $npm$parse$FullOptions): Promise<?T>,
+  find(options?: $npm$parse$FullOptions): Promise<Array<T>>,
+  count(options?: $npm$parse$FullOptions): number,
+  first(options?: $npm$parse$FullOptions): Promise<?T>,
+  each(callback: (obj: T) => any, options?: $npm$parse$FullOptions & { batchSize?: number, ... }): Promise<$npm$parse$ParseObject>,
+  equalTo(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  notEqualTo(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  lessThan(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  greaterThan(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  lessThanOrEqualTo(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  greaterThanOrEqualTo(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  containedIn(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  notContainedIn(key: string, value: mixed): $npm$parse$ParseQuery<T>,
+  containsAll(key: string, values: Array<mixed>): $npm$parse$ParseQuery<T>,
+  exists(key: string): $npm$parse$ParseQuery<T>,
+  doesNotExist(key: string): $npm$parse$ParseQuery<T>,
+  matches(key: string, regex: RegExp, modifiers: string): $npm$parse$ParseQuery<T>,
+  matchesQuery(key: string, query: $npm$parse$ParseQuery<T>): $npm$parse$ParseQuery<T>,
+  doesNotMatchQuery(key: string, query: $npm$parse$ParseQuery<T>): $npm$parse$ParseQuery<T>,
+  matchesKeyInQuery(key: string, queryKey: string, query: $npm$parse$ParseQuery<T>): $npm$parse$ParseQuery<T>,
+  doesNotMatchKeyInQuery(key: string, queryKey: string, query: $npm$parse$ParseQuery<T>): $npm$parse$ParseQuery<T>,
+  contains(key: string, value: string): $npm$parse$ParseQuery<T>,
+  startsWith(key: string, value: string): $npm$parse$ParseQuery<T>,
+  endsWith(key: string, value: string): $npm$parse$ParseQuery<T>,
+  near(key: string, point: $npm$parse$ParseGeoPoint): $npm$parse$ParseQuery<T>,
+  withinRadians(key: string, point: $npm$parse$ParseGeoPoint, distance: number): $npm$parse$ParseQuery<T>,
+  withinMiles(key: string, point: $npm$parse$ParseGeoPoint, distance: number): $npm$parse$ParseQuery<T>,
+  withinKilometers(key: string, point: $npm$parse$ParseGeoPoint, distance: number): $npm$parse$ParseQuery<T>,
+  withinGeoBox(key: string, southwest: $npm$parse$ParseGeoPoint, northeast: $npm$parse$ParseGeoPoint): $npm$parse$ParseQuery<T>,
+  ascending(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  addAscending(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  descending(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  addDescending(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  skip(n: number): $npm$parse$ParseQuery<T>,
+  limit(n: number): $npm$parse$ParseQuery<T>,
+  include(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  select(...keys: Array<string>): $npm$parse$ParseQuery<T>,
+  subscribe(): any,
+  static or(...queries: Array<$npm$parse$ParseQuery<T>>): $npm$parse$ParseQuery<T>
+}
+
+// =========================
+// ParseFile
+// =========================
+declare type $npm$parse$Base64 = { $npm$parse$Base64: string, ... }
+declare type $npm$parse$FileData = Array<number> | $npm$parse$Base64 | File
+declare type $npm$parse$FileSource = {
+  format: 'file',
+  file: File,
+  type: string,
+  ...
+} | {
+  format: '$npm$parse$Base64',
+  $npm$parse$Base64: string,
+  type: string,
+  ...
+}
+
+declare class $npm$parse$ParseFile {
+  static(name: string, data?: $npm$parse$FileData, type?: string): $npm$parse$ParseFile,
+  constructor(name: string, data?: $npm$parse$FileData, type?: string): $npm$parse$ParseFile,
+  name(): string,
+  url(options?: { forceSecure?: boolean, ... }): ?string,
+  save(options?: {
+    success?: any,
+    error?: any,
+    ...
+  }): Promise<$npm$parse$ParseFile>,
+  toJSON(): {
+    name: ?string,
+    url: ?string,
+    ...
+  },
+  equals(other: mixed): boolean
+}
+
+// =========================
+// ParseACL
+// =========================
+declare type $npm$parse$PermissionsMap = { [permission: string]: boolean, ... }
+declare type $npm$parse$ByIdMap = { [userId: string]: $npm$parse$PermissionsMap, ... }
+
+declare class $npm$parse$ParseACL {
+  permissionsById: $npm$parse$ByIdMap,
+  static(arg1?: $npm$parse$ParseUser | $npm$parse$ByIdMap): $npm$parse$ParseACL,
+  constructor(arg1?: $npm$parse$ParseUser | $npm$parse$ByIdMap): $npm$parse$ParseACL,
+  toJSON(): $npm$parse$ByIdMap,
+  equals(other: $npm$parse$ParseACL): boolean,
+  setReadAccess(userId: $npm$parse$ParseUser | $npm$parse$ParseRole | string, allowed: boolean): void,
+  getReadAccess(userId: $npm$parse$ParseUser | $npm$parse$ParseRole | string): boolean,
+  setWriteAccess(userId: $npm$parse$ParseUser | $npm$parse$ParseRole | string, allowed: boolean): void,
+  getWriteAccess(userId: $npm$parse$ParseUser | $npm$parse$ParseRole | string): boolean,
+  setPublicReadAccess(allowed: boolean): void,
+  getPublicReadAccess(): boolean,
+  setPublicWriteAccess(allowed: boolean): void,
+  getPublicWriteAccess(): boolean,
+  getRoleReadAccess(role: $npm$parse$ParseRole | string): boolean,
+  getRoleWriteAccess(role: $npm$parse$ParseRole | string): boolean,
+  setRoleReadAccess(role: $npm$parse$ParseRole | string, allowed: boolean): void,
+  setRoleWriteAccess(role: $npm$parse$ParseRole | string, allowed: boolean): void
+}
+
+// =========================
+// ParseObject
+// =========================
+declare class $npm$parse$ParseObject {
+  static(className: ?string | {
+    [attr: string]: mixed,
+    className: string,
+    ...
+  }, attributes?: { [attr: string]: mixed, ... }, options?: { ignoreValidation: boolean, ... }): $npm$parse$ParseObject,
+  constructor(className: ?string | {
+    [attr: string]: mixed,
+    className: string,
+    ...
+  }, attributes?: { [attr: string]: mixed, ... }, options?: { ignoreValidation: boolean, ... }): $npm$parse$ParseObject,
+  id: string,
+  createdAt: Date,
+  updatedAt: Date,
+  attributes: Object,
+  className: string,
+  toJSON(seen: Array<any> | void): $npm$parse$AttributeMap,
+  equals(other: mixed): boolean,
+  dirty(attr?: string): boolean,
+  dirtyKeys(): Array<string>,
+  to$npm$parse$Pointer(): $npm$parse$Pointer,
+  get(string: string): any,
+  relation(attr: string): $npm$parse$ParseRelation,
+  escape(attr: string): string,
+  has(attr: string): boolean,
+  set(key: mixed, value: mixed, options?: mixed): $npm$parse$ParseObject | boolean,
+  unset(attr: string, options?: { [opt: string]: mixed, ... }): $npm$parse$ParseObject | boolean,
+  increment(attr: string, amount?: number): $npm$parse$ParseObject | boolean,
+  add(attr: string, item: mixed): $npm$parse$ParseObject | boolean,
+  addUnique(attr: string, item: mixed): $npm$parse$ParseObject | boolean,
+  remove(attr: string, item: mixed): $npm$parse$ParseObject | boolean,
+  clone(): any,
+  newInstance(): any,
+  isNew(): boolean,
+  existed(): boolean,
+  isValid(): boolean,
+  validate(attrs: $npm$parse$AttributeMap): $npm$parse$ParseError | boolean,
+  getACL(): ?$npm$parse$ParseACL,
+  setACL(acl: $npm$parse$ParseACL, options?: mixed): $npm$parse$ParseObject | boolean,
+  revert(): void,
+  clear(): $npm$parse$ParseObject | boolean,
+  fetch(options: $npm$parse$RequestOptions): Promise<any>,
+  save(arg1: ?string | { [attr: string]: mixed, ... }, arg2?: $npm$parse$FullOptions, arg3?: $npm$parse$FullOptions): Promise<$npm$parse$ParseObject>,
+  destroy(options: ?$npm$parse$RequestOptions): Promise<any>,
+  static fetchAll(list: Array<$npm$parse$ParseObject>, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseObject>,
+  static fetchAllIfNeeded(list: Array<$npm$parse$ParseObject>, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseObject>,
+  static destroyAll(list: Array<$npm$parse$ParseObject>, options?: $npm$parse$RequestOptions): any,
+  static saveAll(list: Array<$npm$parse$ParseObject>, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseObject>,
+  static createWithoutData(id: string): $npm$parse$ParseObject,
+  static fromJSON(json: Object, override: boolean): $npm$parse$ParseObject,
+  static registerSubclass(className: string, constructor: Class<$npm$parse$ParseObject>): void,
+  // static extend(className: any, protoProps: any, classProps: any): Class<$npm$parse$ParseObject>,
+  static enableSingleInstance(): void,
+  static disableSingleInstance(): void
+}
+
+// =========================
+// ParseUser
+// =========================
+declare class $npm$parse$ParseUser extends $npm$parse$ParseObject {
+  static(attributes: ?$npm$parse$AttributeMap): $npm$parse$ParseUser,
+  constructor(attributes: ?$npm$parse$AttributeMap): $npm$parse$ParseUser,
+  isCurrent(): boolean,
+  getUsername(): string,
+  setUsername(username: string): void,
+  setPassword(password: string): void,
+  getEmail(): ?string,
+  setEmail(email: string): void,
+  getSessionToken(): string,
+  authenticated(): boolean,
+  signUp(attrs?: $npm$parse$AttributeMap, options?: $npm$parse$FullOptions): Promise<$npm$parse$ParseUser>,
+  logIn(options?: $npm$parse$FullOptions): Promise<$npm$parse$ParseUser>,
+  save(...args: Array<any>): Promise<$npm$parse$ParseUser>,
+  destroy(...args: Array<any>): Promise<$npm$parse$ParseUser>,
+  fetch(...args: Array<any>): Promise<$npm$parse$ParseUser>,
+  static readOnlyAttributes(): void,
+  static extend(protoProps: { [prop: string]: any, ... }, classProps: { [prop: string]: any, ... }): void,
+  static current(): ?$npm$parse$ParseUser,
+  static currentAsync(): Promise<?$npm$parse$ParseUser>,
+  static signUp(username: string, password: string, attrs?: $npm$parse$AttributeMap, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseUser>,
+  static logIn(username: string, password: string, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseUser>,
+  static become(sessionToken: string, options?: $npm$parse$RequestOptions): Promise<$npm$parse$ParseUser>,
+  static logOut(): Promise<void>,
+  static requestPasswordReset(email: string, options?: $npm$parse$RequestOptions): void,
+  static allowCustomUserClass(isAllowed: boolean): void,
+  static enableRevocableSession(options?: $npm$parse$RequestOptions): void,
+  static enableUnsafeCurrentUser(): void,
+  static disableUnsafeCurrentUser(): void
+}
+
+// =========================
+// ParseRelation
+// =========================
+declare class $npm$parse$ParseRelation {
+  static(parent: ?$npm$parse$ParseObject, key: ?string): $npm$parse$ParseRelation,
+  constructor(parent: ?$npm$parse$ParseObject, key: ?string): $npm$parse$ParseRelation,
+  parent: ?$npm$parse$ParseObject,
+  add(objects: $npm$parse$ParseObject | Array<$npm$parse$ParseObject | string>): $npm$parse$ParseObject,
+  remove(objects: $npm$parse$ParseObject | Array<$npm$parse$ParseObject | string>): void,
+  toJSON(): {
+    __type: 'Relation',
+    className: ?string,
+    ...
+  },
+  query(): $npm$parse$ParseQuery<any>
+}
+
+// =========================
+// ParseError
+// =========================
+declare class $npm$parse$ParseError {
+  static(code: ?number, message: ?string): $npm$parse$ParseError,
+  constructor(code: ?number, message: ?string): $npm$parse$ParseError,
+  code: ?number,
+  message: ?string
+}
+
+// =========================
+// ParseRole
+// =========================
+declare class $npm$parse$ParseRole extends $npm$parse$ParseObject {
+  static(name: string, acl: $npm$parse$ParseACL): $npm$parse$ParseRole,
+  constructor(name: string, acl: $npm$parse$ParseACL): $npm$parse$ParseRole,
+  getName(): ?string,
+  setName(name: string, options?: $npm$parse$RequestOptions): $npm$parse$ParseObject | boolean,
+  getUsers(): $npm$parse$ParseRelation,
+  getRoles(): $npm$parse$ParseRelation,
+  validate(attrs: $npm$parse$AttributeMap, options?: $npm$parse$RequestOptions): $npm$parse$ParseError | boolean
+}
diff --git a/definitions/npm/pify_v3.x.x/flow_v0.104.x-/pify_v3.x.x.js b/definitions/npm/pify_v3.x.x/flow_v0.104.x-v.200.x/pify_v3.x.x.js
similarity index 100%
rename from definitions/npm/pify_v3.x.x/flow_v0.104.x-/pify_v3.x.x.js
rename to definitions/npm/pify_v3.x.x/flow_v0.104.x-v.200.x/pify_v3.x.x.js
diff --git a/definitions/npm/pify_v3.x.x/flow_v0.201.x-/pify_v3.x.x.js b/definitions/npm/pify_v3.x.x/flow_v0.201.x-/pify_v3.x.x.js
new file mode 100644
index 0000000000..300ad34507
--- /dev/null
+++ b/definitions/npm/pify_v3.x.x/flow_v0.201.x-/pify_v3.x.x.js
@@ -0,0 +1,20 @@
+type $npm$pify$CPSFunction = (...args: any[]) => any;
+
+type $npm$pify$Options = {
+  multiArgs?: boolean,
+  include?: Array<string | RegExp>,
+  exclude?: Array<string | RegExp>,
+  excludeMain?: boolean,
+  errorFirst?: boolean,
+  promiseModule?: () => any,
+  ...
+};
+
+type $npm$pify$PromisifiedFunction = (...args: any[]) => Promise<any>;
+
+declare module "pify" {
+  declare module.exports: (
+    input: $npm$pify$CPSFunction | Object,
+    options?: $npm$pify$Options
+  ) => (...args: any[]) => Promise<any> | Object;
+}
diff --git a/definitions/npm/prettier_v1.x.x/flow_v0.104.x-/prettier_v1.x.x.js b/definitions/npm/prettier_v1.x.x/flow_v0.104.x-v.200.x/prettier_v1.x.x.js
similarity index 100%
rename from definitions/npm/prettier_v1.x.x/flow_v0.104.x-/prettier_v1.x.x.js
rename to definitions/npm/prettier_v1.x.x/flow_v0.104.x-v.200.x/prettier_v1.x.x.js
diff --git a/definitions/npm/prettier_v1.x.x/flow_v0.104.x-/test_prettier_v1.x.x.js b/definitions/npm/prettier_v1.x.x/flow_v0.104.x-v.200.x/test_prettier_v1.x.x.js
similarity index 100%
rename from definitions/npm/prettier_v1.x.x/flow_v0.104.x-/test_prettier_v1.x.x.js
rename to definitions/npm/prettier_v1.x.x/flow_v0.104.x-v.200.x/test_prettier_v1.x.x.js
diff --git a/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/prettier_v1.x.x.js b/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/prettier_v1.x.x.js
new file mode 100644
index 0000000000..8f26df1c3c
--- /dev/null
+++ b/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/prettier_v1.x.x.js
@@ -0,0 +1,225 @@
+declare module "prettier" {
+  declare export type AST = { [key: string]: any, ... };
+  declare export type Doc = {
+    [key: string]: any,
+    ...
+  };
+  declare export type FastPath<T = any> = {
+    stack: any[],
+    getName(): null | string | number | Symbol,
+    getValue(): T,
+    getNode(count?: number): null | T,
+    getParentNode(count?: number): null | T,
+    call<U>(callback: (path: FastPath<T>) => U, ...names: Array<string | number | Symbol>): U,
+    each(callback: (path: FastPath<T>) => void, ...names: Array<string | number | Symbol>): void,
+    map<U>(callback: (path: FastPath<T>, index: number) => U, ...names: Array<string | number | Symbol>): U[],
+    ...
+  };
+
+  declare export type PrettierParserName =
+    | "babylon" // deprecated
+    | "babel"
+    | "babel-flow"
+    | "flow"
+    | "typescript"
+    | "postcss" // deprecated
+    | "css"
+    | "less"
+    | "scss"
+    | "json"
+    | "json5"
+    | "json-stringify"
+    | "graphql"
+    | "markdown"
+    | "vue"
+    | "html"
+    | "angular"
+    | "mdx"
+    | "yaml";
+
+  declare export type PrettierParser = {
+    [name: PrettierParserName]: (text: string, options?: { [key: string]: any, ... }) => AST,
+    ...
+  };
+
+  declare export type CustomParser = (
+    text: string,
+    parsers: PrettierParser,
+    options: Options
+  ) => AST;
+
+  declare export type Options = {|
+    printWidth?: number,
+    tabWidth?: number,
+    useTabs?: boolean,
+    semi?: boolean,
+    singleQuote?: boolean,
+    trailingComma?: "none" | "es5" | "all",
+    bracketSpacing?: boolean,
+    jsxBracketSameLine?: boolean,
+    arrowParens?: "avoid" | "always",
+    rangeStart?: number,
+    rangeEnd?: number,
+    parser?: PrettierParserName | CustomParser,
+    filepath?: string,
+    requirePragma?: boolean,
+    insertPragma?: boolean,
+    proseWrap?: "always" | "never" | "preserve",
+    plugins?: Array<string | Plugin>
+  |};
+
+  declare export type Plugin = {
+    languages: SupportLanguage,
+    parsers: { [parserName: string]: Parser, ... },
+    printers: { [astFormat: string]: Printer, ... },
+    options?: SupportOption[],
+    ...
+  };
+
+  declare export type Parser = {
+    parse: (
+      text: string,
+      parsers: { [parserName: string]: Parser, ... },
+      options: { [key: string]: any, ... }
+    ) => AST,
+    astFormat: string,
+    hasPragma?: (text: string) => boolean,
+    locStart: (node: any) => number,
+    locEnd: (node: any) => number,
+    preprocess?: (text: string, options: { [key: string]: any, ... }) => string,
+    ...
+  };
+
+  declare export type Printer = {
+    print: (
+      path: FastPath<>,
+      options: { [key: string]: any, ... },
+      print: (path: FastPath<>) => Doc
+    ) => Doc,
+    embed: (
+      path: FastPath<>,
+      print: (path: FastPath<>) => Doc,
+      textToDoc: (text: string, options: { [key: string]: any, ... }) => Doc,
+      options: { [key: string]: any, ... }
+    ) => ?Doc,
+    insertPragma?: (text: string) => string,
+    massageAstNode?: (node: any, newNode: any, parent: any) => any,
+    hasPrettierIgnore?: (path: FastPath<>) => boolean,
+    canAttachComment?: (node: any) => boolean,
+    willPrintOwnComments?: (path: FastPath<>) => boolean,
+    printComments?: (path: FastPath<>, print: (path: FastPath<>) => Doc, options: { [key: string]: any, ... }, needsSemi: boolean) => Doc,
+    handleComments?: {
+      ownLine?: (commentNode: any, text: string, options: { [key: string]: any, ... }, ast: any, isLastComment: boolean) => boolean,
+      endOfLine?: (commentNode: any, text: string, options: { [key: string]: any, ... }, ast: any, isLastComment: boolean) => boolean,
+      remaining?: (commentNode: any, text: string, options: { [key: string]: any, ... }, ast: any, isLastComment: boolean) => boolean,
+      ...
+    },
+    ...
+  };
+
+  declare export type CursorOptions = {|
+    cursorOffset: number,
+    printWidth?: $PropertyType<Options, "printWidth">,
+    tabWidth?: $PropertyType<Options, "tabWidth">,
+    useTabs?: $PropertyType<Options, "useTabs">,
+    semi?: $PropertyType<Options, "semi">,
+    singleQuote?: $PropertyType<Options, "singleQuote">,
+    trailingComma?: $PropertyType<Options, "trailingComma">,
+    bracketSpacing?: $PropertyType<Options, "bracketSpacing">,
+    jsxBracketSameLine?: $PropertyType<Options, "jsxBracketSameLine">,
+    arrowParens?: $PropertyType<Options, "arrowParens">,
+    parser?: $PropertyType<Options, "parser">,
+    filepath?: $PropertyType<Options, "filepath">,
+    requirePragma?: $PropertyType<Options, "requirePragma">,
+    insertPragma?: $PropertyType<Options, "insertPragma">,
+    proseWrap?: $PropertyType<Options, "proseWrap">,
+    plugins?: $PropertyType<Options, "plugins">
+  |};
+
+  declare export type CursorResult = {|
+    formatted: string,
+    cursorOffset: number
+  |};
+
+  declare export type ResolveConfigOptions = {|
+    useCache?: boolean,
+    config?: string,
+    editorconfig?: boolean
+  |};
+
+  declare export type SupportLanguage = {
+    name: string,
+    since: string,
+    parsers: Array<string>,
+    group?: string,
+    tmScope: string,
+    aceMode: string,
+    codemirrorMode: string,
+    codemirrorMimeType: string,
+    aliases?: Array<string>,
+    extensions: Array<string>,
+    filenames?: Array<string>,
+    linguistLanguageId: number,
+    vscodeLanguageIds: Array<string>,
+    ...
+  };
+
+  declare export type SupportOption = {|
+    since: string,
+    type: "int" | "boolean" | "choice" | "path",
+    deprecated?: string,
+    redirect?: SupportOptionRedirect,
+    description: string,
+    oppositeDescription?: string,
+    default: SupportOptionValue,
+    range?: SupportOptionRange,
+    choices?: SupportOptionChoice
+  |};
+
+  declare export type SupportOptionRedirect = {|
+    options: string,
+    value: SupportOptionValue
+  |};
+
+  declare export type SupportOptionRange = {|
+    start: number,
+    end: number,
+    step: number
+  |};
+
+  declare export type SupportOptionChoice = {|
+    value: boolean | string,
+    description?: string,
+    since?: string,
+    deprecated?: string,
+    redirect?: SupportOptionValue
+  |};
+
+  declare export type SupportOptionValue = number | boolean | string;
+
+  declare export type SupportInfo = {|
+    languages: Array<SupportLanguage>,
+    options: Array<SupportOption>
+  |};
+                                                             
+  declare export type FileInfo = {|
+    ignored: boolean,
+    inferredParser: PrettierParserName | null,
+  |};                                                          
+
+  declare export type Prettier = {|
+    format: (source: string, options?: Options) => string,
+    check: (source: string, options?: Options) => boolean,
+    formatWithCursor: (source: string, options: CursorOptions) => CursorResult,
+    resolveConfig: {
+      (filePath: string, options?: ResolveConfigOptions): Promise<?Options>,
+      sync(filePath: string, options?: ResolveConfigOptions): ?Options,
+      ...
+    },
+    clearConfigCache: () => void,
+    getSupportInfo: (version?: string) => SupportInfo,
+    getFileInfo: (filePath: string) => Promise<FileInfo>
+  |};
+
+  declare export default Prettier;
+}
diff --git a/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/test_prettier_v1.x.x.js b/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/test_prettier_v1.x.x.js
new file mode 100644
index 0000000000..61f0df68c5
--- /dev/null
+++ b/definitions/npm/prettier_v1.x.x/flow_v0.201.x-/test_prettier_v1.x.x.js
@@ -0,0 +1,117 @@
+import prettier, { type Options } from "prettier";
+
+const code = "let x =  10";
+
+// $FlowExpectedError (Must pass in some source code)
+prettier.format();
+prettier.format(code);
+
+// $FlowExpectedError (Can't use unsupported options)
+prettier.format(code, { printWith: 80 });
+prettier.format(code, { printWidth: 80 });
+
+// $FlowExpectedError (Options should have proper types)
+prettier.format(code, { parser: "flo" });
+prettier.format(code, { parser: "flow" });
+
+// $FlowExpectedError (Same as above, but with explicit annotation)
+const badOptions: Options = { parser: "flo" };
+const goodOptions: Options = { parser: "flow" };
+
+// $FlowExpectedError (Must pass in some source code)
+prettier.check();
+prettier.check(code);
+
+// $FlowExpectedError (Can't use unsupported options)
+prettier.check(code, { sem: true });
+prettier.check(code, { semi: true });
+
+// $FlowExpectedError (Options should have proper types)
+prettier.check(code, { singleQuote: "true" });
+prettier.check(code, { singleQuote: true });
+
+// $FlowExpectedError (Must include CursorOptions)
+prettier.formatWithCursor(code);
+// $FlowExpectedError (CursorOptions must have cursorOffset)
+prettier.formatWithCursor(code, {});
+// $FlowExpectedError (CursorOptions cannot have rangeStart or rangeEnd)
+prettier.formatWithCursor(code, { cursorOffset: 10, rangeStart: 1 });
+prettier.formatWithCursor(code, { cursorOffset: 10 });
+
+// $FlowExpectedError (Must include filePath)
+prettier.resolveConfig();
+prettier.resolveConfig("/path");
+
+const asyncConfig = prettier.resolveConfig("/path");
+if (asyncConfig != null) {
+  // $FlowExpectedError (Returns promise)
+  (asyncConfig.printWidth: number);
+}
+(prettier.resolveConfig("/path"): Promise<?{ printWidth?: number, ... }>);
+
+// $FlowExpectedError (Options should have proper types)
+prettier.resolveConfig("/path", { useCache: "true" });
+prettier.resolveConfig("/path", { useCache: true });
+
+// $FlowExpectedError (Must include filePath)
+prettier.resolveConfig.sync();
+prettier.resolveConfig.sync("/path");
+
+const syncConfig = prettier.resolveConfig.sync("/path");
+if (syncConfig != null) {
+  (syncConfig.printWidth: void | number);
+}
+// $FlowExpectedError (Does not return promise)
+(syncConfig: Promise<?{ printWidth?: number, ... }>);
+
+// $FlowExpectedError (Options should have proper types)
+prettier.resolveConfig.sync("/path", { useCache: "true" });
+prettier.resolveConfig.sync("/path", { useCache: true });
+
+// $FlowExpectedError (Must use correct name)
+prettier.clearConfigCash();
+prettier.clearConfigCache();
+
+// $FlowExpectedError (Version should be a string)
+prettier.getSupportInfo(0.1);
+prettier.getSupportInfo("0.1");
+
+prettier.format(code, {
+  parser() {
+    // $FlowExpectedError (Custom parser should return an ast)
+    return null;
+  }
+});
+
+prettier.format(code, {
+  parser(text, { babylon }) {
+    const ast = babylon(text);
+    return ast;
+  }
+});
+
+/**
+ * Test return types
+ */
+
+let result;
+
+result = prettier.format(code);
+(result: string);
+
+result = prettier.check(code);
+(result: boolean);
+
+result = prettier.formatWithCursor(code, { cursorOffset: 1 });
+(result.formatted: string);
+(result.cursorOffset: number);
+
+result = prettier.resolveConfig("/");
+(result.then: Function);
+
+result = prettier.clearConfigCache();
+(result: void);
+
+result = prettier.getSupportInfo("1.0");
+(result.languages: Array<any>);
+(result.options: Array<any>);
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/ramda_v0.26.x.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/ramda_v0.26.x.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/ramda_v0.26.x.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/ramda_v0.26.x.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_cjs_modules.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_cjs_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_cjs_modules.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_cjs_modules.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_compose.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_compose.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_compose.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_compose.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_es_modules.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_es_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_es_modules.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_es_modules.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_filter.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_filter.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_filter.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_filter.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_functions.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_functions.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_functions.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_functions.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_list.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_list.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_list.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_list.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_logic.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_logic.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_logic.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_logic.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_map.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_map.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_map.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_map.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_math.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_math.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_math.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_math.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_misc.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_misc.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_misc.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_misc.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_object.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_object.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_object.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_object.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_partial.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_partial.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_partial.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_partial.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_pipe.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_pipe.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_pipe.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_pipe.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_relation.js b/definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_relation.js
similarity index 100%
rename from definitions/npm/ramda_v0.26.x/flow_v0.104.x-/test_ramda_v0.26.x_relation.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.104.x-v.200.x/test_ramda_v0.26.x_relation.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/ramda_v0.26.x.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/ramda_v0.26.x.js
new file mode 100644
index 0000000000..b8f0c8a350
--- /dev/null
+++ b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/ramda_v0.26.x.js
@@ -0,0 +1,2130 @@
+/* eslint-disable no-unused-vars, no-redeclare */
+
+type Transformer<A, B> = {
+  "@@transducer/step": <I, R>(r: A, a: any) => R,
+  "@@transducer/init": () => A,
+  "@@transducer/result": (result: any) => B,
+  ...
+};
+
+declare type $npm$ramda$Placeholder = { "@@functional/placeholder": true, ... };
+
+declare opaque type $npm$ramda$Reduced<T>;
+
+declare module ramda {
+  declare type FunctorObj<A> = { map: (<B>(A => B) => FunctorObj<B>), ... }
+  declare type FunctorFantasyLand<A> = { 'fantasy-land/map': (<B>(A => B) => FunctorFantasyLand<B>), ... }
+  declare type UnaryFn<A, R> = (a: A) => R;
+  declare type UnaryPromiseFn<A, R> = UnaryFn<A, Promise<R>>;
+  declare type BinaryFn<A, B, R> = ((a: A, b: B) => R) &
+    ((a: A) => (b: B) => R);
+  declare type UnarySameTypeFn<T> = UnaryFn<T, T>;
+  declare type BinarySameTypeFn<T> = BinaryFn<T, T, T>;
+  declare type NestedObject<T> = { [k: string]: T | NestedObject<T>, ... };
+  declare type UnaryPredicateFn<T> = (x: T) => boolean;
+  declare type MapUnaryPredicateFn = <V>(V) => V => boolean;
+  declare type BinaryPredicateFn<T> = (x: T, y: T) => boolean;
+  declare type BinaryPredicateFn2<T, S> = (x: T, y: S) => boolean;
+
+  declare interface ObjPredicate {
+    (value: mixed, key: string): boolean;
+  }
+
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = (
+    ((...r: [AA]) => CurriedFunction1<BB, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, BB]) => R)
+  );
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = (
+    ((...r: [AA]) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction2<AA, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, CC]) => R)
+  );
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction3<AA, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction2<AA, DD, R>) &
+    ((...r: [BB, $npm$ramda$Placeholder, CC]) => CurriedFunction2<BB, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction4<AA, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction3<AA, DD, EE, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction3<BB, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction2<AA, EE, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction2<BB, EE, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction2<CC, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction5<AA, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction4<AA, DD, EE, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction4<BB, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction3<AA, EE, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction3<BB, EE, FF, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction3<CC, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE]) => CurriedFunction2<AA, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE]) => CurriedFunction2<BB, FF, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE]) => CurriedFunction2<CC, FF, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE]) => CurriedFunction2<DD, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE, FF]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE, FF]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE, FF]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE, FF]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD, $npm$ramda$Placeholder, FF]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type Partial = (<A, R>((...r: [A]) => R, args: [A]) => () => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A]) => B => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A, B]) => () => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A]) => (B, C) => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B]) => C => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B, C]) => () => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A]) => (B, C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B]) => (C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B, C]) => D => R) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R,
+      args: [A, B, C, D]
+    ) => () => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A]
+    ) => (B, C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B]
+    ) => (C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C]
+    ) => (D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D]
+    ) => E => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D, E]
+    ) => () => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A]
+    ) => (B, C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B]
+    ) => (C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C]
+    ) => (D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D]
+    ) => (E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E]
+    ) => F => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E, F]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F]
+    ) => G => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => H => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => (H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => I => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H, I]
+    ) => () => R);
+
+  declare var pipe: {
+    <Args, Return, B, C, D, E, F>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C, D, E,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C, D,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, Return>,
+    ): (...a: Args) => Return,
+    <A, B>(ab: UnaryFn<A, B>): UnaryFn<A, B>,
+    ...
+  };
+
+  declare type Pipe = typeof pipe;
+
+  declare type PipeP = (<A, B, C, D, E, F, G>(
+    ab: UnaryPromiseFn<A, B>,
+    bc: UnaryPromiseFn<B, C>,
+    cd: UnaryPromiseFn<C, D>,
+    de: UnaryPromiseFn<D, E>,
+    ef: UnaryPromiseFn<E, F>,
+    fg: UnaryPromiseFn<F, G>,
+  ) => UnaryPromiseFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>,
+      ef: UnaryPromiseFn<E, F>,
+    ) => UnaryPromiseFn<A, F>) &
+    (<A, B, C, D, E>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>,
+    ) => UnaryPromiseFn<A, E>) &
+    (<A, B, C, D>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+    ) => UnaryPromiseFn<A, D>) &
+    (<A, B, C>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+    ) => UnaryPromiseFn<A, C>) &
+    (<A, B>(
+      ab: UnaryPromiseFn<A, B>,
+    ) => UnaryPromiseFn<A, B>);
+
+  declare type Compose = (<A, B, C, D, E, F, G, H, I, J, K>(
+    jk: UnaryFn<J, K>,
+    ij: UnaryFn<I, J>,
+    hi: UnaryFn<H, I>,
+    gh: UnaryFn<G, H>,
+    fg: UnaryFn<F, G>,
+    ef: UnaryFn<E, F>,
+    de: UnaryFn<D, E>,
+    cd: UnaryFn<C, D>,
+    bc: UnaryFn<B, C>,
+    ab: UnaryFn<A, B>
+  ) => UnaryFn<A, K>) &
+    (<A, B, C, D, E, F, G, H, I, J>(
+      ij: UnaryFn<I, J>,
+      hi: UnaryFn<H, I>,
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, J>) &
+    (<A, B, C, D, E, F, G, H, I>(
+      hi: UnaryFn<H, I>,
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, I>) &
+    (<A, B, C, D, E, F, G, H>(
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, H>) &
+    (<A, B, C, D, E, F, G>(
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, F>) &
+    (<A, B, C, D, E>(
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, E>) &
+    (<A, B, C, D>(
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, D>) &
+    (<A, B, C>(
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, C>) &
+    (<A, B>(ab: UnaryFn<A, B>) => UnaryFn<A, B>);
+
+  // This kind of filter allows us to do type refinement on the result, but we
+  // still need Filter so that non-refining predicates still pass a type check.
+  declare type RefineFilter =
+    & (<K, V, P: $Pred<1>, T: Array<V> | $ReadOnlyArray<V>> (fn: P, xs: T) => Array<$Refine<V, P, 1>>)
+    & (<K, V, P: $Pred<1>, T: Array<V> | $ReadOnlyArray<V>> (fn: P) => (xs: T) => Array<$Refine<V, P, 1>>);
+
+  declare type Filter =
+    & (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>  (fn: UnaryPredicateFn<V>, xs: T) => T)
+    & (<K, V, T: { [key: K]: V, ... } | Array<V>>   (fn: UnaryPredicateFn<V>, xs: T) => T)
+
+    & (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>  (fn: UnaryPredicateFn<V>) =>(xs: T) => T)
+    & (<K, V, T: Array<V> | { [key: K]: V, ... }>   (fn: UnaryPredicateFn<V>) =>(xs: T) => T)
+
+  declare interface Monad<A> {
+    chain<B>(f: A => Monad<B>): Monad<B>;
+  }
+
+  declare class Semigroup<T> {}
+
+  declare class Chain {
+    chain<T, V: Monad<T> | $ReadOnlyArray<T>>(fn: (a: T) => V, x: V): V;
+    chain<T, V: Monad<T> | $ReadOnlyArray<T>>(fn: (a: T) => V): (x: V) => V;
+  }
+
+  declare class GenericContructor<T> {
+    constructor(x: T): GenericContructor<T>;
+  }
+
+  declare class GenericContructorMulti<T> {
+    constructor(...args: Array<T>): GenericContructor<T>;
+  }
+
+  /**
+   * DONE:
+   * Function*
+   * List*
+   * Logic
+   * Math
+   * Object*
+   * Relation
+   * String
+   * Type
+   */
+
+  declare var compose: Compose;
+  declare var pipeK: PipeK;
+  declare var pipeP: PipeP;
+  declare function then<A, R>(onSuccess: UnaryFn<A, R> | UnaryPromiseFn<A, R>): CurriedFunction1<Promise<A>, Promise<R>>
+  declare function then<A, R>(onSuccess: UnaryFn<A, R> | UnaryPromiseFn<A, R>, p: Promise<A>): Promise<R>;
+  declare var curry: Curry;
+  declare function curryN<A, R>(
+    length: number,
+    fn: (...args: Array<A>) => R
+  ): Function;
+
+  // *Math
+  declare var add: CurriedFunction2<number, number, number>;
+  declare var inc: UnaryFn<number, number>;
+  declare var dec: UnaryFn<number, number>;
+  declare var mean: UnaryFn<Array<number>, number>;
+  declare var divide: CurriedFunction2<number, number, number>;
+  declare var mathMod: CurriedFunction2<number, number, number>;
+  declare var median: UnaryFn<Array<number>, number>;
+  declare var modulo: CurriedFunction2<number, number, number>;
+  declare var multiply: CurriedFunction2<number, number, number>;
+  declare var negate: UnaryFn<number, number>;
+  declare var product: UnaryFn<Array<number>, number>;
+  declare var subtract:
+    & CurriedFunction2<number, number, number>
+    & CurriedFunction2<Date, Date, number>
+    & CurriedFunction2<Date, number, number>
+    & CurriedFunction2<number, Date, number>;
+  declare var sum: UnaryFn<Array<number>, number>;
+
+  // Filter
+  // To refine with filter, be sure to import the RefineFilter type, and cast
+  // filter to a RefineFilter.
+  // ex:
+  // import { type RefineFilter, filter } from 'ramda'
+  // const notNull = (x): bool %checks => x != null
+  // const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null])
+  declare var filter: RefineFilter & Filter;
+  // reject doesn't get RefineFilter since it performs the opposite work of
+  // filter, and we don't have a kind of $NotPred type.
+  declare var reject: Filter;
+
+  // *String
+  declare var match: CurriedFunction2<RegExp, string, Array<string | void>>;
+  declare type ReplacementFn = (substring: string, ...args: Array<string>) => string;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A): CurriedFunction2<B, string, string>;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A, B): CurriedFunction1<string, string>;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A, B, string): string;
+  declare var split: CurriedFunction2<RegExp | string, string, Array<string>>;
+  declare var test: CurriedFunction2<RegExp, string, boolean>;
+
+  declare function startsWith<A>(prefix: $ReadOnlyArray<A>): $ReadOnlyArray<A> => boolean;
+  declare function startsWith(prefix: string): string => boolean;
+  declare function startsWith<A>(prefix: $ReadOnlyArray<A>, list: $ReadOnlyArray<A>): boolean;
+  declare function startsWith(prefix: string, list: string): boolean;
+
+  declare function endsWith<A>(prefix: $ReadOnlyArray<A>): $ReadOnlyArray<A> => boolean;
+  declare function endsWith(prefix: string): string => boolean;
+  declare function endsWith<A>(prefix: $ReadOnlyArray<A>, list: $ReadOnlyArray<A>): boolean;
+  declare function endsWith(prefix: string, list: string): boolean;
+
+  declare function toLower(a: string): string;
+  declare function toString(x: mixed): string;
+  declare function toUpper(a: string): string;
+  declare function trim(a: string): string;
+
+  // *Type
+
+  declare function is<T>(t: T): mixed => boolean;
+  declare function is<T>(t: T, v: mixed): boolean;
+  declare function propIs<O>(mixed, $Keys<O>): CurriedFunction1<O, boolean>;
+  declare function propIs<O>(mixed): CurriedFunction2<$Keys<O>, O, boolean>;
+  declare function propIs<O>(mixed, $Keys<O>, O): boolean;
+  declare function type(x: mixed): string;
+
+  declare function isNil(x: mixed): boolean %checks(x === undefined || x === null);
+
+  // *List
+  declare function adjust<T>(index: number): CurriedFunction2<(a: T) => T, $ReadOnlyArray<T>, Array<T>>;
+  declare function adjust<T>(index: number, fn: (a: T) => T): CurriedFunction1<$ReadOnlyArray<T>, Array<T>>;
+  declare function adjust<T>(index: number, fn: (a: T) => T, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function all<T>(fn: UnaryPredicateFn<T>): CurriedFunction1<$ReadOnlyArray<T>, boolean>;
+  declare function all<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+
+  declare function any<T>(fn: UnaryPredicateFn<T>): CurriedFunction1<$ReadOnlyArray<T>, boolean>;
+  declare function any<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+
+  declare function aperture<T>(n: number): CurriedFunction1<$ReadOnlyArray<T>, Array<Array<T>>>;
+  declare function aperture<T>(n: number, xs: $ReadOnlyArray<T>): Array<Array<T>>;
+
+  declare function append<A, E>(A, $ReadOnlyArray<E>): Array<E|A>;
+  declare function append<A, E>(A): CurriedFunction1<$ReadOnlyArray<E>, Array<E|A>>;
+
+  declare function prepend<E>(x: E, xs: $ReadOnlyArray<E>): Array<E>;
+  declare function prepend<E>(x: E): (xs: $ReadOnlyArray<E>) => Array<E>;
+
+  declare function chain<A, B>(f: (x: A) => B[], xs: $ReadOnlyArray<A>): B[]
+  declare function chain<A, B>(f: (x: A) => B[]): (xs: $ReadOnlyArray<A>) => B[]
+
+  // Additional chain functionality documented at https://ramdajs.com/docs/#chain:
+  //
+  // Dispatches to the chain method of the second argument, if present, according to the FantasyLand Chain spec (https://github.com/fantasyland/fantasy-land#chain).
+  //
+  // If second argument is a function, chain(f, g)(x) is equivalent to f(g(x), x).
+  //
+  // Acts as a transducer if a transformer is given in list position.
+  declare function chain<A, B, R>(f: (x: A, y: B) => R, g: (y: B) => A):(y: B) => R;
+
+  declare function concat<A, B>(x: $ReadOnlyArray<A>, y: $ReadOnlyArray<B>): Array<A | B>;
+  declare function concat<A, B>(x: $ReadOnlyArray<A>): CurriedFunction1<$ReadOnlyArray<B>, Array<A | B>>;
+
+  declare function concat(x: string, y: string): string;
+  declare function concat(x: string): CurriedFunction1<string, string>;
+
+  declare type Includes =
+    & ((string, string) => boolean)
+    & ((string) => ((string => boolean)))
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A) => (b: T) => boolean)
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A, b: T) => boolean)
+
+  // Contains is deprecated, and is a synonym for includes.
+  declare var contains: Includes;
+  declare var includes: Includes;
+
+  declare function drop(n: number): (xs: string) => string;
+  declare function drop(n: number, xs: string): string;
+  declare function drop<V, T: $ReadOnlyArray<V>>(n: number): (xs: T) => V[];
+  declare function drop<V, T: $ReadOnlyArray<V>>(n: number, xs: T): V[];
+
+  declare function dropLast(n: number): (xs: string) => string;
+  declare function dropLast(n: number, xs: string): string;
+  declare function dropLast<V, T: $ReadOnlyArray<V>>(n: number): (xs: T) => V[];
+  declare function dropLast<V, T: $ReadOnlyArray<V>>(n: number, xs: T): V[];
+
+  declare function dropLastWhile(fn: UnaryPredicateFn<string>): (xs: string) => string;
+  declare function dropLastWhile(fn: UnaryPredicateFn<string>, xs: string): string;
+  declare function dropLastWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>): (xs: T) => V[];
+  declare function dropLastWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>, xs: T): V[];
+
+  declare function dropWhile(fn: UnaryPredicateFn<string>): (xs: string) => string;
+  declare function dropWhile(fn: UnaryPredicateFn<string>, xs: string): string;
+  declare function dropWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>): (xs: T) => V[];
+  declare function dropWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>, xs: T): V[];
+
+  declare function dropRepeats<V>(xs: $ReadOnlyArray<V>): V[];
+
+  declare function dropRepeatsWith<V>(fn: BinaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => V[];
+  declare function dropRepeatsWith<V>(fn: BinaryPredicateFn<V>, xs: $ReadOnlyArray<V>): V[];
+
+  declare function groupBy<T>(fn: (x: T) => string, xs: $ReadOnlyArray<T>): { [key: string]: Array<T>, ... };
+  declare function groupBy<T>(fn: (x: T) => string): CurriedFunction1<$ReadOnlyArray<T>, { [string]: Array<T>, ... }>;
+
+  declare function groupWith<V>(fn: BinaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => V[][];
+  declare function groupWith<V>(fn: BinaryPredicateFn<V>, xs: $ReadOnlyArray<V>): V[][];
+  declare function groupWith(fn: BinaryPredicateFn<string>): (xs: $ReadOnlyArray<string>) => string[];
+  declare function groupWith(fn: BinaryPredicateFn<string>, xs: $ReadOnlyArray<string>): string[];
+
+  declare function head<T, V: $ReadOnlyArray<T>>(xs: V): $ElementType<V, 0>;
+  declare function head(xs: string): string;
+
+  declare function into<I, T, A: $ReadOnlyArray<T>, R>(
+    accum: R,
+    xf: (a: A) => I,
+    input: A
+  ): R;
+  declare function into<I, T, A: $ReadOnlyArray<T>, R>(
+    accum: Transformer<I, R>,
+    xf: (a: A) => R,
+    input: A
+  ): R;
+
+  declare function indexOf<E>(x: ?E, xs: $ReadOnlyArray<E>): number;
+  declare function indexOf<E>(x: ?E): (xs: $ReadOnlyArray<E>) => number;
+
+  declare function indexBy<V>(fn: (x: V) => string): (xs: $ReadOnlyArray<V>) => { [key: string]: V, ... };
+  declare function indexBy<V>(fn: (x: V) => string, xs: $ReadOnlyArray<V>): { [key: string]: V, ... };
+
+  declare function insert<T>(index: number): (
+    & ((elem: T) => (src: $ReadOnlyArray<T>) => Array<T>)
+    & ((elem: T, src: $ReadOnlyArray<T>) => Array<T>)
+  );
+  declare function insert<T>(index: number, elem: T): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function insert<T>(index: number, elem: T, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function insertAll<T, S>(index: number): (
+    & ((elem: $ReadOnlyArray<S>) => (src: $ReadOnlyArray<T>) => Array<S | T>)
+    & ((elem: $ReadOnlyArray<S>, src: $ReadOnlyArray<T>) => Array<S | T>)
+  );
+  declare function insertAll<T, S>(index: number, elems: $ReadOnlyArray<S>): (src: $ReadOnlyArray<T>) => Array<S | T>;
+  declare function insertAll<T, S>(index: number, elems: $ReadOnlyArray<S>, src: $ReadOnlyArray<T>): Array<S | T>;
+
+  declare function join(x: string, xs: $ReadOnlyArray<string | number>): string;
+  declare function join(x: string): (xs: $ReadOnlyArray<string | number>) => string;
+
+  declare function last<T>(xs: $ReadOnlyArray<T>): ?T;
+  declare function last(xs: string): string;
+
+  declare function none<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+  declare function none<T>(fn: UnaryPredicateFn<T>): (xs: $ReadOnlyArray<T>) => boolean;
+
+  declare function nth<V>(i: number, xs: $ReadOnlyArray<V>): ?V;
+  declare function nth(i: number, xs: string): string;
+  declare function nth<V>(i: number): (
+    & ((xs: string) => string)
+    & ((xs: $ReadOnlyArray<V>) => ?V)
+  );
+
+  declare type Find = (
+    & (<V>(fn: UnaryPredicateFn<V>) => (xs: $ReadOnlyArray<V>) => ?V)
+    & (<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>) => ?V)
+  );
+
+  declare var find: Find;
+
+  declare function findLast<V>(fn: UnaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => ?V | O;
+  declare function findLast<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): ?V;
+
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ...}>(
+    fn: UnaryPredicateFn<V>,
+  ): (xs: T) => number;
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): number;
+
+  declare function findLastIndex<K, V>(fn: UnaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => number;
+  declare function findLastIndex<K, V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): number;
+
+  declare function forEach<T, V>(fn: (x: T) => mixed, xs: $ReadOnlyArray<T>): Array<T>;
+  declare function forEach<T, V>(fn: (x: T) => mixed): (xs: $ReadOnlyArray<T>) => Array<T>;
+
+  declare function forEachObjIndexed<O, K: $Keys<O>, V: $Values<O>>(
+    fn: (val: V, key: K, o: O) => mixed,
+    o: O
+  ): O;
+  declare function forEachObjIndexed<O, K: $Keys<O>, V: $Values<O>>(
+    fn: (val: V, key: K, o: O) => mixed,
+  ): O => O;
+
+  declare function lastIndexOf<E>(x: E, xs: $ReadOnlyArray<E>): number;
+  declare function lastIndexOf<E>(x: E): (xs: $ReadOnlyArray<E>) => number;
+
+  declare var map: {
+    <T, R, FN: (x: T) => R, SR, S: { +map: FN => SR, ... }>(fn: FN, xs: S): SR,
+
+    <T, R, FN: (x: T) => R>(fn: FN): (
+      (<SR, S: { +map: FN => SR, ... }>(xs: S) => SR) &
+      ((xs: { +[key: string]: T, ... }) => { [key: string]: R, ... }) &
+      ((xs: $ReadOnlyArray<T> | Array<T>) => Array<R>)
+    ),
+    <T, R>(fn: (x: T) => R, xs: $ReadOnlyArray<T>): Array<R>,
+    <T, R>(fn: (x: T) => R, xs: { +[key: string]: T, ... }): { [key: string]: R, ... },
+    ...
+  };
+
+  declare type AccumIterator<A, B, R> = (acc: R, x: A) => [R, B];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: $ReadOnlyArray<A>
+  ): [R, Array<B>];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+  ): (acc: R, xs: $ReadOnlyArray<A>) => [R, Array<B>];
+
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: $ReadOnlyArray<A>
+  ): [R, Array<B>];
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+  ): (acc: R, xs: $ReadOnlyArray<A>) => [R, Array<B>];
+
+  declare function intersperse<E>(x: E, xs: $ReadOnlyArray<E>): Array<E>;
+  declare function intersperse<E>(
+    x: E,
+  ): (xs: $ReadOnlyArray<E>) => Array<E>;
+
+  declare function pair<A, B>(a: A, b: B): [A, B];
+  declare function pair<A, B>(a: A): (b: B) => [A, B];
+
+  declare function partition<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function partition<O, V: $Values<O>>(fn: UnaryPredicateFn<V>, xs: O): [$Shape<O>, $Shape<O>];
+  declare function partition<V>(fn: UnaryPredicateFn<V>): ((xs: $ReadOnlyArray<V>) => [V[], V[]]);
+  declare function partition<O, V>(fn: UnaryPredicateFn<V>): ((xs: O) => [$Shape<O>, $Shape<O>]);
+
+  declare function pluck<
+    V,
+    K: $Keys<V>,
+  >(key: K, list: $ReadOnlyArray<V>): Array<$ElementType<V, K>>;
+  declare function pluck<
+    V,
+    K: $Keys<V>,
+  >(key: K): (list: $ReadOnlyArray<V>) => Array<$ElementType<V, K>>;
+  declare function pluck<
+    T,
+    V: $ReadOnlyArray<T>,
+  >(key: number, list: $ReadOnlyArray<V>): Array<$ElementType<V, number>>;
+  declare function pluck<
+    T,
+    V: $ReadOnlyArray<V>,
+  >(key: number): (list: $ReadOnlyArray<V>) => Array<$ElementType<V, number>>;
+
+  declare var range: CurriedFunction2<number, number, Array<number>>;
+
+  declare function reduced<T>(x: T): $npm$ramda$Reduced<T>;
+
+  declare function remove<T>(
+    from: number,
+  ): ((to: number) => (src: $ReadOnlyArray<T>) => Array<T>) &
+    ((to: number, src: $ReadOnlyArray<T>) => Array<T>);
+  declare function remove<T>(
+    from: number,
+    to: number,
+  ): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function remove<T>(from: number, to: number, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function repeat<T>(x: T, times: number): Array<T>;
+  declare function repeat<T>(x: T): (times: number) => Array<T>;
+
+  declare function slice(from: number): (
+    & ((to: number) => (
+        & (<V>(src: $ReadOnlyArray<V>) => V[])
+        & ((src: string) => string)
+    ))
+    & (<V>(to: number, src: $ReadOnlyArray<V>) => V[])
+    & ((to: number, src: string) => string)
+  );
+  declare function slice(from: number, to: number): (
+    & (<V>(src: $ReadOnlyArray<V>) => V[])
+    & ((src: string) => string)
+  );
+  declare function slice<V>(
+    from: number,
+    to: number,
+    src: $ReadOnlyArray<V>,
+  ): V[];
+  declare function slice(
+    from: number,
+    to: number,
+    src: string,
+  ): string;
+
+  declare function sort<V, T: Array<V>>(fn: (a: V, b: V) => number, xs: $ReadOnlyArray<V>): T;
+  declare function sort<V, T: Array<V>>(
+    fn: (a: V, b: V) => number,
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function sortWith<V, T: Array<V>>(
+    fns: $ReadOnlyArray<(a: V, b: V) => number>,
+    xs: $ReadOnlyArray<V>
+  ): T;
+  declare function sortWith<V, T: Array<V>>(
+    fns: $ReadOnlyArray<(a: V, b: V) => number>,
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  /**
+   * In the examples for ascend and descend, its result is plugged into sort.
+   * In order for this to function properly ascend and descend need to yield a
+   * function that can take two arguments. In our case we'll declare the result
+   * function as curried, which matches the ramda behavior.
+   */
+  declare type MakeComparator = <A, B>(A => B) => CurriedFunction2<A, A, number>
+
+  declare var descend: MakeComparator
+  declare var ascend: MakeComparator
+
+  declare function times<T>(fn: (i: number) => T, n: number): Array<T>;
+  declare function times<T>(
+    fn: (i: number) => T,
+  ): (n: number) => Array<T>;
+
+  declare function take<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function take<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLast<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function takeLast<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>,
+    xs: $ReadOnlyArray<V>
+  ): T;
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function takeWhile<V, T: Array<V>>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): T;
+  declare function takeWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean,
+  ): (seed: T) => Array<R>;
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean,
+    seed: T
+  ): Array<R>;
+
+  declare function uniqBy<T, V>(
+    fn: (x: T) => V,
+  ): (xs: $ReadOnlyArray<T>) => Array<T>;
+  declare function uniqBy<T, V>(fn: (x: T) => V, xs: $ReadOnlyArray<T>): Array<T>;
+
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): (xs: $ReadOnlyArray<T>) => Array<T>;
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function update<T>(
+    index: number,
+  ): ((elem: T) => (src: $ReadOnlyArray<T>) => Array<T>) &
+    ((elem: T, src: $ReadOnlyArray<T>) => Array<T>);
+  declare function update<T>(
+    index: number,
+    elem: T,
+  ): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function update<T>(index: number, elem: T, src: $ReadOnlyArray<T>): Array<T>;
+
+  // TODO `without` as a transducer
+  declare function without<T, E>($ReadOnlyArray<E>, $ReadOnlyArray<E|T>): Array<E|T>;
+  declare function without<T, E>($ReadOnlyArray<E>): CurriedFunction1<$ReadOnlyArray<E|T>, Array<E|T>>;
+
+  declare function xprod<T, S>(xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>): Array<[T, S]>;
+  declare function xprod<T, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<[T, S]>;
+
+  declare function zip<T, S>(xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>): Array<[T, S]>;
+  declare function zip<T, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<[T, S]>;
+
+  declare function zipObj<T: string, S>(
+    xs: $ReadOnlyArray<T>,
+    ys: $ReadOnlyArray<S>
+  ): { [key: T]: S, ... };
+  declare function zipObj<T: string, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => { [key: T]: S, ... };
+
+  declare type NestedArray<T> = $ReadOnlyArray<T | NestedArray<T>>;
+  declare function flatten<T>(xs: NestedArray<T>): Array<T>;
+
+  declare function fromPairs<T, V>(pairs: $ReadOnlyArray<[T, V]>): { [key: string]: V, ... };
+
+  declare function init<T>(xs: $ReadOnlyArray<T>): T[];
+  declare function init(xs: string): string;
+
+  declare function length<T>(xs: $ReadOnlyArray<T> | string | { length: number, ... }): number;
+
+  declare function reverse<T, V: Array<T> | string>(xs: $ReadOnlyArray<T>): V;
+
+  declare type Reduce = (
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A) => (
+        & ((init: I) => (xs: $ReadOnlyArray<B>) => (A | I))
+        & ((init: I, xs: $ReadOnlyArray<B>) => (A | I))
+      )
+    )
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A, init: I) => (xs: $ReadOnlyArray<B>) => (A | I)
+    )
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A, init: I, xs: $ReadOnlyArray<B>) => (A | I)
+    )
+  );
+
+  declare var reduce: Reduce;
+
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+  ): ((acc: B) => ((
+    keyFn: (elem: A) => string,
+  ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... })) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string,
+    ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string,
+      xs: Array<A>
+    ) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+  ): ((
+    keyFn: (elem: A) => string,
+  ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string
+  ): (xs: Array<A>) => { [key: string]: B, ... };
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string,
+    xs: Array<A>
+  ): { [key: string]: B, ... };
+
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+  ): ((init: A, xs: Array<B>) => A) &
+    ((init: A) => (xs: Array<B>) => A);
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A,
+  ): (xs: Array<B>) => A;
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function reduceWhile<A, B>(pred: (acc: A, curr: B) => boolean): ((
+    fn: (a: A, b: B) => A,
+  ) => (init: A) => (
+    xs: Array<B>
+  ) => A &
+    ((
+      fn: (a: A, b: B) => A,
+    ) => (init: A, xs: Array<B>) => A)) &
+    ((
+      fn: (a: A, b: B) => A,
+      init: A,
+    ) => (xs: Array<B>) => A) &
+    ((fn: (a: A, b: B) => A, init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    pred: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A,
+  ): ((init: A) => (xs: Array<B>) => A) &
+    ((init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    fn: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+  ): ((init: A, xs: Array<B>) => Array<A>) &
+    ((init: A) => (xs: Array<B>) => Array<A>);
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A,
+  ): (xs: Array<B>) => Array<A>;
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A,
+    xs: Array<B>
+  ): Array<A>;
+
+  declare function splitAt<V>(i: number, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function splitAt(i: number, xs: string): [string, string];
+  declare function splitAt(i: number): (
+    & (string => [string, string])
+    & <V>($ReadOnlyArray<V>) => [V[], V[]]
+  );
+
+  declare function splitEvery<V>(i: number, xs: $ReadOnlyArray<V>): V[][];
+  declare function splitEvery(i: number, xs: string): string[];
+  declare function splitEvery(i: number): (
+    & (string => string[])
+    & <V>($ReadOnlyArray<V>) => V[][]
+  );
+
+  declare function splitWhen<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function splitWhen(fn: UnaryPredicateFn<string>, xs: string): [string, string];
+  declare function splitWhen<V>(fn: V => boolean): (
+  	& ($ReadOnlyArray<V> => [V[], V[]])
+  	& ((V & string) => [string, string])
+  );
+
+  declare function tail<V>(xs: $ReadOnlyArray<V>): V[];
+  declare function tail<V>(xs: string): string;
+
+  declare function transpose<T>(xs: $ReadOnlyArray<$ReadOnlyArray<T>>): Array<Array<T>>;
+
+  declare function uniq<T>(xs: $ReadOnlyArray<T>): Array<T>;
+
+  declare function unnest<T>(xs: $ReadOnlyArray<T | $ReadOnlyArray<T>>): $ReadOnlyArray<T>;
+
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+  ): ((xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>) => Array<R>) &
+    ((xs: $ReadOnlyArray<T>) => (ys: $ReadOnlyArray<S>) => Array<R>);
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<R>;
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: $ReadOnlyArray<T>,
+    ys: $ReadOnlyArray<S>
+  ): Array<R>;
+
+  // *Relation
+  declare function equals<T>(x: T): (y: T) => boolean;
+  declare function equals<T>(x: T, y: T): boolean;
+
+  declare function eqBy<A, B>(
+    fn: (x: A) => B,
+      ): ((x: A, y: A) => boolean) &
+    ((x: A) => (y: A) => boolean);
+  declare function eqBy<A, B>(
+    fn: (x: A) => B,
+    x: A,
+      ): (y: A) => boolean;
+  declare function eqBy<A, B>(fn: (x: A) => B, x: A, y: A): boolean;
+
+  // Flow cares about the order in which these appear. Generally function
+  // siguatures should go from smallest arity to largest arity.
+  declare type PropEq = (
+    & (
+        <T>(prop: $Keys<T>) => (
+          & ((val: mixed) => (obj: T) => boolean)
+          & ((val: mixed, obj: T) => boolean)
+        )
+    )
+    & (
+      <T>(prop: $Keys<T>, val: mixed) => (obj: T) => boolean
+    )
+    & (
+      <T>(prop: $Keys<T>, val: mixed, obj: T) => boolean
+    )
+    // Array variants.
+    & (
+      <T>(prop: number) => (
+        & ((val: mixed) => (obj: $ReadOnlyArray<T>) => boolean)
+        & ((val: mixed, obj: $ReadOnlyArray<T>) => boolean)
+      )
+    )
+    & (
+      <T>(prop: number, val: mixed) => (obj: $ReadOnlyArray<T>) => boolean
+    )
+    & (
+      <T>(prop: number, val: mixed, obj: $ReadOnlyArray<T>) => boolean
+    )
+  );
+  declare var propEq: PropEq;
+
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>): (
+    & ((val: mixed) => (o: O) => boolean)
+    & ((val: mixed, o: O) => boolean)
+  );
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>, val: mixed): (o: O) => boolean;
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>, val: mixed, O): boolean;
+
+  declare function clamp<T: number | string | Date>(
+    min: T,
+  ): ((max: T) => (v: T) => T) & ((max: T, v: T) => T);
+  declare function clamp<T: number | string | Date>(
+    min: T,
+    max: T,
+  ): (v: T) => T;
+  declare function clamp<T: number | string | Date>(min: T, max: T, v: T): T;
+
+  declare function countBy<T>(
+    fn: (x: T) => string,
+  ): (list: $ReadOnlyArray<T>) => { [key: string]: number, ... };
+  declare function countBy<T>(
+    fn: (x: T) => string,
+    list: $ReadOnlyArray<T>
+  ): { [key: string]: number, ... };
+
+  declare function difference<T>(
+    xs1: $ReadOnlyArray<T>,
+  ): (xs2: $ReadOnlyArray<T>) => Array<T>;
+  declare function difference<T>(xs1: $ReadOnlyArray<T>, xs2: $ReadOnlyArray<T>): Array<T>;
+
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((xs1: $ReadOnlyArray<T>) => (xs2: $ReadOnlyArray<T>) => Array<T>) &
+    ((xs1: $ReadOnlyArray<T>, xs2: $ReadOnlyArray<T>) => Array<T>);
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: $ReadOnlyArray<T>,
+  ): (xs2: $ReadOnlyArray<T>) => Array<T>;
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: $ReadOnlyArray<T>,
+    xs2: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function eqBy<T>(fn: (x: T) => T, x: T, y: T): boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T, y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T, x: T): (y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T) => (y: T) => boolean;
+
+  declare type RelationCompare =
+    & ((x: number) => (y: number) => bool)
+    & ((x: number, y: number) => bool)
+    & ((x: string) => (y: string) => bool)
+    & ((x: string, y: string) => bool)
+
+  declare var gt: RelationCompare
+  declare var gte: RelationCompare
+  declare var lt: RelationCompare
+  declare var lte: RelationCompare
+
+  declare function identical<T>(x: T): (y: T) => boolean;
+  declare function identical<T>(x: T, y: T): boolean;
+
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+  ): (
+    a: $ReadOnlyArray<A>,
+  ) => (b: $ReadOnlyArray<B>) => Array<A> & ((a: $ReadOnlyArray<A>, b: $ReadOnlyArray<B>) => Array<A>);
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: $ReadOnlyArray<A>,
+  ): (b: $ReadOnlyArray<B>) => Array<A>;
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: $ReadOnlyArray<A>,
+    b: $ReadOnlyArray<B>
+  ): Array<A>;
+
+  declare function intersection<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+  declare function intersection<T>(x: $ReadOnlyArray<T>): (y: $ReadOnlyArray<T>) => Array<T>;
+
+  declare function max<T>(x: T): (y: T) => T;
+  declare function max<T>(x: T, y: T): T;
+
+  declare function maxBy<T, V>(
+    fn: (x: T) => V,
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function maxBy<T, V>(
+    fn: (x: T) => V,
+    x: T,
+  ): (y: T) => T;
+  declare function maxBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function min<T>(x: T): (y: T) => T;
+  declare function min<T>(x: T, y: T): T;
+
+  declare function minBy<T, V>(
+    fn: (x: T) => V,
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function minBy<T, V>(fn: (x: T) => V, x: T): (y: T) => T;
+  declare function minBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function sortBy<T, V>(
+    fn: (x: T) => V,
+  ): (x: $ReadOnlyArray<T>) => Array<T>;
+  declare function sortBy<T, V>(fn: (x: T) => V, x: $ReadOnlyArray<T>): Array<T>;
+
+  declare function symmetricDifference<T>(
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function symmetricDifference<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((x: $ReadOnlyArray<T>) => (y: Array<T>) => Array<T>) &
+    ((x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>) => Array<T>);
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+    y: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function union<T>(
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function union<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((x: $ReadOnlyArray<T>) => (y: Array<T>) => Array<T>) &
+    ((x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>) => Array<T>);
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+    y: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  // *Object
+  declare var assoc: {
+    <T, S>(
+      key: string,
+      ...args: Array<void>
+    ):
+      & ((val: T) => (src: S) => ({ [k: string]: T, ... }))
+      & ((val: T, src: S) => ({ [k: string]: T, ... } & S)),
+    <T, S>(
+      key: string,
+      val: T,
+      ...args: Array<void>
+    ): (src: S) => ({ [k: string]: T, ... } & S),
+    <T, S: { ... }, K: $Keys<S>> (key: K, val: T, src: S):      ({ [k: string]: T, ... } & S),
+    <T, S: { ... }>              (key: string, val: T, src: S): ({
+      [k: string]: T,
+      ...$Exact<S>,
+      ...
+    }),
+    ...
+  };
+
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    ...args: Array<void>
+  ): ((val: V) => (src: S) => { [k: string]: V, ... }) &
+    ((val: V) => (src: S) => { [k: string]: V, ... } & S);
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    val: V,
+    ...args: Array<void>
+  ): (src: S) => { [k: string]: V, ... } & S;
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    val: V,
+    src: S
+  ): { [k: string]: V, ... } & S;
+
+  declare function clone<T>(src: T): $Shape<T>;
+
+  declare function dissoc<T>(
+    key: string,
+    ...args: Array<void>
+  ): (src: { [k: string]: T, ... }) => { [k: string]: T, ... };
+  declare function dissoc<T>(
+    key: string,
+    src: { [k: string]: T, ... }
+  ): { [k: string]: T, ... };
+
+  declare function dissocPath<T: string | number, U>(
+    key: $ReadOnlyArray<T>,
+    ...args: Array<void>
+  ): (src: { [k: string]: U, ... }) => { [k: string]: U, ... };
+  declare function dissocPath<T: string | number, U>(
+    key: $ReadOnlyArray<T>,
+    src: { [k: string]: U, ... }
+  ): { [k: string]: U, ... };
+
+  declare function evolve(NestedObject<Function>): { ... } => { ... };
+  declare function evolve(NestedObject<Function>, { ... }): { ... };
+
+  declare function eqProps(
+    key: string,
+    ...args: Array<void>
+  ): ((o1: { ... }) => (o2: { ... }) => boolean) &
+    ((o1: { ... }, o2: { ... }) => boolean);
+  declare function eqProps(
+    key: string,
+    o1: { ... },
+    ...args: Array<void>
+  ): (o2: { ... }) => boolean;
+  declare function eqProps(key: string, o1: { ... }, o2: { ... }): boolean;
+
+  declare function has(key: string): (o: ?{ ... }) => boolean;
+  declare function has(key: string, o: ?{ ... }): boolean;
+
+  declare function hasPath<T: string | number>(path: $ReadOnlyArray<T>): (o: { ... }) => boolean;
+  declare function hasPath<T: string | number>(path: $ReadOnlyArray<T>, o: { ... }): boolean;
+
+  declare function hasIn(key: string, o: { ... }): boolean;
+  declare function hasIn(key: string): (o: { ... }) => boolean;
+
+  declare function invert(o: { ... }): { [k: string]: Array<string>, ... };
+  declare function invertObj(o: { ... }): { [k: string]: string, ... };
+
+  declare function keys(o: ?{ ... }): Array<string>;
+
+  declare type Lens<A, B, Fa: Functor<A>, Fb: Functor<B>> = (A => Fb) => Fb;
+  /**
+   * Because it is difficult to treat objects as if they are Functors, let's
+   * just have a lens type that works with objects, since Ramda supports objects
+   * as Functors in this context.
+   */
+  declare type LensObj<F, A, O> = (A => O) => O;
+
+  declare var lens:
+    & (<A, B, Fa, Fb>(
+      getter: (f: Fa) => A) => (
+      setter: (b: B, f: Fa) => Fb
+    ) => LensObj<Fa, A, Fb>)
+    & (<A, B, Fa, Fb>(
+      getter: (f: Fa) => A,
+      setter: (b: B, f: Fa) => Fb
+    ) => LensObj<Fa, A, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(
+      getter: (f: Fa) => A) => (
+      setter: (b: B, f: Fa) => Fb
+    ) => Lens<A, B, Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(
+      getter: (f: Fa) => A,
+      setter: (b: B, f: Fa) => Fb
+    ) => Lens<A, B, Fa, Fb>)
+
+  declare function lensIndex<A, B, Fa: Functor<A>, Fb: Functor<B>, N: number, V: $ElementType<Fa, N>>(N): Lens<V, B, Fa, Fb>;
+
+  /**
+   * lensPath requires a tuple rather than an Array for its parameter. This
+   * allows us to make rested $ElementType uses in order to walk down the object
+   * hierarchy. This remains something TODO.
+   */
+  declare function lensPath<O, F, K: $Keys<F>>(p: [K]): LensObj<F, $ElementType<F, K>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>
+  >(p: [K0, K1]): LensObj<F, $ElementType<E0, K1>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>
+  >(p: [K0, K1, K2]): LensObj<F, $ElementType<E1, K2>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>, E2: $ElementType<E1, K2>,
+    K3: $Keys<E2>
+  >(p: [K0, K1, K2, K3]): LensObj<F, $ElementType<E2, K3>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>, E2: $ElementType<E1, K2>,
+    K3: $Keys<E2>, E3: $ElementType<E2, K3>,
+    K4: $Keys<E3>
+  >(p: [K0, K1, K2, K3, K4]): LensObj<F, $ElementType<E3, K4>, O>;
+
+  // declare function lensProp(str: string): Lens;
+  declare function lensProp<O, F, K: $Keys<F>>(K): LensObj<F, $ElementType<F, K>, O>;
+
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: { ... }) => B,
+    o: { [key: string]: A, ... }
+  ): { [key: string]: B, ... };
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: { ... }) => B,
+    ...args: Array<void>
+  ): (o: { [key: string]: A, ... }) => { [key: string]: B, ... };
+
+  declare type Merge =
+    (<A, B>(a: A) => (b: B) => A & B) &
+    (<A, B>(a: A, b: B) => A & B);
+
+  declare var merge: Merge;
+  declare var mergeLeft: Merge;
+  declare var mergeDeepLeft: Merge;
+  declare var mergeRight: Merge;
+
+  declare function mergeAll<T>(
+    os: $ReadOnlyArray<{ [k: string]: T, ... }>
+  ): { [k: string]: T, ... };
+
+  declare var mergeDeepRight: (<A, B>(a: A, b: B) => B & A) &
+    (<A, B>(a: A) => (b: B) => B & A);
+
+  declare type MergeWith = (<A, B, T: $Values<A> & $Values<B>>(
+    fn: (a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+    ) => (a: A) => (b: B) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+    ) => (a: A, b: B) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+      a: A,
+    ) => (b: B) => A & B);
+
+  declare type MergeWithKey = (<
+    A,
+    B,
+    S: $Keys<A> & $Keys<B>,
+    T: $ElementType<A, $Keys<A>> & $ElementType<B, $Keys<B>>,
+  >(
+    fn: (s: S, a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+    ) => (a: A, b: B) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+    ) => (a: A) => (b: B) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+      a: A,
+    ) => (b: B) => A & B);
+
+  declare var mergeDeepWith: MergeWith;
+
+  declare var mergeDeepWithKey: MergeWithKey;
+
+  declare var mergeWith: MergeWith;
+
+  declare var mergeWithKey: MergeWithKey;
+
+  declare function objOf<T>(
+    key: string,
+  ): (val: T) => { [key: string]: T, ... };
+  declare function objOf<T>(key: string, val: T): { [key: string]: T, ... };
+
+  declare function omit<T: { ... }>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: T) => $Shape<T>;
+  declare function omit<T: { ... }>(keys: $ReadOnlyArray<string>, val: T): $Shape<T>;
+
+  declare type Functor<A> =
+    | { @@iterator(): Iterator<A>, ... }
+    | FunctorObj<A>
+    | FunctorFantasyLand<A>
+    | Array<A>
+    | $ReadOnlyArray<A>
+
+  declare var over:
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>) => CurriedFunction2<A => B, Oa, Ob>)
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, A => B) => CurriedFunction1<Oa, Ob>)
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, A => B, Oa) => Ob)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>) => CurriedFunction2<A => B, Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, A => B) => CurriedFunction1<Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, A => B, Fa) => Fb)
+
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: NestedObject<V>) => V;
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: null | void) => void;
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: mixed) => ?V;
+  declare function path<T: string | number, V, A: NestedObject<V>>(p: $ReadOnlyArray<T>, o: A): V;
+  declare function path<T: string | number, V, A: null | void>(p: $ReadOnlyArray<T>, o: A): void;
+  declare function path<T: string | number, V, A>(p: $ReadOnlyArray<T>, o: A): ?V;
+
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: NestedObject<V>) => V;
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: null | void) => void;
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: mixed) => ?V;
+  declare function path<V, A: NestedObject<V>>(p: $ReadOnlyArray<string>, o: A): V;
+  declare function path<V, A: null | void>(p: $ReadOnlyArray<string>, o: A): void;
+  declare function path<V, A: mixed>(p: $ReadOnlyArray<string>, o: A): ?V;
+
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+  ): ((p: $ReadOnlyArray<U>) => (o: ?A) => V | T) &
+    ((p: $ReadOnlyArray<U>, o: ?A) => V | T);
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+    p: $ReadOnlyArray<U>,
+  ): (o: ?A) => V | T;
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+    p: $ReadOnlyArray<U>,
+    o: ?A
+  ): V | T;
+
+  declare function pick<O, K: $ReadOnlyArray<$Keys<O>>>(
+    keys: K,
+  ): (val: O) => O;
+  declare function pick<O, K: $ReadOnlyArray<$Keys<O>>>(
+    keys: K,
+    val: O
+  ): O;
+
+  declare function pickAll<A>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: { [key: string]: A, ... }) => { [key: string]: ?A, ... };
+  declare function pickAll<A>(
+    keys: $ReadOnlyArray<string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: ?A, ... };
+
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>,
+  ): (val: { [key: string]: A, ... }) => { [key: string]: A, ... };
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: A, ... };
+
+  declare function project<T>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: $ReadOnlyArray<{ [key: string]: T, ... }>) => Array<{ [key: string]: T, ... }>;
+  declare function project<T>(
+    keys: $ReadOnlyArray<string>,
+    val: $ReadOnlyArray<{ [key: string]: T, ... }>
+  ): Array<{ [key: string]: T, ... }>;
+
+  declare function prop<T: string, O>(
+    key: T,
+  ): (o: O) => $ElementType<O, T>;
+  declare function prop<T: string, O>(
+    __: $npm$ramda$Placeholder,
+    o: O
+  ): (key: T) => $ElementType<O, T>;
+  declare function prop<T: string, O>(key: T, o: O): $ElementType<O, T>;
+
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+  ): ((p: string) => (o: A) => V | T) &
+    ((p: string, o: A) => V | T);
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+    p: string,
+  ): (o: A) => V | T;
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+    p: string,
+    o: A
+  ): V | T;
+
+  declare function keysIn(o: { ... }): Array<string>;
+
+  declare function props<T: string, O>(
+    keys: $ReadOnlyArray<T>,
+  ): (o: O) => Array<$ElementType<O, T>>;
+  declare function props<T: string, O>(
+    keys: $ReadOnlyArray<T>,
+    o: O
+  ): Array<$ElementType<O, T>>;
+
+  declare var set:
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>) => (
+      & (B => Oa => Ob)
+      & ((B, Oa) => Ob)
+    ))
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, B, Oa) => Ob)
+    // NOTE: Other functor types might need to be directly supported here.
+    & (<A, B, Fa: Array<A>>(lens: Lens<A, B, Fa, Array<B>>) => (
+      & (B => Fa => Array<B>)
+      & ((B, Fa) => Array<B>)
+    ))
+    & (<A, B, Fa: Array<A>>(lens: Lens<A, B, Fa, Array<B>>, B, Fa) => Array<B>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>) => (
+      & (B => Fa => Fb)
+      & ((B, Fa) => Fb)
+    ))
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, B, Fa) => Fb)
+
+  declare function toPairs<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[$Keys<O>, T]>;
+
+  declare function toPairsIn<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[string, T]>;
+
+  declare function values<T>(o: T): Array<$Values<T>>;
+
+  declare function valuesIn<T, O>(o: O): Array<$Values<T> | mixed>;
+
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>,
+    o: O
+  ): boolean;
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>
+  ): O => boolean;
+
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O,
+  ): (o: $Shape<O & Q>) => boolean;
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O,
+    o: $Shape<O & Q>
+  ): boolean;
+
+  declare var view:
+    & (<A, B, Oa, Ob>(LensObj<Oa, A, B>) => Oa => A)
+    & (<A, B, Oa, Ob>(LensObj<Oa, A, B>, Oa) => A)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(Lens<A, B, Fa, Fb>) => Fa => A)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(Lens<A, B, Fa, Fb>, Fa) => A)
+
+  // *Function
+  declare var __: $npm$ramda$Placeholder;
+
+  declare var T: (_: mixed) => true;
+  declare var F: (_: mixed) => false;
+
+  declare function addIndex<A, B>(
+    iterFn: (fn: (x: A) => B, xs: $ReadOnlyArray<A>) => Array<B>
+  ): (fn: (x: A, idx: number, xs: $ReadOnlyArray<A>) => B, xs: $ReadOnlyArray<A>) => Array<B>;
+
+  declare function always<T>(x: T): (x: mixed) => T;
+
+  declare function ap<T, V>(
+    fns: $ReadOnlyArray<(x: T) => V>,
+  ): (xs: $ReadOnlyArray<T>) => Array<V>;
+  declare function ap<T, V>(fns: $ReadOnlyArray<(x: T) => V>, xs: $ReadOnlyArray<T>): Array<V>;
+
+  declare function apply<T, V>(
+    fn: (...args: Array<T>) => V,
+  ): (xs: $ReadOnlyArray<T>) => V;
+  declare function apply<T, V>(fn: (...args: Array<T>) => V, xs: $ReadOnlyArray<T>): V;
+
+  declare function applySpec<
+    V,
+    S,
+    A: $ReadOnlyArray<V>,
+    T: NestedObject<(...args: A) => S>
+  >(
+    spec: T
+  ): (...args: A) => NestedObject<S>;
+
+  declare function applyTo<A, B>(a: A): (fn: (x: A) => B) => B;
+  declare function applyTo<A, B>(a: A, fn: (x: A) => B): B;
+
+  declare function binary<T, A, B>(
+    fn: (a: A, b: B, ...args: Array<mixed>) => T
+  ): (x: A, y: B) => T;
+
+  declare function bind<T, A, R, F: (...args: A) => R>(
+    fn: F,
+    thisObj: T
+  ): F;
+
+  declare function call<T, V>(
+    fn: (...args: Array<V>) => T,
+    ...args: Array<V>
+  ): T;
+
+  declare function comparator<T>(
+    fn: BinaryPredicateFn<T>
+  ): (x: T, y: T) => number;
+
+  // TODO add tests
+  declare function construct<T>(
+    ctor: Class<GenericContructor<T>>
+  ): (x: T) => GenericContructor<T>;
+
+  // TODO add tests
+  declare function constructN<T, E>(
+    n: number,
+    ctor: Class<GenericContructorMulti<T>>
+  ): (...args: Array<T>) => GenericContructorMulti<T>;
+
+  // TODO make less generic
+  declare function converge(after: Function, fns: $ReadOnlyArray<Function>): Function;
+
+  declare function empty<T>(x: T): T;
+
+  declare function flip<A, B, TResult>(
+    fn: (arg0: A, arg1: B) => TResult
+  ): CurriedFunction2<B, A, TResult>;
+  declare function flip<A, B, C, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C) => TResult
+  ): ((arg0: B, arg1: A) => (arg2: C) => TResult) &
+    ((arg0: B, arg1: A, arg2: C) => TResult);
+  declare function flip<A, B, C, D, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D) => TResult
+  ): ((
+    arg1: B,
+    arg0: A,
+  ) => (arg2: C, arg3: D) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D) => TResult);
+  declare function flip<A, B, C, D, E, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D, arg4: E) => TResult
+  ): ((
+    arg1: B,
+    arg0: A,
+  ) => (arg2: C, arg3: D, arg4: E) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D, arg4: E) => TResult);
+
+  declare function identity<T>(x: T): T;
+
+  declare function invoker<A, B, C, D, O: { [k: string]: Function, ... }>(
+    arity: number,
+    name: $Keys<O>
+  ): CurriedFunction2<A, O, D> &
+    CurriedFunction3<A, B, O, D> &
+    CurriedFunction4<A, B, C, O, D>;
+
+  declare function juxt<T, S>(
+    fns: $ReadOnlyArray<(...args: Array<S>) => T>
+  ): (...args: Array<S>) => Array<T>;
+
+  // TODO lift
+
+  // TODO liftN
+
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: $ReadOnlyArray<A>) => C
+  ): (...args: Array<A>) => (...args: Array<A>) => B;
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: $ReadOnlyArray<A>) => C,
+    fn: (...args: Array<A>) => B
+  ): (...args: Array<A>) => B;
+
+  declare function nAry<T, V>(
+    arity: number,
+    fn: (...args: Array<V>) => T
+  ): (...args: Array<V>) => T;
+
+  declare function nthArg<T>(n: number): (...args: Array<T>) => T;
+
+  declare var o: (<A, B, C>(
+    fn1: (b: B) => C,
+    ...rest: void[]
+  ) => ((fn2: (a: A) => B, ...rest: void[]) => (x: A) => C) &
+    ((fn2: (a: A) => B, x: A) => C)) &
+    (<A, B, C>(
+      fn1: (b: B) => C,
+      fn2: (a: A) => B,
+      ...rest: void[]
+    ) => (x: A) => C) &
+    (<A, B, C>(fn1: (b: B) => C, fn2: (a: A) => B, x: A) => C);
+
+  declare function of<T>(x: T): Array<T>;
+
+  declare function once<A, B, T: (...args: Array<A>) => B>(fn: T): T;
+
+  declare var partial: Partial;
+  // TODO partialRight
+
+  declare type UnaryMonadFn<A, R> = UnaryFn<A, Monad<R>>;
+  declare type PipeK = (<A, B, C, D, E, F, G, H, I, J, K, L: Monad<K>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: UnaryMonadFn<E, F>,
+        fg: UnaryMonadFn<F, G>,
+        gh: UnaryMonadFn<G, H>,
+        hi: UnaryMonadFn<H, I>,
+        ij: UnaryMonadFn<I, J>,
+        jk: J => L,
+    ) => A => L) &
+    (<A, B, C, D, E, F, G, H, I, J, K: Monad<J>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: UnaryMonadFn<E, F>,
+        fg: UnaryMonadFn<F, G>,
+        gh: UnaryMonadFn<G, H>,
+        hi: UnaryMonadFn<H, I>,
+        ij: I => K,
+    ) => A => K) &
+    (<A, B, C, D, E, F, G, H, I, J: Monad<I>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: UnaryMonadFn<E, F>,
+        fg: UnaryMonadFn<F, G>,
+        gh: UnaryMonadFn<G, H>,
+        hi: H => J,
+    ) => A => J) &
+    (<A, B, C, D, E, F, G, H, I: Monad<H>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: UnaryMonadFn<E, F>,
+        fg: UnaryMonadFn<F, G>,
+        gh: G => I,
+    ) => A => I) &
+    (<A, B, C, D, E, F, G, H: Monad<G>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: UnaryMonadFn<E, F>,
+        fg: F => H,
+    ) => A => H) &
+    (<A, B, C, D, E, F, G: Monad<F>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: UnaryMonadFn<D, E>,
+        ef: E => G,
+    ) => A => G) &
+    (<A, B, C, D, E, F: Monad<E>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: UnaryMonadFn<C, D>,
+        de: D => F,
+    ) => A => F) &
+    (<A, B, C, D, E: Monad<D>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: UnaryMonadFn<B, C>,
+        cd: C => E,
+    ) => A => E) &
+    (<A, B, C, D: Monad<C>>(
+        ab: UnaryMonadFn<A, B>,
+        bc: B => D,
+    ) => A => D) &
+    (<A, B, C: Monad<B>>(
+        ab: A => C
+    ) => A => C);
+
+  declare function tap<T>(fn: (x: T) => mixed): (x: T) => T;
+  declare function tap<T>(fn: (x: T) => mixed, x: T): T;
+
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B
+  ): ((catcher: (e: E, a: A) => B) => (a: A) => B) &
+    ((catcher: (e: E, a: A) => B, a: A) => B);
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B
+  ): (a: A) => B;
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B,
+    a: A
+  ): B;
+
+  declare function unapply<T, V>(
+    fn: (xs: $ReadOnlyArray<T>) => V
+  ): (...args: Array<T>) => V;
+
+  declare function unary<T, A, V>(fn: (A, ...args: Array<V>) => T): (x: A) => T;
+
+  declare var uncurryN: (<A, B, C>(2, (A) => B => C) => (A, B) => C) &
+    (<A, B, C, D>(3, (A) => B => C => D) => (A, B, C) => D) &
+    (<A, B, C, D, E>(4, (A) => B => C => D => E) => (A, B, C, D) => E) &
+    (<A, B, C, D, E, F>(
+      5,
+      (A) => B => C => D => E => F
+    ) => (A, B, C, D, E) => F) &
+    (<A, B, C, D, E, F, G>(
+      6,
+      (A) => B => C => D => E => F => G
+    ) => (A, B, C, D, E, F) => G) &
+    (<A, B, C, D, E, F, G, H>(
+      7,
+      (A) => B => C => D => E => F => G => H
+    ) => (A, B, C, D, E, F, G) => H) &
+    (<A, B, C, D, E, F, G, H, I>(
+      8,
+      (A) => B => C => D => E => F => G => H => I
+    ) => (A, B, C, D, E, F, G, H) => I);
+
+  //TODO useWith
+
+  // *Logic
+
+  declare function allPass<T>(
+    fns: $ReadOnlyArray<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function and<X, Y>(x: X): (y: Y) => X | Y;
+  declare function and<X, Y>(x: X, y: Y): X | Y;
+
+  declare function anyPass<T>(
+    fns: $ReadOnlyArray<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function both<T, F: (...args: Array<T>) => boolean>(x: F): (y: F) => F;
+  declare function both<T, F: (...args: Array<T>) => boolean>(x: F, y: F): F;
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement declaration.
+
+  declare function complement< Fn: () => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, Fn: (A) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, Fn: (A, B) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, Fn: (A, B, C) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, Fn: (A, B, C, D) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, Fn: (A, B, C, D, E) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, Fn: (A, B, C, D, E, F) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, Fn: (A, B, C, D, E, F, G) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, Fn: (A, B, C, D, E, F, G, H) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, Fn: (A, B, C, D, E, F, G, H, I) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, J, Fn: (A, B, C, D, E, F, G, H, I, J) => boolean>(
+    f: Fn
+  ): Fn;
+  // End generated complement declaration.
+
+  declare function cond<A>(
+    fns: $ReadOnlyArray<[
+      (...r: Array<A>) => boolean,
+      (...r: Array<A>) => B
+    ]>
+  ): (...r: Array<A>) => B;
+
+  declare function defaultTo<T, V>(d: T): (x: ?V) => V | T;
+  declare function defaultTo<T, V>(d: T, x: ?V): V | T;
+
+  declare function either<A, F: (...args: Array<A>) => boolean>(x: F): (y: F) => F;
+  declare function either<A, F: (...args: Array<A>) => boolean>(x: F, y: F): F;
+
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean
+  ): ((
+    f1: (...args: Args) => B
+  ) => (f2: (...args: Args) => C) => (...args: Args) => B | C) &
+    ((
+      f1: (...args: Args) => B,
+      f2: (...args: Args) => C
+    ) => (...args: Args) => B | C);
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean,
+    f1: (...args: Args) => B,
+    f2: (...args: Args) => C
+  ): (...args: Args) => B | C;
+
+  declare function isEmpty<A>(x: ?$ReadOnlyArray<A> | { ... } | string): boolean;
+
+  declare function not(x: boolean): boolean;
+
+  declare function or<X, Y>(x: X): (y: Y) => X | Y;
+  declare function or<X, Y>(x: X, y: Y): X | Y;
+
+  declare var pathSatisfies: CurriedFunction3<
+    UnaryPredicateFn<mixed>,
+    $ReadOnlyArray<string | number>,
+    { ... },
+    boolean
+  >;
+
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+  ): ((prop:  K) => (o: T) => boolean) &
+    ((prop:  K, o: T) => boolean);
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+    prop: K,
+  ): (o: T) => boolean;
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+    prop: K,
+    o: T
+  ): boolean;
+
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+  ): (x: T | S) => V | T;
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: T) => T) => (x: T) => T) &
+    ((fn: (x: T) => T, x: T) => T);
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T,
+  ): (x: T) => T;
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T,
+    x: T
+  ): T;
+
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+  ): (x: T | S) => V | T;
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_cjs_modules.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_cjs_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_cjs_modules.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_cjs_modules.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_compose.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_compose.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_compose.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_compose.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_es_modules.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_es_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_es_modules.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_es_modules.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_filter.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_filter.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_filter.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_filter.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_functions.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_functions.js
new file mode 100644
index 0000000000..dc65226d55
--- /dev/null
+++ b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_functions.js
@@ -0,0 +1,574 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, pipe, uncurryN, curry, pipeP, pipeK, tryCatch, applyTo } from "ramda";
+// Function
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// TODO: "Gap" Functions: Started failing in v31...
+// const g = _.propIs
+// const __ = _.__
+// const g1: boolean = g(1, '2', {p: 3})
+// const g2: boolean = g(__, '2', {p: 3})(1)
+// const g3: boolean = g(__, __, {p: 3})(1)('2')
+// const g4: boolean = g(__, __, {p: 3})(1, '2')
+// const g5: boolean = g(__, '2', __)(1, {p: 3})
+// const g6: boolean = g(__, '2')(1)({p: 3})
+// const g7: boolean = g(__, '2')(1, {p: 3})
+// const g8: boolean = g(__, '2')(__, {p: 3})(1)
+
+type R = {
+  sum: number,
+  nested: { mul: number, ... },
+  ...
+};
+// TODO: "Gap" Functions: Started failing in v31...
+// const greet: string = _.replace('{name}', _.__, 'Hello, {name}!')('John')
+const truth: boolean = _.T("ddd");
+const lie: boolean = _.F("ddd");
+const mapIndexed = _.addIndex(_.map);
+
+const mi: Array<string> = mapIndexed((val, idx) => idx + "-" + val, [
+  "f",
+  "o",
+  "o",
+  "b",
+  "a",
+  "r"
+]);
+
+const t: string = _.always("Tee")();
+const app: Array<number> = _.ap([_.multiply(2), _.add(3)], [1, 2, 3]);
+const app1: Array<string | number> = _.ap([_.toString, _.add(3)], [1, 2, 3]);
+
+const nums = [1, 2, 3, -99, 42, 6, 7];
+const applied: number = _.apply(Math.max, nums);
+const spec = {
+  sum: _.add,
+  nested: { mul: _.multiply }
+};
+
+const applyToResult1 = applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult1: string);
+// $FlowExpectedError
+(applyToResult1: number);
+
+const applyToResult2 = applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult2: string);
+// $FlowExpectedError
+(applyToResult2: number);
+
+const getMetrics = _.applySpec(spec);
+const apspec: $Shape<R> = getMetrics(2, 2);
+
+const applyToResult3 = _.applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult3: string);
+// $FlowExpectedError
+(applyToResult3: number);
+
+const applyToResult4 = _.applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult4: string);
+// $FlowExpectedError
+(applyToResult4: number);
+
+const cmp: (x: Object, y: Object) => number = _.comparator(
+  (a, b) => a.age < b.age
+);
+const compf: number = _.compose(_.inc, _.negate)(2);
+
+const fn = compose(_.add);
+const fn1: (n: number) => number = fn(2);
+const add2 = _.compose(_.add(2));
+const four: number = add2(2);
+const str0: Array<string | void> = _.compose(_.match(/2/), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const fn2: (n: number) => (n: number) => number = pipe(_.add);
+const fn3: (n: number) => number = fn2(2);
+const add2p = _.pipe(_.add(2));
+const b: number = add2p(2);
+const fail: string = _.pipe(_.trim)("h");
+const str3: Array<string | void> = _.pipe(_.toLower, _.trim, _.match(/2/))(
+  " 1,2,3 "
+);
+const str4: Array<string> = _.pipe(_.toLower, _.trim, _.split(","))(" 1,2,3 ");
+const str5: string = _.pipe(_.replace("3", "4"), _.toLower, _.trim)(" 1,2,3 ");
+
+// --- Curry ---
+declare var bar1: string => "bar1";
+declare var bar2: (string, number) => "bar2";
+declare var bar6: (string, number, boolean, null, {...}, []) => "bar6";
+
+const foo1 = curry(bar1);
+const foo2 = curry(bar2);
+const foo6 = curry(bar6);
+
+const foo1_1: "bar1" = foo1("");
+const foo2_1: "bar2" = foo2("", 0);
+const foo2_2: "bar2" = foo2("")(0);
+
+const foo6_1: "bar6" = foo6("", 0, true, null, {}, []);
+const foo6_2: "bar6" = foo6("")(0, true, null, {}, []);
+const foo6_3: "bar6" = foo6("", 0)(true, null, {}, []);
+const foo6_4: "bar6" = foo6("", 0, true)(null, {}, []);
+const foo6_5: "bar6" = foo6("", 0, true, null)({}, []);
+const foo6_6: "bar6" = foo6("", 0, true, null, {})([]);
+const foo6_7: "bar6" = foo6("")(0)(true, null, {}, []);
+const foo6_8: "bar6" = foo6("", 0)(true)(null, {}, []);
+const foo6_9: "bar6" = foo6("", 0, true)(null)({}, []);
+const foo6_10: "bar6" = foo6("", 0, true, null)({})([]);
+const foo6_11: "bar6" = foo6("")(0, true)(null, {}, []);
+const foo6_12: "bar6" = foo6("", 0)(true, null)({}, []);
+const foo6_13: "bar6" = foo6("", 0, true)(null, {})([]);
+const foo6_14: "bar6" = foo6("")(0, true, null)({}, []);
+const foo6_15: "bar6" = foo6("", 0)(true, null, {})([]);
+const foo6_16: "bar6" = foo6("")(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error1: "bar6" = foo6(false, 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error1: "bar6" = foo6(false)(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error1: "bar6" = foo6(false, 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error1: "bar6" = foo6(false, 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error1: "bar6" = foo6(false, 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error1: "bar6" = foo6(false, 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error1: "bar6" = foo6(false)(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error1: "bar6" = foo6(false, 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error1: "bar6" = foo6(false, 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error1: "bar6" = foo6(false, 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error1: "bar6" = foo6(false)(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error1: "bar6" = foo6(false, 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error1: "bar6" = foo6(false, 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error1: "bar6" = foo6(false)(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error1: "bar6" = foo6(false, 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error1: "bar6" = foo6(false)(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error2: "bar6" = foo6("", 0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_2_Error2: "bar6" = foo6("")(0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_3_Error2: "bar6" = foo6("", 0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_4_Error2: "bar6" = foo6("", 0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_5_Error2: "bar6" = foo6("", 0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_6_Error2: "bar6" = foo6("", 0, true, "", {})([]);
+// $FlowExpectedError
+const foo6_7_Error2: "bar6" = foo6("")(0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_8_Error2: "bar6" = foo6("", 0)(true)("", {}, []);
+// $FlowExpectedError
+const foo6_9_Error2: "bar6" = foo6("", 0, true)("")({}, []);
+// $FlowExpectedError
+const foo6_10_Error2: "bar6" = foo6("", 0, true, "")({})([]);
+// $FlowExpectedError
+const foo6_11_Error2: "bar6" = foo6("")(0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_12_Error2: "bar6" = foo6("", 0)(true, "")({}, []);
+// $FlowExpectedError
+const foo6_13_Error2: "bar6" = foo6("", 0, true)("", {})([]);
+// $FlowExpectedError
+const foo6_14_Error2: "bar6" = foo6("")(0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_15_Error2: "bar6" = foo6("", 0)(true, "", {})([]);
+// $FlowExpectedError
+const foo6_16_Error2: "bar6" = foo6("")(0, true, "", {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error3: "bar6" = foo6("", 0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_2_Error3: "bar6" = foo6("")(0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_3_Error3: "bar6" = foo6("", 0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_4_Error3: "bar6" = foo6("", 0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_5_Error3: "bar6" = foo6("", 0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_6_Error3: "bar6" = foo6("", 0, true, null, {})("");
+// $FlowExpectedError
+const foo6_7_Error3: "bar6" = foo6("")(0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_8_Error3: "bar6" = foo6("", 0)(true)(null, {}, "");
+// $FlowExpectedError
+const foo6_9_Error3: "bar6" = foo6("", 0, true)(null)({}, "");
+// $FlowExpectedError
+const foo6_10_Error3: "bar6" = foo6("", 0, true, null)({})("");
+// $FlowExpectedError
+const foo6_11_Error3: "bar6" = foo6("")(0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_12_Error3: "bar6" = foo6("", 0)(true, null)({}, "");
+// $FlowExpectedError
+const foo6_13_Error3: "bar6" = foo6("", 0, true)(null, {})("");
+// $FlowExpectedError
+const foo6_14_Error3: "bar6" = foo6("")(0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_15_Error3: "bar6" = foo6("", 0)(true, null, {})("");
+// $FlowExpectedError
+const foo6_16_Error3: "bar6" = foo6("")(0, true, null, {})("");
+
+// $FlowExpectedError
+const foo6_1_Error4: "error" = foo6("", 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error4: "error" = foo6("")(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error4: "error" = foo6("", 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error4: "error" = foo6("", 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error4: "error" = foo6("", 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error4: "error" = foo6("", 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error4: "error" = foo6("")(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error4: "error" = foo6("", 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error4: "error" = foo6("", 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error4: "error" = foo6("", 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error4: "error" = foo6("")(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error4: "error" = foo6("", 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error4: "error" = foo6("", 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error4: "error" = foo6("")(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error4: "error" = foo6("", 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error4: "error" = foo6("")(0, true, null, {})([]);
+
+// -------------
+
+const currfn1: (y: number) => number = _.curryN(
+  2,
+  (x: number, y: number): number => x + y
+)(2);
+
+const flipped: (x: number, y: boolean, z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const flipped2: (x: number, y: boolean) => (z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const obb = {
+  doStuff(x: string, y: number, z: boolean) {
+    return 1;
+  },
+  doLessStuff(x: string, y: number) {
+    return "hello";
+  },
+  doEvenLessStuff(x: string) {
+    return true;
+  }
+};
+const doStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doStuff");
+//$FlowExpectedError
+const doLessStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doLStuff");
+const stuffDone: number = doStuff("dd", 1, true, obb);
+
+const range = _.juxt([_.toString, Math.min, Math.max]);
+const ju: Array<number | string> = range(3, 4, 9, -3);
+
+
+let _memoizeWith = 0;
+const _memoizeWithFactorial = _.memoizeWith(_.identity, n => {
+  _memoizeWith += 1;
+  return _.product(_.range(1, n + 1));
+});
+const memWith: number = _memoizeWithFactorial(5);
+
+const narg: string | number = _.nthArg(1)(1, "b", "c");
+
+const nameIs = ({ first, last }) => `The name's ${last}, ${first} ${last}`;
+const o1: string = _.o(_.toUpper, nameIs)({ first: "James", last: "Bond" });
+const oNum: number = _.o(_.multiply(10), _.add(10))(-4);
+
+const oof: Array<Array<number>> = _.of([42]);
+
+const unap: string = _.unapply(JSON.stringify)(1, 2, 3);
+
+const greetName = name => "Hello " + name;
+
+// Uncurry
+const needs3: string => string => string => string = a => b => c => a + b + c;
+
+//$FlowExpectedError
+const needs3_error1: number = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error2: string => string = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error3: string => string => string = uncurryN(3, needs3)(
+  "",
+  "",
+  ""
+);
+
+const needs3_no_error: string = uncurryN(3, needs3)("", "", "");
+
+// --- PipeP ---
+const pAdd: number => number => Promise<number> = a => b =>
+  Promise.resolve(a + b);
+const pAppend: string => string => Promise<string> = a => b =>
+  Promise.resolve(a + b);
+const pToString: number => Promise<string> = n => Promise.resolve(String(n));
+const pFn1: number => Promise<number> = pipeP(pAdd(2));
+const pFoo1: Promise<number> = pFn1(2);
+const pFn2: number => Promise<string> = pipeP(pAdd(2), pToString);
+const pFoo2: Promise<string> = pFn2(2);
+const pFn3: number => Promise<string> = pipeP(pAdd(2), pToString, pAppend("A"));
+const pFoo3: Promise<string> = pFn3(2);
+const pFn4: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B")
+);
+const pFoo4: Promise<string> = pFn4(2);
+const pFn5: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAppend("C")
+);
+const pFoo5: Promise<string> = pFn5(2);
+const pFn6: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAppend("C"),
+  pAppend("D")
+);
+const pFoo6: Promise<string> = pFn6(2);
+
+//$FlowExpectedError
+const pipeP_error1: number => Promise<number> = _.pipeP(_.add(2));
+//$FlowExpectedError
+const pipeP_error2: number => Promise<string> = _.pipeP(pAdd(2), String);
+//$FlowExpectedError
+const pipeP_error3: number => Promise<number> = pipeP(
+  pAdd(2),
+  pToString,
+  pAdd(2)
+);
+//$FlowExpectedError
+const pipeP_error4: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAdd(2)
+);
+//$FlowExpectedError
+const pipeP_error5: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAdd(2)
+);
+const pipeP_error6: number => Promise<string> = pipeP(
+//$FlowExpectedError
+  pAdd(2), pToString, pAppend("A"), pAppend("B"), pAppend("C"), pAdd(2)
+);
+
+// -------------
+
+// --- PipeK ---
+
+class Box<A>  {
+    value: A;
+
+    constructor(x) {
+        this.value = x;
+    }
+
+    chain(f: A => any) {
+        return f(this.value);
+    }
+
+    static of<T: any>(x: T): Box<T> {
+        return new Box(x);
+    }
+}
+
+const kAdd: number => number => Box<number> = a => b =>
+  Box.of(a + b);
+const kAppend: string => string => Box<string> = a => b =>
+  Box.of(a + b);
+const kToString: number => Box<string> = n => Box.of(String(n));
+const kFn1: number => Box<number> = pipeK(kAdd(2));
+const kFoo1: Box<number> = kFn1(2);
+const kFn2: number => Box<string> = pipeK(kAdd(2), kToString);
+const kFoo2: Box<string> = kFn2(2);
+const kFn3: number => Box<string> = pipeK(kAdd(2), kToString, kAppend("A"));
+const kFoo3: Box<string> = kFn3(2);
+const kFn4: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B")
+);
+const kFoo4: Box<string> = kFn4(2);
+const kFn5: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAppend("C")
+);
+const kFoo5: Box<string> = kFn5(2);
+const kFn6: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAppend("C"),
+  kAppend("D")
+);
+const kFoo6: Box<string> = kFn6(2);
+
+//$FlowExpectedError
+const pipeK_error1: number => Box<number> = _.pipeK(_.add(2));
+//$FlowExpectedError
+const pipeK_error2: number => Box<string> = _.pipeK(kAdd(2), String);
+//$FlowExpectedError
+const pipeK_error3: number => Box<number> = pipeK(
+  kToString,
+  kAdd(2),
+  kAdd(2)
+);
+//$FlowExpectedError
+const pipeK_error4: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAdd(2)
+);
+//$FlowExpectedError
+const pipeK_error5: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAdd(2)
+);
+const pipeK_error6: number => Box<number> = pipeK(
+//$FlowExpectedError
+  kAdd(2), kToString, kAppend("A"), kAppend("B"), kAppend("C"), kAdd(2)
+);
+
+// -------------
+
+// --- TyrCatch ---
+const tryFn: boolean => string = a => String(a);
+
+const tryFn_2: boolean => boolean = a => a;
+
+const catchFn: (Error, boolean) => string = (e, a) => e.message;
+
+const catchFn_2: (Error, boolean) => boolean = (e, a) => a;
+
+const tc1: string = tryCatch(tryFn, catchFn, true);
+const tc2: boolean => string = tryCatch(tryFn, catchFn);
+const tc3: string = tc2(true);
+//const tc7: string = tryCatch(tryFn)(catchFn)(true);
+const tc4: string = tryCatch(tryFn)(catchFn, true);
+const tc5: string = tryCatch(tryFn)(catchFn)(true);
+
+//$FlowExpectedError
+const tc_error1: boolean = tryCatch(tryFn, catchFn, true);
+//$FlowExpectedError
+const tc_error2: boolean = tryCatch(tryFn, catchFn)(true);
+//$FlowExpectedError
+const tc_error3: boolean = tryCatch(tryFn)(catchFn, true);
+//$FlowExpectedError
+const tc_error4: boolean = tryCatch(tryFn)(catchFn)(true);
+//$FlowExpectedError
+const tc_error5: string = tryCatch(tryFn_2, catchFn, "string");
+//$FlowExpectedError
+const tc_error6: string = tryCatch(tryFn_2, catchFn)("string");
+//$FlowExpectedError
+const tc_error7: string = tryCatch(tryFn_2)(catchFn, "string");
+//$FlowExpectedError
+const tc_error8: string = tryCatch(tryFn_2)(catchFn)("string");
+//$FlowExpectedError
+const tc_error9: string = tryCatch(tryFn_2, catchFn, true);
+//$FlowExpectedError
+const tc_error10: string = tryCatch(tryFn_2, catchFn)(true);
+//$FlowExpectedError
+const tc_error11: string = tryCatch(tryFn_2)(catchFn, true);
+//$FlowExpectedError
+const tc_error12: string = tryCatch(tryFn_2)(catchFn)(true);
+//$FlowExpectedError
+const tc_error13: string = tryCatch(tryFn, catchFn_2, true);
+//$FlowExpectedError
+const tc_error14: string = tryCatch(tryFn, catchFn_2)(true);
+//$FlowExpectedError
+const tc_error15: string = tryCatch(tryFn)(catchFn_2, true);
+//$FlowExpectedError
+const tc_error16: string = tryCatch(tryFn)(catchFn_2)(true);
+
+// -------------
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_list.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_list.js
new file mode 100644
index 0000000000..cfced4f709
--- /dev/null
+++ b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_list.js
@@ -0,0 +1,974 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  type RefineFilter,
+  adjust,
+  append,
+  chain,
+  compose,
+  concat,
+  contains,
+  curry,
+  filter,
+  find,
+  groupBy,
+  includes,
+  last,
+  length,
+  nth,
+  pipe,
+  reduce,
+  repeat,
+  subtract,
+  uniq,
+  without,
+  zipWith
+} from "ramda";
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: number | string, ... }> = [
+  { a: 1, c: "d" },
+  { b: 2 }
+];
+const str: string = "hello world";
+
+// List
+{
+  const xs: Array<number> = _.adjust(2, x => x + 1, ns);
+  const xs1: Array<number> = _.adjust(2, x => x + 1)(ns);
+  //$FlowExpectedError
+  const xs3: Array<string> = _.adjust(2)(x => x + 1)(ns);
+
+  const as: boolean = _.all(x => x > 1, ns);
+  const asf: (s: Array<string>) => boolean = _.any(x => x.length > 1);
+  const as1: boolean = asf(ss);
+
+  const aps: Array<Array<number>> = _.aperture(2, ns);
+  const aps2: Array<Array<string>> = _.aperture(2)(ss);
+
+  const newXs1: Array<number> = _.prepend(1)(ns);
+
+  describe('concat', () => {
+    it('should support array', () => {
+      const r1: Array<number> = concat([4, 5, 6], [1, 2, 3]);
+      const r2: Array<number> = concat([4, 5, 6])([1, 2, 3]);
+    });
+    it('should supports strings', () => {
+      const r1: string = concat("ABC", "DEF");
+      const r2: string = concat("ABC")("DEF");
+    });
+    it('should support readonly arrays', () => {
+      const arr1: $ReadOnlyArray<number> = [4, 5, 6];
+      const arr2: $ReadOnlyArray<string> = ['1', '2', '3'];
+      const r1: Array<number|string> = concat(arr1, arr2);
+      const r2: Array<number|string> = concat(arr1)(arr2);
+
+      // $FlowExpectedError
+      const r3: Array<number> = concat(arr1)(arr2);
+      // $FlowExpectedError
+      const r4: Array<string> = concat(arr1)(arr2);
+    });
+    it('should error when concat array with string', () => {
+      // $FlowExpectedError
+      concat("ABC", ["DEF"]);
+    });
+  });
+
+  const dropxs: Array<string> = _.drop(4, ss);
+  const dropxs1: string = _.drop(3)(str);
+  const dropxs2: Array<string> = _.dropLast(4, ss);
+  const dropxs3: string = _.dropLast(3)(str);
+  const dropxs4: Array<number> = _.dropLastWhile(x => x <= 3, ns);
+  const dropxs5: Array<string> = _.dropRepeats(ss);
+  const dropxs6: Array<number> = _.dropRepeatsWith(_.eqBy(Math.abs), ns);
+  const dropxs7: Array<number> = _.dropWhile(x => x === 1, ns);
+
+  // The contains libdef is the same as includes, and tests should be duplicated
+  // across the two. As of 0.26.0 contains is deprecated, but still present.
+  describe('contains', () => {
+    describe('uncurried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = contains(2, xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = contains(2, xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = contains('foo', xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<string> = ['bar']
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = contains(1, xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = contains('foo', 'bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = contains(1, 'bar')
+      })
+    })
+
+    describe('1 arg curried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = contains(2)(xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = contains(2)(xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = contains('foo')(xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = contains('foo')(xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = contains('foo')('bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = contains(1)('bar')
+      })
+    })
+  })
+
+  describe('includes', () => {
+    describe('uncurried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = includes(2, xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = includes(2, xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = includes('foo', xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<string> = ['bar']
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = includes(1, xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = includes('foo', 'bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = includes(1, 'bar')
+      })
+    })
+
+    describe('1 arg curried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = includes(2)(xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = includes(2)(xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = includes('foo')(xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = includes('foo')(xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = includes('foo')('bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = includes(1)('bar')
+      })
+    })
+  })
+
+  describe('startsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.startsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is starting in another array', () => {
+      const result: boolean = _.startsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.startsWith%28%5B1%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the starting of an array', () => {
+      const result: boolean = _.startsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.startsWith%28%5B1%2C%202%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.startsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.startsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.startsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  describe('endsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.endsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is ending in another array', () => {
+      const result: boolean = _.endsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.endsWith%28%5B3%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the ending of an array', () => {
+      const result: boolean = _.endsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.endsWith%28%5B2%2C%203%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.endsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.endsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.endsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  const chainxs: number[] = _.chain((n) => [n, n], [1, 2])
+  const chainxs1: number[] = _.chain((n) => [n, n])([1, 2])
+
+  const findxs: ?{ [k: string]: number | string, ... } = _.find(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs1: ?{ [k: string]: number | string, ... } = _.find(_.propEq("a", 4))(
+    os
+  );
+  // Ramda doesn't strictly break if you pass it an object, but it always
+  // returns undefined.
+  // $FlowExpectedError
+  const findObj = find(o => o == "bar", { foo: "bar" });
+
+  const findxs2: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs3: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 4)
+  )(os);
+  const findxs4: number = _.findIndex(_.propEq("a", 2), os);
+  const findxs5: number = _.findIndex(_.propEq("a", 4))(os);
+  const findxs6: number = _.findLastIndex(_.propEq("a", 2), os);
+  const findxs7: number = _.findLastIndex(_.propEq("a", 4))(os);
+
+
+  describe('length', () => {
+    describe('works on', () => {
+      it('empty array', () => {
+        length([])
+      })
+      it('simple array of strings', () => {
+        length(ss)
+      })
+      it('heterogeneous arrays', () => {
+        length([1, '', ss, true, ns])
+      })
+      it('strings', () => {
+        length(str)
+      })
+      it('objects defining numeric .length property', () => {
+        length({length: 12})
+      })
+    })
+    describe('fails on', () => {
+      it('null and undefined', () => {
+        // $FlowExpectedError
+        length(null)
+        // $FlowExpectedError
+        length()
+      })
+      it('types that has no length', () => {
+        // $FlowExpectedError
+        length(123)
+      })
+      it('non-numeric .length property', () => {
+        // $FlowExpectedError
+        length({length: 'size'})
+      })
+    })
+  })
+
+  const s4 = _.find(x => x === "2", ["1", "2"]);
+  //$FlowExpectedError
+  const s5: ?{ [key: string]: string, ... } = _.find(x => x === "2", { a: 1, b: 2 });
+  const s6: number = _.findIndex(x => x === "2", ["1", "2"]);
+  const forEachxs = _.forEach(x => console.log(x), ns);
+
+  const forEachObj = _.forEachObjIndexed((value, key) => {}, { x: 1, y: 2 });
+
+  describe('groupBy', () => {
+    it('should work with basic array', () => {
+      const fn = x => `${x}`;
+      const groupedBy: { [k: string]: Array<number>, ... } = groupBy(fn, [1, 2, 3]);
+      const groupedBy1: { [k: string]: Array<string>, ... } = groupBy(fn)(['one', 'two', 'three']);
+    });
+    it('group function should return string', () => {
+      const fn: number => number = x => x;
+
+      // $FlowExpectedError
+      groupBy(fn, [1,2,3]);
+      // $FlowExpectedError
+      groupBy(fn)([1,2,3]);
+    });
+    it('group function param should match array element', () => {
+      const fn: string => string = x => x;
+
+      // $FlowExpectedError
+      groupBy(fn, [1,2,3]);
+      // $FlowExpectedError
+      groupBy(fn)([1,2,3]);
+    });
+    it('should support readonly array', () => {
+      const fn: (number | string) => string = x => `${x}`;
+      const arr: $ReadOnlyArray<number> = [1, 2, 3];
+      const groupedBy: { [k: string]: Array<number>, ... } = groupBy(fn, arr);
+      const arr1: $ReadOnlyArray<number|string> = [1, 'two', 3];
+      const groupedBy1: { [k: string]: Array<number|string>, ... } = groupBy(fn)(arr1);
+
+      const fn1: number => string = x => `${x}`;
+      // $FlowExpectedError
+      groupBy(fn1, arr1);
+      // $FlowExpectedError
+      const groupedBy2: { [k: string]: Array<number> } = groupBy(fn)(arr1);
+    });
+  });
+
+  const groupedWith: Array<Array<number>> = _.groupWith(x => x > 1, ns);
+  const groupedWith1: Array<Array<string>> = _.groupWith(x => x === "one")(ss);
+
+  describe('head', () => {
+    describe('with array', () => {
+      it('should returns MaybeOf element type', () => {
+        const fn = (arr: number[]) => {
+          const xOfXs: ?number = _.head(arr);
+          //$FlowExpectedError
+          const xOfXs: number = _.head(arr);
+        }
+      });
+      it('should works with refinement', () => {
+        const fn = (arr: number[]) => {
+          if (arr.length > 0) {
+            const xOfXs: number = _.head(arr);
+          }
+        }
+      });
+      it('should works with mixed-type arrays', () => {
+        const fn = (arr: Array<number|string>) => {
+          const xOfXs: ?(number|string) = _.head(arr);
+          //$FlowExpectedError
+          const xOfXs: ?number = _.head(arr);
+          if (arr.length > 0) {
+            const xOfXs: number|string = _.head(arr);
+            //$FlowExpectedError
+            const xOfXs: number = _.head(arr);
+          }
+        }
+      });
+    });
+    describe('with string', () => {
+      it('should works', () => {
+        const xOfStr: string = _.head(str);
+      });
+    })
+  });
+
+  const transducer = _.compose(_.map(_.add(1)), _.take(2));
+
+  const txs: Array<number> = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs1: string = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs2: string = _.into([], transducer, ss);
+
+  const ind: number = _.indexOf(1, ns);
+  const ind1: number = _.indexOf(str)(ss);
+  const ind2: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s",
+    os
+  );
+  const ind3: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s"
+  )(os);
+  const ind4: number = _.indexOf(null)(ss);
+
+  const insxs: Array<number> = _.insert(1, 2, ns);
+  const insxs2: Array<string> = _.insert(1, "2", ss);
+
+  const insxs3: Array<number> = _.insertAll(1, [2, 3], ns);
+  // this is disgusting — don't do this :)
+  // Technically it's a tuple with arbitrary size
+  const insxs4: Array<number | boolean | string> = _.insertAll(
+    1,
+    ["2", false],
+    ns
+  );
+  const insxs5: Array<string | number> = _.insertAll(1, [2], ss);
+
+  const joinxs: string = _.join("|", ns);
+
+  const lastxs: ?number = _.last(ns);
+  const laststr: string = _.last(str);
+
+  const lasti: number = _.lastIndexOf(3, [-1, 3, 3, 0, 1, 2, 3, 4]);
+
+  const mapxs: Array<number> = _.map(x => x + 1, ns);
+
+  const someObj: {
+    a: string,
+    b: number,
+    ...
+  } = { a: 'a', b: 2 }
+  const someMap: { [string]: {
+    a: string,
+    b: number,
+    ...
+  }, ... } = { so: someObj }
+  const mapObj: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a)(someMap)
+  const mapObj2: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a, someMap)
+
+  const functor = {
+    x: 1,
+    map(f) {
+      return f(this.x);
+    }
+  };
+
+  // Doesn't typecheck (yet) but at least doesn't break
+  const mapFxs = _.map(_.toString, functor);
+
+  const double = x => x * 2;
+  const dxs: Array<number> = _.map(double, [1, 2, 3]);
+  const dos: $Shape<typeof obj> = _.map(double, obj);
+
+  const appender = (a, b) => [a + b, a + b];
+  const mapacc: [number, Array<number>] = _.mapAccum(appender, 0, ns);
+  const mapacc1: [number, Array<number>] = _.mapAccumRight(appender, 0, ns);
+
+  const nxs: boolean = _.none(x => x > 1, ns);
+
+  describe('append', () => {
+    it('should supports arrays', () => {
+      const appendResult1: Array<number> = append(1, [1, 2, 3]);
+      const appendResult2: Array<string> = append('four')(['one', 'two', 'three']);
+    });
+    it('should works with read-only array', (readOnly: $ReadOnlyArray<number>) => {
+      const appendResult1: $ReadOnlyArray<number> = append(1, readOnly);
+      const appendResult2: $ReadOnlyArray<number> = append(1)(readOnly);
+    });
+    it('should result array element should be correct', () => {
+      const readOnly: $ReadOnlyArray<number> = [1, 2, 3];
+      const appendResult1: $ReadOnlyArray<number|string> = append('s', readOnly);
+      const appendResult2: $ReadOnlyArray<number|string> = append('s')(readOnly);
+
+      //$FlowExpectedError
+      const appendResult3: $ReadOnlyArray<number|null> = append('s', readOnly);
+      //$FlowExpectedError
+      const appendResult4: $ReadOnlyArray<number> = append('s')(readOnly);
+    });
+  });
+
+  const xxxs: Array<number> = _.intersperse(1, [1, 2, 3]);
+
+  const pairxs: [number, string] = _.pair(2, "str");
+
+  const partxs: [Array<string>, Array<string>] = _.partition(_.contains("s"), [
+    "sss",
+    "ttt",
+    "foo",
+    "bars"
+  ]);
+  const partxs1: [
+    { [k: string]: string, ... },
+    { [k: string]: string, ... }
+  ] = _.partition(_.contains("s"), { a: "sss", b: "ttt", foo: "bars" });
+
+  describe('pluck', () => {
+    it('should works on array of objects as maps', () => {
+      const arr: Array<{ [string]: number | string, ... }> = [{ a: "1" }, { a: 2 }];
+      const pl: Array<number | string> = _.pluck("a")(arr);
+      const p2: Array<number | string> = _.pluck("b")(arr);
+    });
+    it('should works on array of arrays', () => {
+      const pl: Array<number> = _.pluck(0)([[1, 2], [3, 4]]);
+    });
+    it('should works on array of objects', () => {
+      const arr: Array<{
+        key: number,
+        other?: string,
+        ...
+      }> = [{ key: 42 }, { key: 28, other: 'string' }];
+      const pl: number[] = _.pluck('key', arr);
+    });
+    it('should fails on non existing property', () => {
+      //$FlowExpectedError
+      const pl = _.pluck('notExistingKey', [{ key: 42 }, { key: 28, other: 'string' }]);
+      //$FlowExpectedError
+      const pl = _.pluck('other', [{ key: 42 }, { key: 28, other: 'string' }]);
+    });
+    it('should returns union type of selected property', () => {
+      const arr = [{ key: 42 }, { key: 'string', other: 'string' }];
+      const pl: Array<number | string> = _.pluck('key', arr);
+      //$FlowExpectedError
+      const pl: number[] = _.pluck('key', arr);
+    });
+  });
+
+  const rxs: Array<number> = _.range(1, 10);
+
+  const remxs: Array<string> = _.remove(0, 2, ss);
+  const remxs1: Array<string> = _.remove(0, 2)(ss);
+  const remxs2: Array<string> = _.remove(0)(2)(ss);
+  const remxs3: Array<string> = _.remove(0)(2, ss);
+
+  const ys4: Array<string> = _.repeat("1", 10);
+  const ys5: Array<number> = _.repeat(1, 10);
+
+  // reduce
+  const redxs: number = reduce(_.add, 10, ns);
+  const redxs1: string = reduce(concat, "", ss);
+  const redxs2: Array<string> = reduce<string[], string[]>(concat, [])(_.map(x => [x], ss));
+  // Example used in docs: http://ramdajs.com/docs/#reduce
+  const redxs4: number = reduce(subtract, 0, [1, 2, 3, 4]);
+  // Using accumulator type that differs from the element type (A and B).
+  const redxs5: number = reduce((acc, s) => acc + parseInt(s), 0, [
+    "1",
+    "2",
+    "3"
+  ]);
+
+  const redux6a: number = reduce((acc, s) => _.reduced(acc), 0, ns)
+  const redux6b: number = reduce((acc: number, s: number) => _.reduced(acc), 0, ns)
+  const redxs7: number = reduce(
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(acc),
+    0,
+    ["1", "2", "3"]
+  );
+  // $FlowExpectedError
+  const redxs8: number = reduce(
+    // $FlowExpectedError
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(s),
+    0,
+    ["1", "2", "3"]
+  );
+
+  // Ramda works with $ReadOnlyArray as it is immutable.
+  const readOnlyArray: $ReadOnlyArray<number> = [1, 2, 3, 4];
+  // $ReadOnlyArray with curried permutations:
+  const redxsReadOnly3: number = reduce(subtract, 0, readOnlyArray);
+  const redxsReadOnly2_1: number = reduce(subtract, 0)(readOnlyArray);
+  const redxsReadOnly1_2: number = reduce<number, number>(subtract)(0, readOnlyArray);
+  const redxsReadOnly1_1_1: number = reduce(subtract)(0)(readOnlyArray);
+
+  // $FlowExpectedError reduce will not work with an object.
+  reduce(subtract, 0, { foo: 1, bar: 2 });
+
+  // reduceRight
+  const redrxs1: number = _.reduceRight(_.add, 10, ns);
+  const redrxs2: string = _.reduceRight(concat, "", ss);
+  const redrxs3: Array<string> = _.reduceRight(concat, [])(
+    _.map(x => [x], ss)
+  );
+  const redrxs3a: string = _.reduceRight(
+    //$FlowExpectedError
+    (acc: string, value: number): string => acc,
+    "",
+    ns
+  );
+  const redrxs3b: string = _.reduceRight(
+    (value: number, acc: string): string => acc,
+    "",
+    ns
+  );
+
+  // $FlowExpectedError reduceRight does not support reduced.
+  const redrxs4: number = _.reduceRight(
+    // $FlowExpectedError reduceRight does not support reduced.
+    (acc, n) => acc < 4 ? acc + n : _.reduced(acc),
+    0,
+    ns
+  );
+
+  const scanxs6: Array<number> = _.scan(_.add)(10)(ns);
+  const scanxs7: Array<number> = _.scan(_.add, 10)(ns);
+  const scanxs8: Array<number> = _.scan(_.add)(10, ns);
+  const scanxs9: Array<number> = _.scan(_.add, 10, ns);
+  const scanxs10: Array<string> = _.scan(concat)("")(ss);
+  const scanxs11: Array<string> = _.scan(concat, "")(ss);
+  const scanxs12: Array<string> = _.scan(concat)("", ss);
+  const scanxs13: Array<string> = _.scan(concat, "", ss);
+
+  const reduceToNamesBy = _.reduceBy(
+    (acc, student) => acc.concat(student.name),
+    []
+  );
+  const namesByGrade = reduceToNamesBy(student => {
+    const score = student.score;
+    return score < 65
+      ? "F"
+      : score < 70 ? "D" : score < 80 ? "C" : score < 90 ? "B" : "A";
+  });
+  const students = [
+    { name: "Lucy", score: 92 },
+    { name: "Drew", score: 85 },
+    { name: "Bart", score: 62 }
+  ];
+  const names1: { [k: string]: Array<string>, ... } = namesByGrade(students);
+
+  const isOdd = (acc, x) => x % 2 === 1;
+  const reduceWhile1: number = _.reduceWhile(isOdd, _.add, 0, [1, 3, 5, 60, 777, 800]);
+  const reduceWhile2: number = _.reduceWhile(isOdd, _.add, 111, [2, 4, 6]);
+
+  const spl: Array<string> = _.split(/\./, "a.b.c.xyz.d");
+
+  const spl1: [Array<number>, Array<number>] = _.splitAt(1, [1, 2, 3]);
+  const spl2: [string, string] = _.splitAt(5, "hello world");
+  const spl3: [string, string] = _.splitAt(-1, "foobar");
+  const spl4: Array<Array<number>> = _.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]);
+  const spl5: Array<string> = _.splitEvery(3, "foobarbaz");
+  const spl6: [Array<number>, Array<number>] = _.splitWhen(_.equals(2))([
+    1,
+    2,
+    3,
+    1,
+    2,
+    3
+  ]);
+
+  const slixs: Array<string> = _.slice(0, 2, ss);
+  const slixs1: Array<string> = _.slice(0, 2)(ss);
+  const slixs2: Array<string> = _.slice(0)(2)(ss);
+  const slixs3: Array<string> = _.slice(0)(2, ss);
+
+  const diff = function(a, b) {
+    return a - b;
+  };
+  const sortxs: Array<number> = _.sort(diff, [4, 2, 7, 5]);
+
+  const timesxs: Array<number> = _.times(_.identity, 5);
+
+  const unf: (x: string) => Array<string> = _.unfold(
+    (x: string) => x.length > 10 || [x, x + "0"]
+  );
+  const unf1: Array<number> = _.unfold(x => x > 10 || [x, x + 1], 0);
+  const f = n => (n > 50 ? false : [-n, n + 10]);
+  const unf11: Array<number> = _.unfold(f, 10);
+
+  //$FlowExpectedError
+  const unf2 = _.unfold(x => x.length > 10 || [x, x + "0"], 2);
+
+  const unby: Array<number> = _.uniqBy(Math.abs)([-1, -5, 2, 10, 1, 2]);
+
+  const strEq = _.eqBy(String);
+  const strEq2 = _.eqBy(String, 1, 2);
+  const unw = _.uniqWith(strEq)([1, "1", 2, 1]);
+  const unw1 = _.uniqWith(strEq)([{}, {}]);
+  const unw2 = _.uniqWith(strEq)([1, "1", 1]);
+  const unw3 = _.uniqWith(strEq)(["1", 1, 1]);
+
+  //$FlowExpectedError
+  const ys6: { [key: string]: string, ... } = _.fromPairs([["h", 2]]);
+
+  describe('without', () => {
+    it('should work with basic array', () => {
+      const arr1: Array<number> = without([1, 2], [1, 2, 3, 4, 5]);
+      const arr2: Array<string> = without(['a'])(['a', 'b', 'c']);
+    });
+    it('should fail when first list does not match second list type', () => {
+      // $FlowExpectedError
+      const arr1: Array<number> = without(['1', '2'], [1, 2, 3, 4, 5]);
+      // $FlowExpectedError
+      const arr2: Array<string> = without([1])(['a', 'b', 'c']);
+    });
+    it('should work with readonly array', () => {
+      const list1: $ReadOnlyArray<number|string> =  [1, 'four', 5];
+      const list2: $ReadOnlyArray<number|string> =  [1, 'two', 3, 'four', 5];
+      const arr1: Array<number|string> = without(list1, list2);
+      const arr2: Array<number|string> = without(list1)(list2);
+    });
+    it('should list1 be a subset of list2', () => {
+      const list1: $ReadOnlyArray<number> =  [1, 3, 5];
+      const list2: $ReadOnlyArray<number|string> =  [1, 'four', 5];
+      const arr1: Array<number|string> = without(list1, list2);
+      // $FlowExpectedError
+      const arr2: Array<number> = without(list2, list1);
+    });
+  });
+
+  const xprodxs: Array<[number, string]> = _.xprod([1, 2], ["a", "b", "c"]);
+  const xprodxs1: Array<[boolean, string]> = _.xprod([true, false])(["a", "b"]);
+
+  const zipxs: Array<[number, string]> = _.zip([1, 2, 3], ["a", "b", "c"]);
+
+  //$FlowExpectedError
+  const zipxs1: Array<[number, string]> = _.zip([true, false])(["a", "b"]);
+
+  const zipos: { [k: string]: number, ... } = _.zipObj(["a", "b", "c"], [1, 2, 3]);
+
+  const ys9: { [k: string]: number, ... } = _.zipObj(["me", "you"], [1, 2]);
+  const zipped: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3],
+    ["1", "2", "3"]
+  );
+  const zipped2: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3]
+  )(["1", "2", "3"]);
+  const zipped3: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith((a, b) => ({
+    s: a,
+    y: b
+  }))([1, 2, 3])(["1", "2", "3"]);
+
+  describe('chain', () => {
+    it('should accept read only list as input', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const duplicate = n => [n, n];
+      const result1: Array<string> = chain(duplicate, arr);
+      const result2: Array<string> = chain(duplicate)(arr);
+    });
+
+    it('should fail when input out type mismatch', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const castType = n => (parseInt(n): number);
+      //$FlowExpectedError
+      const result: Array<string> = chain(castType, arr);
+    });
+
+    it('should take second argument as function', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const result: Array<?string> = chain(append, x => x[x.length - 1])(arr)
+    });
+
+    it('should error out when second arugment is function but type mismatches', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const castType = n => (parseInt(n): number);
+      //$FlowExpectedError
+      const result: Array<string> = chain(append, castType)(arr)
+    });
+  });
+              
+  describe('nth', () => {
+    it('should get a maybe type back on input is an array of given types', () => {
+      const nthxs1: ?number = nth(2, [1,2,3]);
+      const nthxs2: ?number = nth(2)([1,2]);
+      const nthxs3: ?number = nth(3)([1,2]);
+      const nthxs4: ?string = nth(2, ["curry"]);
+      const nthxs5: ?string = nth(2)(["curry", "bean"]);
+      const nthxs6: ?string = nth(3)(['foo', 'bar']);
+    });
+
+    it('should get a string back when input is string', () => {
+      const nthxs: string = nth(2)("curry");
+      const nthxs1: string = nth(2, "curry");
+    });
+
+    it('should take read only array as second argument', () => {
+      const readOnlyArray: $ReadOnlyArray<number>  = [1, 2, 3];
+      const nthxs = nth(2)(readOnlyArray)
+      const nthxs1 = nth(2, readOnlyArray)
+    });
+
+    it('should take a mutable array as second arugment', () => {
+      const array: Array<string> = ['foo', 'bar'];
+      const nthxs = nth(1)(array)
+      const nthxs1 = nth(1, array)
+      const nthxs2 = nth(1)(array)
+    });
+
+    it('should take tuple as second argument', () => {
+      const tuple:[number, boolean] = [1, true]
+      const n = nth(0, tuple)
+      const ns = nth(1)(tuple)
+    });
+
+    it('should fail on expecting return type to be a maybe type of the element of the input list', () => {
+      const arr: Array<number> = [1, 2, 3]
+      //$FlowExpectedError
+      const nthxs: ?string = nth(2)(arr);
+      //$FlowExpectedError
+      const nthxs1: ?boolean = nth(1)(arr);
+    });
+
+    it('should fail on expecting return type to mismatch the input array type', () => {
+      const arr: Array<number> = [1, 2, 3]
+      //$FlowExpectedError
+      const nthxs: string = nth(2, arr);
+      //$FlowExpectedError
+      const nthxs1: string = nth(2)(arr);
+      //$FlowExpectedError
+      const nthxs2: string = nth(1, ['foo'])
+      //$FlowExpectedError
+      const nthxs3: number = nth(1, arr);
+      //$FlowExpectedError
+      const nthxs4: number = nth(1)(arr);
+      //$FlowExpectedError
+      const nthxs5: number = nth(1, [1])
+      //$FlowExpectedError
+      const nthxs: ?number = nth(2)(['foo']);
+    });
+
+    it('should fail on passing a non-number to first argument', () => {
+      //$FlowExpectedError
+      const nthxs = nth('foo')(['foo', 'bar'])
+    });
+
+    it('should fail on passing a non-array to second argument', () => {
+      //$FlowExpectedError
+      const nthxs = nth(2)({}) 
+    });
+  });
+              
+  describe('adjust', () => {
+    it('should allow both Array and $ReadOnlyArray output', () => {
+      const arr: Array<number> = [1, 2, 3]
+      const ro: $ReadOnlyArray<number> = [1, 2, 3]
+      const result: $ReadOnlyArray<number> = adjust(1, x => x + 1, arr)
+      const result1: Array<number> = adjust(1, x => x + 1, arr)
+      const result2: $ReadOnlyArray<number> = adjust(1, x => x + 1, ro)
+      const result3: Array<number> = adjust(1, x => x + 1, ro)
+    });
+  });
+
+  describe('uniq', () => {
+    it('should accept read only array', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      const result:$ReadOnlyArray<number> = uniq(readOnlyNumbers);
+    });
+
+    it('should fail when element type mismatches', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      //$FlowExpectedError
+      const result:$ReadOnlyArray<string> = uniq(readOnlyNumbers);
+
+      const mix = ['1', 2, true];
+      //$FlowExpectedError
+      const result: $ReadOnlyArray<string> = uniq(mix);
+    });
+
+    it('should accept read only array when expecting mutable array as output', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      const result: Array<number> = uniq(readOnlyNumbers);
+    });
+
+    it('should accept mutable array as input and read only array as output', () => {
+      const readOnlyStrings: Array<string> = ['foo', 'bar'];
+      const result1: $ReadOnlyArray<string> = uniq(readOnlyStrings)
+    });
+
+    it('should accept mutable array', () => {
+      const arr: Array<string> = ['1', '2', '3'];
+      const result: Array<string> = uniq(arr);
+    });
+
+    it('should accept a mixed element type array', () => {
+      const arr: Array<string|number|boolean> = ['foo', 1, false]
+      const result: Array<string|number|boolean> = uniq(arr)
+    });
+
+    //Reason not to test the other way around, namely, Array<A> to $ReadOnlyArray<A> is because
+    //$ReadOnlyArray is a supertype of Array https://flow.org/en/docs/types/arrays/#toc-readonlyarray
+  })
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_logic.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_logic.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_logic.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_logic.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_map.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_map.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_map.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_map.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_math.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_math.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_math.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_math.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_misc.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_misc.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_misc.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_misc.js
diff --git a/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_object.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_object.js
new file mode 100644
index 0000000000..079edf4502
--- /dev/null
+++ b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_object.js
@@ -0,0 +1,653 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { describe, it } from 'flow-typed-test';
+import _, {
+  compose,
+  curry,
+  filter,
+  find,
+  lens,
+  lensProp,
+  lensPath,
+  lensIndex,
+  pipe,
+  over,
+  repeat,
+  set,
+  values,
+  view,
+  zipWith,
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+describe("Object", () => {
+  describe("assoc", () => {
+    it("should return more exact type when passed key hasn't in passed object", () => {
+      (_.assoc("c", "s", { a: 1, b: 2 }): {
+        a: number,
+        b: number,
+        c: string,
+        ...
+      });
+
+      (_.assoc("x", { x1: 11 }, { y: ["y1"] }): {
+        x: { [string]: number, ... },
+        y: Array<string>,
+        ...
+      });
+    });
+
+    it("should return sum types when passed key already has in passed object", () => {
+      (_.assoc("a", "s", { a: 1, b: 2 }): {
+        a: number | string,
+        b: number | string,
+        ...
+      });
+    });
+  });
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's over works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with over because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('over', () => {
+    it('works with lens', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: typeof data = over(l, x => -x, data)
+    })
+
+    it('works with lensIndex', () => {
+      const xs: Array<number> = [1, 2, 3]
+      const result: Array<number> = over(lensIndex(0), x => x + 1, xs)
+    })
+
+    it('works with lensProp', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = over(lensProp('c'), () => true, data)
+    })
+
+    it('works with lensPath', () => {
+      const data = {
+        a: 'foo',
+        b: {
+          d: 4,
+          e: ['h'],
+        },
+        c: true,
+      }
+
+      const result: typeof data = over(lensPath(['b', 'd']), () => 56, data)
+    })
+
+    it('works with lensPath down to level 5', () => {
+      type NestedData = { a: { b: { c: { d: { e: string, ... }, ... }, ... }, ... }, ... };
+      const nestedData: NestedData = {
+        a: {
+          b: {
+            c: {
+              d: {
+                e: 'bar',
+              }
+            }
+          }
+        }
+      }
+
+      const result: NestedData = over(lensPath(['a', 'b', 'c', 'd', 'e']), () => 56, nestedData)
+    })
+
+    it('produces an output type that results from the mapping function and input (object)', () => {
+      type TransformedData = { a: number, ... }
+      const data = {
+        a: 'foo',
+      }
+
+      const result: TransformedData = over(lensProp('a'), s => 0, data)
+    })
+
+    it('requires the lens works with the functor provided (object)', () => {
+      type Data = { a: string, ... }
+      const data: Data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result = over(lensProp('b'), s => s.toUpperCase(), data)
+    })
+
+    it('requires the mapping function provides the correct type (object)', () => {
+      const data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result = over(lensProp('a'), (s: number) => s + 1, data)
+    })
+
+    it('requires the mapping function provides the correct type (non-object)', () => {
+      const xs: Array<number> = [1, 2, 3]
+      // $FlowExpectedError
+      const result: Array<number> = over(lensIndex(0), (x: string) => x.toUpperCase(), xs)
+    })
+
+    it('should be curried', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = over(lensProp('c'), () => true, data)
+      const result1: typeof data = over(lensProp('c'))(() => true, data)
+      const result2: typeof data = over(lensProp('c'))(() => true)(data)
+      const result3: typeof data = over(lensProp('c'))(() => true, data)
+    });
+  })
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's set works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with set because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('set', () => {
+    it('works with lens', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: typeof data = set(l, 3, data)
+    })
+
+    it('works with lensIndex', () => {
+      const xs: Array<string> = ['a', 'b', 'c']
+      const result: Array<string> = set(lensIndex(0), 'd', xs)
+    })
+
+    it('works with lensProp', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = set(lensProp('c'), true, data)
+    })
+
+    // This scenario doesn't work in the present form.
+    it('produces an output type that results from the mapping function and input (functor)', () => {
+      const data: [number] = [0]
+      // $FlowExpectedError
+      const result: [string] = over(lensIndex(0), 'foo', data)
+    })
+
+    it('requires the lens works with the functor provided (object)', () => {
+      type Data = { a: string, ... }
+      const data: Data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result: Data = set(lensProp('b'), 'FOO', data)
+    })
+  })
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's view works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with view because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('view', () => {
+    it('works with lens', () => {
+      type Data = {
+        a: string,
+        b: number,
+        c: boolean,
+        ...
+      }
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: Data = set(l, 3, data)
+    })
+
+    it('works with lensIndex', () => {
+      type Data = { a: string, ... }
+      const xs: Array<number> = [1, 2, 3]
+      const result: number = view(lensIndex(0), xs)
+    })
+
+    it('works with lensProp', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      const result: string = view(lensProp('a'), data)
+    })
+
+    it('fails when the lensProp refers to a non-existent field', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      // $FlowExpectedError
+      const result: string = view(lensProp('b'), data)
+    })
+
+    it('produces the correct result type', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      // $FlowExpectedError
+      const result: number = view(lensProp('a'), data)
+    })
+  })
+});
+
+const apath: { [k: string]: number | string | Object, ... } = _.assocPath(
+  ["a", 0, "c"],
+  "s",
+  { a: [ { c: 0 } ] }
+);
+
+const tomato = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 },
+  id: 123
+};
+const tomato1 = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 }
+};
+
+// TODO: Started failing in v31...
+// const transformations = {
+//   firstName: _.trim,
+//   lastName: _.trim,
+//   data: {
+//     elapsed: _.add(1),
+//     remaining: _.add(-1),
+//   },
+// }
+// const evolved:{firstName: string, data: {elapsed: number, remaining: number}, id: number} = _.evolve(transformations, tomato)
+
+const objects = [{}, {}, {}];
+const objectsClone: Array<Object> = _.clone(objects);
+const objectsClone1: number = _.clone(1);
+const objectsClone2: typeof tomato = _.clone(tomato);
+//$FlowExpectedError
+const objectsClone3: $Shape<typeof tomato1> = _.clone(tomato);
+const objectsClone4: $Shape<typeof tomato1> = _.clone(tomato1);
+
+const id = objectsClone2.id;
+//$FlowExpectedError
+const idE = objectsClone4.id;
+
+const dissocd: { a: number, ... } = _.dissoc("b", { a: 1, b: 2 });
+const dissocd2: { a: number, ... } = _.dissoc("b")({ a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd3: { a: string, ... } = _.dissoc("b", { a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd4: { a: string, ... } = _.dissoc("b")({ a: 1, b: 2 });
+
+const dissocPathd: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+const dissocPathd2: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+const dissocPathd3: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c", 0])({
+  a: { b: 1, c: [2] }
+});
+//$FlowExpectedError
+const dissocPathd4: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+//$FlowExpectedError
+const dissocPathd5: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+
+
+const o1 = { a: 1, b: 2, c: 3, d: 4 };
+const o2 = { a: 10, b: 20, c: 3, d: 40 };
+
+const ep: boolean = _.eqProps("a", o1, o2);
+
+// curried versions
+const epCurr: boolean = _.eqProps("a")(o1, o2);
+const ep2: boolean = _.eqProps("c", o1)(o2);
+
+const evolved1 = _.evolve(
+  {
+    foo: x => x + 1,
+    bar: x => x + 2
+  },
+  {
+    foo: 1,
+    bar: 2
+  }
+);
+const evolved2 = _.evolve({
+  foo: x => x + 1,
+  bar: x => x + 2
+})({
+  foo: 1,
+  bar: 2
+});
+const evolved3 = _.evolve(
+  {
+    foo: x => x + 1
+  },
+  {
+    bar: 1
+  }
+);
+const evolved4 = _.evolve({
+  foo: x => x + 1
+})({
+  bar: 1
+});
+//$FlowExpectedError
+const evolved5: number = evolved4.foo;
+//$FlowExpectedError
+const evolved6 = _.evolve(["foo"]);
+
+const has: boolean = _.has("id", tomato);
+const has2: boolean = _.has("id")(tomato);
+
+const hasPath1: boolean = _.hasPath(['a', 'b'], {a: {b: 2}});
+const hasPath2: boolean = _.hasPath(['a', 0, 'c'])({a: [{c: 2}]});
+
+function Rectangle(width, height) {
+  this.width = width;
+  this.height = height;
+}
+Rectangle.prototype.area = function() {
+  return this.width * this.height;
+};
+
+const square = new Rectangle(2, 2);
+const hasIn: boolean = _.hasIn("width", square);
+const hasIn1: boolean = _.hasIn("area", square);
+
+const raceResultsByFirstName = {
+  first: "alice",
+  second: "jake",
+  third: "alice"
+};
+const inverted: { [k: string]: Array<string>, ... } = _.invert(
+  raceResultsByFirstName
+);
+const inverted1: { [k: string]: string, ... } = _.invertObj(raceResultsByFirstName);
+
+const ks: Array<string> = _.keys(raceResultsByFirstName);
+const ksMaybe: Array<string> = _.keys(null)
+const ksi: Array<string> = _.keysIn(square);
+
+const xs = { x: 1, y: 2, z: 3 };
+const prependKeyAndDouble = (num, key, obj) => key + num * 2;
+
+const obI: { [k: string]: string, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+//$FlowExpectedError
+const obI2: { [k: string]: number, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+
+const ob1 = { a: 1 };
+const ob2 = { b: 3 };
+const ob3 = _.merge(ob1, ob2);
+//$FlowExpectedError
+const propX = ob3.x;
+const propA = ob3.a;
+
+type User = {
+  name: string,
+  age: number,
+  ...
+}
+const mLeft: User = _.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
+const mLeftName: string = mLeft.name;
+const mLeftAge: number = mLeft.age;
+type Point = {
+  x: number,
+  y: number,
+  ...
+}
+const mLeft2: Point = _.mergeLeft({x: 0})({x: 5, y: 2});
+const mLeftX: number = mLeft2.x;
+const mLeftY: number = mLeft2.y;
+
+const mRight: User = _.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
+const mRightName: string = mRight.name;
+// $FlowExpectedError
+const mRightAge: number = mRight.name;
+const mRight2: Point = _.mergeRight({x: 0, y: 0})({y: 2});
+const mRightX: number = mRight2.x;
+const mRightY: number = mRight2.y;
+
+const mwith = _.mergeWith(
+  (a, b) => Array.isArray(a) && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB: boolean = mwith.b;
+
+const mwithK = _.mergeWithKey(
+  (k, a, b) => Array.isArray(a) && k === "d" && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB1: boolean = mwithK.b;
+
+const mDwith = _.mergeDeepWith(
+  _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propmDwithB: boolean = mDwith.b;
+
+const concatValues = (k, l, r) => k == 'values' ? _.concat(l, r) : r
+const mDwithKey = _.mergeDeepWithKey(
+  concatValues,
+  { a: true, c: { thing: 'foo', values: [10, 20] }},
+  { b: true, c: { thing: 'bar', values: [15, 35] }}
+);
+const propmDwithKeyB: boolean = mDwithKey.b;
+
+const mDLeft = _.mergeDeepLeft(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB2: boolean = mDLeft.a;
+const propB3: boolean = mDLeft.b;
+const propB4: 10 = mDLeft.values[0];
+
+const mDRight = _.mergeDeepRight(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB5: boolean = mDRight.a;
+const propB6: boolean = mDRight.b;
+const propB7: 15 = mDRight.values[0];
+
+const objA = _.objOf("a", false);
+//$FlowExpectedError
+const propAA: number = objA.a;
+
+const om: Object = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4 });
+const omap1 = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4, h: 7 });
+const omap2 = _.omit(["a", "d", "h"])({ a: 1, b: 2, c: 3, d: 4 });
+
+const path1: Object | number = _.path(["a", "b"], { a: { b: 2 } });
+const path2: Object | number = _.path(["a", 1], { a: { "1": 2 } });
+const path3: ?Object = _.path(["a", "b"], { c: { b: 2 } });
+const path4: void = _.path(["a"], null);
+
+const pathOr: string | Object | number = _.pathOr("N/A", ["a", "b", 0], {
+  a: { b: [2] }
+});
+
+describe('pick', () => {
+  it('should works', () => {
+    const pck = _.pick(["a", "d"], { a: 1, b: 2, c: 3, d: '4' });
+    const a: number = pck.a;
+    const d: string = pck.d;
+
+    //$FlowExpectedError
+    const e = pck.e;
+  });
+  it('should fail with not existing props', () => {
+    //$FlowExpectedError
+    const pck = _.pick(["b", "r"], { a: 1, b: 2, c: 3, d: '4' });
+  });
+});
+
+
+const ooo = { a: 1, b: 2, A: 3, B: 4 };
+const isUpperCase = (val, key) => key.toUpperCase() === key;
+const pb: Object = _.pickBy(isUpperCase, ooo);
+
+const ppp: number = _.prop("x", { x: 100 });
+//$FlowExpectedError
+const ppp1: number = _.prop("y", { x: 100 });
+const ppp2: number = _.prop("x")({ x: 100 });
+//$FlowExpectedError
+const ppp3: string = _.prop("x", { x: 100 });
+const ppp4: number = _.prop(_.__, { x: 100 })("x");
+//$FlowExpectedError
+const ppp5: number = _.prop(_.__, { x: 100 })("y");
+const ppp6: number = _.prop("x", ({ x: 1, y: "a" }: {
+  x: number,
+  y: string,
+  ...
+}));
+const ppp7: number = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+//$FlowExpectedError
+const ppp8: string = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+
+const alice = {
+  name: "ALICE",
+  age: 101
+};
+
+const favoriteWithDefault = _.propOr("Ramda", "favoriteLibrary");
+const fav = favoriteWithDefault(alice);
+
+const nameWithDefault = _.propOr("Ramda", "name");
+const nm: number | string = nameWithDefault(alice);
+
+const pss1: Array<number | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+const pss2: Array<number | boolean> = _.props(
+  ["x", "y"],
+  ({ x: true, y: 2, z: "foo" }: {
+  x: boolean,
+  y: number,
+  ...
+})
+);
+const pss3: Array<number> = _.props(["y"], { x: true, y: 2, z: "foo" });
+const pss4: Array<number> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+//$FlowExpectedError -- wrong key
+const pssE1: Array<number | boolean> = _.props(["d", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type
+const pssE2: Array<string | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type on indexer value
+const pssE3: Array<string> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+
+const top: Array<["a" | "b" | "c", number]> = _.toPairs({ a: 1, b: 2, c: 3 });
+
+//$FlowExpectedError
+const topE: Array<["a" | "b" | "c" | "z", number]> = _.toPairs({
+  a: 1,
+  b: 2,
+  c: 3
+});
+
+const F = function() {
+  this.x = "X";
+};
+F.prototype.y = "Y";
+const f = new F();
+const topin = _.toPairsIn(f);
+
+describe('values', () => {
+  it('provides a union per element when the types of all values vary', () => {
+    const val = values({ a: 1, b: 2, c: true });
+    const val1: number | boolean = val[0];
+  })
+
+  it('works with the example in the docs http://ramdajs.com/docs/#values', () => {
+    const vs: Array<number> = values({a: 1, b: 2, c: 3})
+  })
+})
+
+const pred = _.where({
+  a: (a: string) => a === "foo",
+  b: _.complement(_.equals("bar")),
+  c: (c: Object) => !!c,
+  x: _.gt(10),
+  y: _.lt(20),
+});
+
+const w: boolean = pred({ a: "foo", b: "xxx", c: {}, x: 11, y: 19 });
+
+const pred1 = _.whereEq({ a: 1, b: 2 });
+
+const win: boolean = pred1({ a: 1, d: 1 });
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_partial.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_partial.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_partial.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_partial.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_pipe.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_pipe.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_pipe.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_pipe.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_relation.js b/definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_relation.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_relation.js
rename to definitions/npm/ramda_v0.26.x/flow_v0.201.x-/test_ramda_v0.26.x_relation.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/ramda_v0.27.x.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/ramda_v0.27.x.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/ramda_v0.27.x.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/ramda_v0.27.x.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_cjs_modules.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_cjs_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_cjs_modules.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_cjs_modules.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_compose.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_compose.js
new file mode 100644
index 0000000000..e2d39f1915
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_compose.js
@@ -0,0 +1,31 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { compose } from 'ramda';
+
+const f1 = (a: number): number => 1;
+
+describe("compose()", () => {
+  describe('call "compose" with different number of arguments', () => {
+    it('rises an error when more then 10 arguments', () => {
+      // $FlowExpectedError - compose can't take more than 10 arguments
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when 10 arguments are provided', () => {
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when less than 10 arguments are provided', () => {
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when 1 argument is provided', () => {
+      compose(f1)(1);
+    });
+
+    it('raises and error when no argument is provided', () => {
+      // $FlowExpectedError - compose needs at least one argument
+      compose()(1);
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_es_modules.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_es_modules.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_es_modules.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_es_modules.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_filter.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_filter.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_filter.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_filter.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_functions.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_functions.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_functions.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_functions.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_list.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_list.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_list.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_list.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_logic.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_logic.js
new file mode 100644
index 0000000000..e909102721
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_logic.js
@@ -0,0 +1,319 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { describe, it } from 'flow-typed-test';
+import _, {
+  complement,
+  compose,
+  curry,
+  filter,
+  find,
+  ifElse,
+  pipe,
+  repeat,
+  zipWith,
+} from 'ramda';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ['one', 'two', 'three', 'four'];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: 'd' };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: 'd' }, { b: 2 }];
+const str: string = 'hello world';
+
+//Logic
+// TODO: Fix flow issues
+// const isQueen = _.propEq("rank", "Q");
+// const isSpade = _.propEq("suit", "♠︎");
+// const isQueenOfSpades = _.allPass([isQueen, isSpade]);
+
+//$FlowExpectedError
+const allp: boolean = isQueenOfSpades(1);
+const allp1: boolean = isQueenOfSpades({ rank: 'Q', suit: '♣︎' });
+
+const a: boolean = _.and(true, true);
+const a_: (a: boolean) => boolean = _.and(true);
+
+const nonBooleanAnd: number = _.and(69, 42);
+const nonBooleanAnd_: (nonBooleanAnd: number) => any = _.and(69);
+
+const gte = _.anyPass([_.gt, _.equals]);
+const ge: boolean = gte(3, 2);
+
+//$FlowExpectedError
+const gt10 = x => x > 10;
+//$FlowExpectedError
+const even = x => x % 2 === 0;
+const f = _.both(gt10, even);
+
+const b: boolean = f('');
+const b_: boolean = f(100);
+
+const fn = _.cond([
+  [_.equals(0), _.always('water freezes at 0°C')],
+  [_.equals(100), _.always(1)],
+  [_.T, temp => 'nothing special happens at ' + temp + '°C'],
+]);
+const cond_: number | string = fn(0);
+
+// This is abit awkward — if a non-null value of type
+// differrent to number is passed flow will infer a union type
+// for all of them
+const defaultTo42 = _.defaultTo(42);
+const def: number = defaultTo42(null);
+const def1: number = defaultTo42(undefined);
+
+const feither = _.either(gt10, even);
+const feitherR: boolean = f(101);
+
+describe('complement', () => {
+  it('accepts a function that returns a boolean', () => {
+    complement(() => true)
+    complement(() => false)
+    // $FlowExpectedError
+    complement(() => 'foo')
+    // $FlowExpectedError
+    complement(() => 5)
+    // $FlowExpectedError
+    complement(() => [])
+    // $FlowExpectedError
+    complement(() => ({}))
+    // $FlowExpectedError
+    complement(() => null)
+    // $FlowExpectedError
+    complement(() => undefined)
+  })
+
+  it('returns a function that returns a boolean', () => {
+    const fn = complement(() => true)
+    const b: boolean = fn()
+    // $FlowExpectedError
+    const s: string = fn()
+    // $FlowExpectedError
+    const n: number = fn()
+    // $FlowExpectedError
+    const xs: Array<mixed> = fn()
+    // $FlowExpectedError
+    const obj: {[string]: mixed} = fn()
+    // $FlowExpectedError
+    const v: void = fn()
+    // $FlowExpectedError
+    const nil: null = fn()
+  })
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement test cases.
+  it('returns a function whose parameters match the input function (0)', () => {
+    const fn = complement(() => true)
+    fn()
+    // Extra arguments are discarded, so there is no negative case here.
+  })
+
+  it('returns a function whose parameters match the input function (1)', () => {
+    const fn = complement((a: 'a',) => true)
+    fn('a',)
+    // $FlowExpectedError
+    fn(0)
+  })
+
+  it('returns a function whose parameters match the input function (2)', () => {
+    const fn = complement((a: 'a', b: 'b',) => true)
+    fn('a', 'b',)
+    // $FlowExpectedError
+    fn(0, 1)
+  })
+
+  it('returns a function whose parameters match the input function (3)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c',) => true)
+    fn('a', 'b', 'c',)
+    // $FlowExpectedError
+    fn(0, 1, 2)
+  })
+
+  it('returns a function whose parameters match the input function (4)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd',) => true)
+    fn('a', 'b', 'c', 'd',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3)
+  })
+
+  it('returns a function whose parameters match the input function (5)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e',) => true)
+    fn('a', 'b', 'c', 'd', 'e',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4)
+  })
+
+  it('returns a function whose parameters match the input function (6)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5)
+  })
+
+  it('returns a function whose parameters match the input function (7)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6)
+  })
+
+  it('returns a function whose parameters match the input function (8)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7)
+  })
+
+  it('returns a function whose parameters match the input function (9)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8)
+  })
+
+  it('returns a function whose parameters match the input function (10)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i', j: 'j',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+  })
+
+  // End generated complement test cases.
+})
+
+
+describe('ifElse', () => {
+  it('uses a union of both branches as the return type', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    const ie: number | string = incCount(1);
+  })
+
+  it('checks the condition input matches the branch inputs', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    // Because the object literal ({}) isn't a number it
+    // $FlowExpectedError
+    const ie: number | string = incCount({});
+  })
+
+  it('works with variadic arg inputs', () => {
+    const ifElseFn = ifElse(
+      // Without this test, variadic argument input functions will produce an
+      // error like this:
+      //
+      // Cannot call `ifElse` because rest array [1] has an unknown number of
+      // elements, so is incompatible with tuple type [2].
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    const result: void | string = ifElseFn('input')
+  })
+
+  it('preserves the types used with variadic argument condition functions', () => {
+    const ifElseFn = ifElse(
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    // $FlowExpectedError
+    const result: void | string = ifElseFn(5)
+  })
+
+  // This was the original test for ifElse, which depends on the implementation
+  // of "is". "is" in its present form does not perform type refinement, so the
+  // stricter form of ifElse fails the check with this test. This test below
+  // captures the issue, and is left for reference and/or if some brave soul
+  // wishes to expand the definition of ifElse (and possibly also "is") to
+  // refine the predicate correctly. At time of writing, $Pred and $Refine are
+  // considered experimental/internal and abandoned:
+  // https://github.com/facebook/flow/issues/2464#issuecomment-471115953
+  //
+  // it('feeds a predicate-refined type to the branches', () => {
+  //   const incCount = ifElse(is(Number), x => x + 1, x => x.toString());
+  //   const ie: number | string = incCount(1);
+  // })
+})
+
+const em: boolean = _.isEmpty([1, 2, 3]);
+
+const n: boolean = _.not(true);
+//$FlowExpectedError
+const n1: boolean = _.not(1);
+
+const oor: boolean = _.or(true, true);
+
+const nonBooleanOr: ?string = _.or('watskeburt', undefined);
+const nonBooleanOr_: (arg: { key: string, ... }) => string | { key: string, ... } = _.or(
+  'watskeburt'
+);
+
+// type refinement is important here
+// which might be awkward for some
+// but can actually catch some bugs statically
+
+const psatE: boolean = _.pathSatisfies(y => y > 0, ['x', 'y', 0], {
+  x: { y: [2] },
+});
+const psat: boolean = _.pathSatisfies(
+  y => typeof y === 'number' && y > 0,
+  ['x', 'y', 0],
+  { x: { y: [2] } }
+);
+const psatPart = _.pathSatisfies(y => typeof y === 'number' && y > 0);
+const psat2: boolean = psatPart(['x', 'y', 0])({ x: { y: 2 }, z: true });
+const psatPart2 = _.pathSatisfies(y => typeof y === 'number' && y > 0, [
+  'x',
+  'y',
+  0,
+]);
+const psat3: boolean = psatPart2({ x: { y: 2 }, z: true });
+
+describe('propSatisfies', () => {
+  describe('with object', () => {
+    it('should works with object', () => {
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'x', { x: 1, y: 2 });
+    });
+    it('should works with object with properties of different types', () => {
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'x', { x: 1, y: 2, str: 'different type' });
+      // same again but this time using a curried function
+      const propSatCurry: boolean = _.propSatisfies((x: number) => x > 0, 'x')({ x: 1, y: 2, str: 'different type' });
+    });
+    it('should error when property does not exist', () => {
+      //$FlowExpectedError
+      const propSat3: boolean = _.propSatisfies((x: number) => x > 0, 'z', { x: 1, y: 2 });
+    });
+    it('should error when condition param does not match property type', () => {
+      //$FlowExpectedError
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'str', { x: 1, y: 2, str: 'different type' });
+      //$FlowExpectedError
+      const propSatCurry: boolean = _.propSatisfies((x: number) => x > 0, 'str')({ x: 1, y: 2, str: 'different type' });
+    });
+  });
+  describe('with object as maps', () => {
+    const o: { [string]: number, ... } = { x: 1, y: 2 };
+    it('should works with object map', () => {
+      const propSat: boolean = _.propSatisfies((x: number) => x > 0, 'x', o);
+    });
+    it('should error when condition param does not match property type', () => {
+      //$FlowExpectedError
+      const propSat2: boolean = _.propSatisfies((x: string) => x > 0, 'x', o);
+    });
+  });
+});
+
+const coerceArray = _.unless(_.is(Array), _.of);
+const coer: Array<number | Array<number>> | number = coerceArray([1, 2, 3]);
+const coer1: Array<number | Array<number>> | number = coerceArray(1);
+
+const coerceString = _.unless(_.is(String), _.toString);
+const coer2: string | Array<number> = coerceString([1, 2, 3]);
+const coer3: string | Array<number> = coerceString('s');
+
+const unlPrt = _.unless(_.is(Number), _.T);
+const unl: number | boolean | Array<number> = unlPrt([1, 2, 3]);
+const unl2: number | boolean | Array<number> = unlPrt(1);
+
+const un: number = _.until(_.gt(100), _.multiply(2))(1);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_map.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_map.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_map.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_map.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_math.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_math.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_math.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_math.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_misc.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_misc.js
new file mode 100644
index 0000000000..f87706e3bd
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_misc.js
@@ -0,0 +1,81 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  compose,
+  pipe,
+  curry,
+  filter,
+  find,
+  isNil,
+  repeat,
+  replace,
+  zipWith
+} from "ramda";
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// Math
+{
+  const partDiv: (a: number) => number = _.divide(6);
+  const div: number = _.divide(6, 2);
+  //$FlowExpectedError
+  const div2: number = _.divide(6, true);
+}
+
+// String
+{
+  const ss: Array<string | void> = _.match(/h/, "b");
+  describe('replace', () => {
+    it('should supports replace by string', () => {
+      const r1: string = replace(",", "|", "b,d,d");
+      const r2: string = replace(",")("|", "b,d,d");
+      const r3: string = replace(",")("|")("b,d,d");
+      const r4: string = replace(",", "|")("b,d,d");
+    });
+    it('should supports replace by RegExp', () => {
+      const r1: string = replace(/[,]/, "|", "b,d,d");
+      const r2: string = replace(/[,]/)("|", "b,d,d");
+      const r3: string = replace(/[,]/)("|")("b,d,d");
+      const r4: string = replace(/[,]/, "|")("b,d,d");
+    });
+    it('should supports replace by RegExp with replacement fn', () => {
+      const fn = (match: string, g1: string): string => g1;
+      const r1: string = replace(/([,])d/, fn, "b,d,d");
+      const r2: string = replace(/([,])d/)(fn, "b,d,d");
+      const r3: string = replace(/([,])d/)(fn)("b,d,d");
+      const r4: string = replace(/([,])d/, fn)("b,d,d");
+    });
+  });
+  const ss2: Array<string> = _.split(",", "b,d,d");
+  const ss1: boolean = _.test(/h/, "b");
+  const s: string = _.trim("s");
+  const x: string = _.head("one");
+  const sss: string = _.concat("H", "E");
+  const sss1: string = _.concat("H")("E");
+  const ssss: string = _.drop(1, "EF");
+  const ssss1: string = _.drop(1)("E");
+  const ssss2: string = _.dropLast(1, "EF");
+  const ys: string = _.nth(2, "curry");
+  const ys1: string = _.nth(2)("curry");
+}
+//Type
+{
+  const x: boolean = _.is(Number, 1);
+  const x1: boolean = isNil(1);
+
+  // should refine type
+  const x1a: ?{ a: number, ... } = { a: 1 };
+  //$FlowExpectedError
+  x1a.a;
+  if (!isNil(x1a)) {
+    x1a.a;
+  }
+
+  const x2: boolean = _.propIs(1, "num", { num: 1 });
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_object.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_object.js
similarity index 100%
rename from definitions/npm/ramda_v0.27.x/flow_v0.104.x-/test_ramda_v0.27.x_object.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_object.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0..x.x_partial.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_partial.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0..x.x_partial.js
rename to definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_partial.js
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_pipe.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_pipe.js
new file mode 100644
index 0000000000..0ccac55966
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_pipe.js
@@ -0,0 +1,224 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { pipe } from "ramda";
+
+// f - function
+// a - argument
+// unf - unary function
+function f1(a1: number): number {
+  return 69;
+}
+
+function f2(a1: number, a2: string): number {
+  return 69;
+}
+
+function f3(a1: number, a2: string, a3: boolean): number {
+  return 69;
+}
+
+function f4(a1: number, a2: string, a3: boolean, a4: number): number {
+  return 69;
+}
+
+function f5(a1: number, a2: string, a3: boolean, a4: number, a5: string): number {
+  return 69;
+}
+
+function unf1(a1: number): string {
+  return "69";
+}
+
+function unf2(a1: string): boolean {
+  return false;
+}
+
+function unf3(a1: boolean): number {
+  return 69;
+}
+
+function unf4(a1: number): string {
+  return "69";
+}
+
+function unf5(a1: string): boolean {
+  return true;
+}
+
+describe("pipe(...fn)", () => {
+  describe('call "pipe" with unary function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f1, unf1, unf3, unf4, unf5)(1);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f1, unf1, unf2, unf3, unf4, unf5)(1): boolean);
+      (pipe(f1, unf1, unf2, unf3, unf4)(1): string);
+      (pipe(f1, unf1, unf2, unf3)(1): number);
+      (pipe(f1, unf1, unf2)(1): boolean);
+      (pipe(f1, unf1)(1): string);
+      (pipe(f1)(1): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f1)(1, "1", true);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f1)();
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with number
+      pipe(f1, unf1)(true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f1, unf1)(1): boolean);
+    });
+  });
+
+  describe('call "pipe" with double function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f2, unf1, unf3, unf4, unf5)(1, "2");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f2, unf1, unf2, unf3, unf4, unf5)(1, "2"): boolean);
+      (pipe(f2, unf1, unf2, unf3, unf4)(1, "2"): string);
+      (pipe(f2, unf1, unf2, unf3)(1, "2"): number);
+      (pipe(f2, unf1, unf2)(1, "2"): boolean);
+      (pipe(f2, unf1)(1, "2"): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f2)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f2)(1);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      pipe(f2, unf1)(1, true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f2, unf1)(1, "2"): boolean);
+    });
+  });
+
+  describe('call "pipe" with triple function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f3, unf1, unf3, unf4, unf5)(1, "2", true);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f3, unf1, unf2, unf3, unf4, unf5)(1, "2", true): boolean);
+      (pipe(f3, unf1, unf2, unf3, unf4)(1, "2", true): string);
+      (pipe(f3, unf1, unf2, unf3)(1, "2", true): number);
+      (pipe(f3, unf1, unf2)(1, "2", true): boolean);
+      (pipe(f3, unf1)(1, "2", true): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f3)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f3)(1, "2");
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - number is incompatible with boolean
+      pipe(f3, unf1)(1, "2", 999);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f3, unf1)(1, "2", true): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 4 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f4, unf1, unf3, unf4, unf5)(1, "2", true, 4);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f4, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1, unf2, unf3, unf4)(1, "2", true, 4): string);
+      (pipe(f4, unf1, unf2, unf3)(1, "2", true, 4): number);
+      (pipe(f4, unf1, unf2)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1)(1, "2", true, 4): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f4)(1, "2", true, 4, "5", 6, false);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f4)(1, "2", true);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - string is incompatible with number
+      pipe(f4, unf1)(1, "2", true, "new number");
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f4, unf1)(1, "2", true, 4): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 5 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f5, unf1, unf3, unf4, unf5)(1, "2", true, 4, "5");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f5, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1, unf2, unf3, unf4)(1, "2", true, 4, "5"): string);
+      (pipe(f5, unf1, unf2, unf3)(1, "2", true, 4, "5"): number);
+      (pipe(f5, unf1, unf2)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f5)(1, "2", true, 4, "5", 6, 7, 8);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f5)(1, "2", true, 4);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean is incompatible with string
+      pipe(f5, unf1)(1, "2", true, 4, false);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): boolean);
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_relation.js b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_relation.js
new file mode 100644
index 0000000000..19ccf08a1a
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.104.x-v.200.x/test_ramda_v0.27.x_relation.js
@@ -0,0 +1,334 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { it, describe } from "flow-typed-test";
+import _, {
+  ascend,
+  compose,
+  curry,
+  descend,
+  filter,
+  find,
+  gt,
+  gte,
+  intersection,
+  lt,
+  lte,
+  pipe,
+  prop,
+  repeat,
+  sort,
+  zipWith,
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const objArr: { [k: string]: mixed, ... } = { a: 1, b: [1,2,3], c: "d"};
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+const cl: number = _.clamp(1, 10, -1);
+const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
+const letters = _.split("", "abcABCaaaBBc");
+// In ramda docs example it's just `Math.floor`
+// but we don't want the implicit number -> string
+const countB = _.countBy(_.compose(_.toString, Math.floor))(numbers);
+const countB1: { [k: string]: number, ... } = _.countBy(_.toLower)(letters);
+const diff: Array<number> = _.difference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+//$FlowExpectedError
+const diff1: Array<string> = _.difference(
+  ["1", "2", "3", "4"],
+  [7, 6, 5, 4, 3]
+);
+
+const cmp = (x, y) => x.a === y.a;
+const l1 = [{ a: 1 }, { a: 2 }, { a: 3 }];
+const l2 = [{ a: 3 }, { a: 4 }];
+const diff2 = _.differenceWith(cmp, l1, l2);
+
+const eqb: boolean = _.eqBy(Math.abs, 5, -5);
+
+const es: boolean = _.equals([1, 2, 3], [1, 2, 3]);
+
+describe('ascend', () => {
+  /**
+   * In the examples for ascend, its result is plugged into sort. In order
+   * for this to function properly ascend needs to yield a function that can
+   * take two arguments.
+   */
+  it('works as an input to sort', () => {
+    const byAge = ascend(prop('age'));
+    const people = [
+      { name: 'Emma', age: 70 },
+      { name: 'Peter', age: 78 },
+      { name: 'Mikhail', age: 62 },
+    ];
+    const peopleByYoungestFirst = sort(byAge, people);
+  })
+
+  it('returns a curried function', () => {
+    const byAge = ascend(prop('age'))
+    byAge({ name: 'Emma', age: 70 })({ name: 'Peter', age: 78 })
+  })
+})
+
+describe('descend', () => {
+  /**
+   * In the examples for descend, its result is plugged into sort. In order
+   * for this to function properly descend needs to yield a function that can
+   * take two arguments.
+   */
+  it('works as an input to sort', () => {
+    const byAge = descend(prop('age'));
+    const people = [
+      { name: 'Emma', age: 70 },
+      { name: 'Peter', age: 78 },
+      { name: 'Mikhail', age: 62 },
+    ];
+    const peopleByYoungestFirst = sort(byAge, people);
+  })
+
+  it('returns a curried function', () => {
+    const byAge = descend(prop('age'))
+    byAge({ name: 'Emma', age: 70 })({ name: 'Peter', age: 78 })
+  })
+})
+
+describe('gt', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = gt(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = gt(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = gt('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = gt('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    gt('a', 1)
+    // $FlowExpectedError
+    gt(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    gt(() => 1, () => 2)
+  })
+})
+
+describe('gte', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = gte(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = gte(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = gte('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = gte('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    gte('a', 1)
+    // $FlowExpectedError
+    gte(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    gte(() => 1, () => 2)
+  })
+})
+
+describe('lt', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = lt(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = lt(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = lt('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = lt('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    lt('a', 1)
+    // $FlowExpectedError
+    lt(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    lt(() => 1, () => 2)
+  })
+})
+
+describe('lte', () => {
+  it('works with two numbers and produces a bool', () => {
+    const resulte: bool = lte(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const resulte: bool = lte(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const resulte: bool = lte('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const resulte: bool = lte('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    lte('a', 1)
+    // $FlowExpectedError
+    lte(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    lte(() => 1, () => 2)
+  })
+})
+
+const _max: number = _.max(2, 1);
+const _min: number = _.min(2, 1);
+
+const _maxBy: number = _.maxBy(Math.abs)(2, 1);
+const _minBy: number = _.minBy(Math.abs, 2, 1);
+
+const _identical: boolean = _.identical(2, 1);
+
+const _innerJoin: Array<{ [k: string]: mixed, ... }> = _.innerJoin(
+  (record, id) => record.id === id,
+  [{id: 824, name: 'Richie Furay'},
+   {id: 956, name: 'Dewey Martin'},
+   {id: 313, name: 'Bruce Palmer'},
+   {id: 456, name: 'Stephen Stills'},
+   {id: 177, name: 'Neil Young'}],
+  [177, 456, 999]
+);
+
+const pathEqObj: boolean = _.pathEq(["b", 1], 1, objArr);
+const pathEqObj2: boolean = _.pathEq(["b", 1])(1)(objArr);
+
+// It's good to test this with multiple params since $Keys<T> is a union.
+type PropEqObj = {
+  bar: number,
+  baz: string,
+  ...
+};
+const propEqObj: PropEqObj = { bar: 2, baz: "qux" };
+
+const isQueen = _.propEq("rank", "Q");
+
+const propEqResult1a: boolean = _.propEq("bar", 1, propEqObj);
+// Test curried versions.
+const propEqResult1b: boolean = _.propEq("bar")(1)(propEqObj);
+const propEqResult1c: boolean = _.propEq("bar")(1, propEqObj);
+const propEqResult1d: boolean = _.propEq("bar", 1)(propEqObj);
+
+// The type compared can be any type just like any other === comparison.
+// Also test the various arities.
+const propEqResult2a: boolean = _.propEq("bar", "always false", propEqObj);
+const propEqResult2b: boolean = _.propEq("bar")("always false")(propEqObj);
+const propEqResult2c: boolean = _.propEq("bar")("always false", propEqObj);
+const propEqResult2d: boolean = _.propEq("bar", "always false")(propEqObj);
+
+// The property name must be a property on the object supplied.
+// $FlowExpectedError
+const propEqResultError: boolean = _.propEq("missing", 1, propEqObj);
+
+// propEq must work with key value pairs.
+const propEqKvp: { [string]: mixed, ... } = { foo: 1, bar: "2", baz: 3 };
+const propEqResult3a: boolean = _.propEq("qux", "value", propEqKvp);
+const propEqResult3b: boolean = _.propEq("qux")("value")(propEqKvp);
+const propEqResult3c: boolean = _.propEq("qux")("value", propEqKvp);
+const propEqResult3d: boolean = _.propEq("qux", "value")(propEqKvp);
+
+// propEq must work with arrays.
+const propEqArray = [1, 2, 3];
+const propEqResult4a: boolean = _.propEq(1, 2, propEqArray);
+const propEqResult4b: boolean = _.propEq(1)(2)(propEqArray);
+const propEqResult4c: boolean = _.propEq(1)(2, propEqArray);
+const propEqResult4d: boolean = _.propEq(1, 2)(propEqArray);
+
+const sortByFirstItem = _.sortBy(([first]) => first);
+const pairs = [[-1, 1], [-2, 2], [-3, 3]];
+const sorted: Array<[number, number]> = sortByFirstItem(pairs);
+
+const sortWithData = [
+  {name: 'alice', age: 40},
+  {name: 'bob', age: 30},
+  {name: 'clara', age: 40}
+];
+const descAge = (l, r) => l.age < r.age ? -1 : 1;
+const ascName = (l, r) => l.name < r.name ? -1 : 1;
+_.sortWith([descAge, ascName], sortWithData);
+_.sortWith([descAge, ascName])(sortWithData);
+
+const eqA = _.eqBy(prop("a"));
+const ls1: Array<{ [k: string]: number, ... }> = [
+  { a: 1 },
+  { a: 2 },
+  { a: 3 },
+  { a: 4 }
+];
+const ls2: Array<{ [k: string]: number, ... }> = [
+  { a: 3 },
+  { b: 4 },
+  { a: 5 },
+  { a: 6 }
+];
+const symW: Array<{ [k: string]: number, ... }> = _.symmetricDifferenceWith(
+  eqA,
+  ls1,
+  ls2
+);
+const sym: Array<number> = _.symmetricDifference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+
+const un: Array<number> = _.union([1, 2, 3])([2, 3, 4]);
+const un1: Array<{ [k: string]: number, ... }> = _.unionWith(eqA, ls1, ls2);
+
+// Given $ReadOnlyArray is super type of Array, no need to test Array -> $ReadOnlyArray case
+describe('intersection', () => {
+  it('should accept read only input', () => {
+    const readOnlyArray: $ReadOnlyArray<number> = [1, 2, 3]
+    const inters1: Array<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters2: Array<number> = intersection(readOnlyArray)(readOnlyArray)
+    const inters3: $ReadOnlyArray<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters4: $ReadOnlyArray<number> = intersection(readOnlyArray)(readOnlyArray)
+  });
+
+  it('should allow mutable array in and out', () => {
+    const readOnlyArray: Array<number> = [1, 2, 3]
+    const inters1: Array<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters2: Array<number> = intersection(readOnlyArray)(readOnlyArray)
+    const inters3: $ReadOnlyArray<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters4: $ReadOnlyArray<number> = intersection(readOnlyArray)(readOnlyArray)
+  });
+})
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/ramda_v0.27.x.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/ramda_v0.27.x.js
new file mode 100644
index 0000000000..f511bf0433
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/ramda_v0.27.x.js
@@ -0,0 +1,2050 @@
+/* eslint-disable no-unused-vars, no-redeclare */
+
+type Transformer<A, B> = {
+  "@@transducer/step": <I, R>(r: A, a: any) => R,
+  "@@transducer/init": () => A,
+  "@@transducer/result": (result: any) => B,
+  ...
+};
+
+declare type $npm$ramda$Placeholder = { "@@functional/placeholder": true, ... };
+
+declare opaque type $npm$ramda$Reduced<T>;
+
+declare module ramda {
+  declare type FunctorObj<A> = { map: (<B>(A => B) => FunctorObj<B>), ... }
+  declare type FunctorFantasyLand<A> = { 'fantasy-land/map': (<B>(A => B) => FunctorFantasyLand<B>), ... }
+  declare type UnaryFn<A, R> = (a: A) => R;
+  declare type UnaryPromiseFn<A, R> = UnaryFn<A, Promise<R>>;
+  declare type BinaryFn<A, B, R> = ((a: A, b: B) => R) &
+    ((a: A) => (b: B) => R);
+  declare type UnarySameTypeFn<T> = UnaryFn<T, T>;
+  declare type BinarySameTypeFn<T> = BinaryFn<T, T, T>;
+  declare type NestedObject<T> = { [k: string]: T | NestedObject<T>, ... };
+  declare type UnaryPredicateFn<T> = (x: T) => boolean;
+  declare type MapUnaryPredicateFn = <V>(V) => V => boolean;
+  declare type BinaryPredicateFn<T> = (x: T, y: T) => boolean;
+  declare type BinaryPredicateFn2<T, S> = (x: T, y: S) => boolean;
+
+  declare interface ObjPredicate {
+    (value: mixed, key: string): boolean;
+  }
+
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = (
+    ((...r: [AA]) => CurriedFunction1<BB, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, BB]) => R)
+  );
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = (
+    ((...r: [AA]) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction2<AA, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, CC]) => R)
+  );
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction3<AA, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction2<AA, DD, R>) &
+    ((...r: [BB, $npm$ramda$Placeholder, CC]) => CurriedFunction2<BB, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction4<AA, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction3<AA, DD, EE, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction3<BB, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction2<AA, EE, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction2<BB, EE, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction2<CC, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB]) => CurriedFunction5<AA, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC]) => CurriedFunction4<AA, DD, EE, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC]) => CurriedFunction4<BB, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD]) => CurriedFunction3<AA, EE, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD]) => CurriedFunction3<BB, EE, FF, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD]) => CurriedFunction3<CC, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE]) => CurriedFunction2<AA, FF, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE]) => CurriedFunction2<BB, FF, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE]) => CurriedFunction2<CC, FF, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE]) => CurriedFunction2<DD, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [$npm$ramda$Placeholder, BB, CC, DD, EE, FF]) => CurriedFunction1<AA, R>) &
+    ((...r: [AA, $npm$ramda$Placeholder, CC, DD, EE, FF]) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB, $npm$ramda$Placeholder, DD, EE, FF]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC, $npm$ramda$Placeholder, EE, FF]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD, $npm$ramda$Placeholder, FF]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type Partial = (<A, R>((...r: [A]) => R, args: [A]) => () => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A]) => B => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A, B]) => () => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A]) => (B, C) => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B]) => C => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B, C]) => () => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A]) => (B, C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B]) => (C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B, C]) => D => R) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R,
+      args: [A, B, C, D]
+    ) => () => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A]
+    ) => (B, C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B]
+    ) => (C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C]
+    ) => (D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D]
+    ) => E => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D, E]
+    ) => () => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A]
+    ) => (B, C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B]
+    ) => (C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C]
+    ) => (D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D]
+    ) => (E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E]
+    ) => F => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E, F]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F]
+    ) => G => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => H => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => (H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => I => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H, I]
+    ) => () => R);
+
+  declare var pipe: {
+    <Args, Return, B, C, D, E, F>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C, D, E,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C, D,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B, C,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, Return>,
+    ): (...a: Args) => Return,
+    <Args, Return, B,>(
+      ab: (...a: Args) => B,
+      bc: UnaryFn<B, Return>,
+    ): (...a: Args) => Return,
+    <A, B>(ab: UnaryFn<A, B>): UnaryFn<A, B>,
+    ...
+  };
+
+  declare type Pipe = typeof pipe;
+
+  declare type PipeP = (<A, B, C, D, E, F, G>(
+    ab: UnaryPromiseFn<A, B>,
+    bc: UnaryPromiseFn<B, C>,
+    cd: UnaryPromiseFn<C, D>,
+    de: UnaryPromiseFn<D, E>,
+    ef: UnaryPromiseFn<E, F>,
+    fg: UnaryPromiseFn<F, G>,
+  ) => UnaryPromiseFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>,
+      ef: UnaryPromiseFn<E, F>,
+    ) => UnaryPromiseFn<A, F>) &
+    (<A, B, C, D, E>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>,
+    ) => UnaryPromiseFn<A, E>) &
+    (<A, B, C, D>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+    ) => UnaryPromiseFn<A, D>) &
+    (<A, B, C>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+    ) => UnaryPromiseFn<A, C>) &
+    (<A, B>(
+      ab: UnaryPromiseFn<A, B>,
+    ) => UnaryPromiseFn<A, B>);
+
+  // This kind of filter allows us to do type refinement on the result, but we
+  // still need Filter so that non-refining predicates still pass a type check.
+  declare type RefineFilter =
+    & (<K, V, P: $Pred<1>, T: Array<V> | $ReadOnlyArray<V>> (fn: P, xs: T) => Array<$Refine<V, P, 1>>)
+    & (<K, V, P: $Pred<1>, T: Array<V> | $ReadOnlyArray<V>> (fn: P) => (xs: T) => Array<$Refine<V, P, 1>>);
+
+  declare type Filter =
+    & (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>  (fn: UnaryPredicateFn<V>, xs: T) => T)
+    & (<K, V, T: { [key: K]: V, ... } | Array<V>>   (fn: UnaryPredicateFn<V>, xs: T) => T)
+
+    & (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>  (fn: UnaryPredicateFn<V>) =>(xs: T) => T)
+    & (<K, V, T: Array<V> | { [key: K]: V, ... }>   (fn: UnaryPredicateFn<V>) =>(xs: T) => T)
+
+  declare interface Monad<A> {
+    chain<B>(f: A => Monad<B>): Monad<B>;
+  }
+
+  declare class Semigroup<T> {}
+
+  declare class Chain {
+    chain<T, V: Monad<T> | $ReadOnlyArray<T>>(fn: (a: T) => V, x: V): V;
+    chain<T, V: Monad<T> | $ReadOnlyArray<T>>(fn: (a: T) => V): (x: V) => V;
+  }
+
+  declare class GenericContructor<T> {
+    constructor(x: T): GenericContructor<T>;
+  }
+
+  declare class GenericContructorMulti<T> {
+    constructor(...args: Array<T>): GenericContructor<T>;
+  }
+
+  /**
+   * DONE:
+   * Function*
+   * List*
+   * Logic
+   * Math
+   * Object*
+   * Relation
+   * String
+   * Type
+   */
+
+  declare type Compose = (<A, B, C, D, E, F, G, H, I, J, K>(
+    jk: UnaryFn<J, K>,
+    ij: UnaryFn<I, J>,
+    hi: UnaryFn<H, I>,
+    gh: UnaryFn<G, H>,
+    fg: UnaryFn<F, G>,
+    ef: UnaryFn<E, F>,
+    de: UnaryFn<D, E>,
+    cd: UnaryFn<C, D>,
+    bc: UnaryFn<B, C>,
+    ab: UnaryFn<A, B>
+  ) => UnaryFn<A, K>) &
+    (<A, B, C, D, E, F, G, H, I, J>(
+      ij: UnaryFn<I, J>,
+      hi: UnaryFn<H, I>,
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, J>) &
+    (<A, B, C, D, E, F, G, H, I>(
+      hi: UnaryFn<H, I>,
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, I>) &
+    (<A, B, C, D, E, F, G, H>(
+      gh: UnaryFn<G, H>,
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, H>) &
+    (<A, B, C, D, E, F, G>(
+      fg: UnaryFn<F, G>,
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, F>) &
+    (<A, B, C, D, E>(
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, E>) &
+    (<A, B, C, D>(
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, D>) &
+    (<A, B, C>(
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+    ) => UnaryFn<A, C>) &
+    (<A, B>(ab: UnaryFn<A, B>) => UnaryFn<A, B>);
+  declare var compose: Compose;
+
+  declare function andThen<A, R>(onSuccess: UnaryFn<A, R> | UnaryPromiseFn<A, R>): CurriedFunction1<Promise<A>, Promise<R>>
+  declare function andThen<A, R>(onSuccess: UnaryFn<A, R> | UnaryPromiseFn<A, R>, p: Promise<A>): Promise<R>;
+  declare var curry: Curry;
+  declare function curryN<A, R>(
+    length: number,
+    fn: (...args: Array<A>) => R
+  ): Function;
+
+  // *Math
+  declare var add: CurriedFunction2<number, number, number>;
+  declare var inc: UnaryFn<number, number>;
+  declare var dec: UnaryFn<number, number>;
+  declare var mean: UnaryFn<Array<number>, number>;
+  declare var divide: CurriedFunction2<number, number, number>;
+  declare var mathMod: CurriedFunction2<number, number, number>;
+  declare var median: UnaryFn<Array<number>, number>;
+  declare var modulo: CurriedFunction2<number, number, number>;
+  declare var multiply: CurriedFunction2<number, number, number>;
+  declare var negate: UnaryFn<number, number>;
+  declare var product: UnaryFn<Array<number>, number>;
+  declare var subtract:
+    & CurriedFunction2<number, number, number>
+    & CurriedFunction2<Date, Date, number>
+    & CurriedFunction2<Date, number, number>
+    & CurriedFunction2<number, Date, number>;
+  declare var sum: UnaryFn<Array<number>, number>;
+
+  // Filter
+  // To refine with filter, be sure to import the RefineFilter type, and cast
+  // filter to a RefineFilter.
+  // ex:
+  // import { type RefineFilter, filter } from 'ramda'
+  // const notNull = (x): bool %checks => x != null
+  // const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null])
+  declare var filter: RefineFilter & Filter;
+  // reject doesn't get RefineFilter since it performs the opposite work of
+  // filter, and we don't have a kind of $NotPred type.
+  declare var reject: Filter;
+
+  // *String
+  declare var match: CurriedFunction2<RegExp, string, Array<string | void>>;
+  declare type ReplacementFn = (substring: string, ...args: Array<string>) => string;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A): CurriedFunction2<B, string, string>;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A, B): CurriedFunction1<string, string>;
+  declare function replace<A: RegExp | string, B: string | ReplacementFn>(A, B, string): string;
+  declare var split: CurriedFunction2<RegExp | string, string, Array<string>>;
+  declare var test: CurriedFunction2<RegExp, string, boolean>;
+
+  declare function startsWith<A>(prefix: $ReadOnlyArray<A>): $ReadOnlyArray<A> => boolean;
+  declare function startsWith(prefix: string): string => boolean;
+  declare function startsWith<A>(prefix: $ReadOnlyArray<A>, list: $ReadOnlyArray<A>): boolean;
+  declare function startsWith(prefix: string, list: string): boolean;
+
+  declare function endsWith<A>(prefix: $ReadOnlyArray<A>): $ReadOnlyArray<A> => boolean;
+  declare function endsWith(prefix: string): string => boolean;
+  declare function endsWith<A>(prefix: $ReadOnlyArray<A>, list: $ReadOnlyArray<A>): boolean;
+  declare function endsWith(prefix: string, list: string): boolean;
+
+  declare function toLower(a: string): string;
+  declare function toString(x: mixed): string;
+  declare function toUpper(a: string): string;
+  declare function trim(a: string): string;
+
+  // *Type
+
+  declare function is<T>(t: T): mixed => boolean;
+  declare function is<T>(t: T, v: mixed): boolean;
+  declare function propIs<O>(mixed, $Keys<O>): CurriedFunction1<O, boolean>;
+  declare function propIs<O>(mixed): CurriedFunction2<$Keys<O>, O, boolean>;
+  declare function propIs<O>(mixed, $Keys<O>, O): boolean;
+  declare function type(x: mixed): string;
+
+  declare function isNil(x: mixed): boolean %checks(x === undefined || x === null);
+
+  // *List
+  declare function adjust<T>(index: number): CurriedFunction2<(a: T) => T, $ReadOnlyArray<T>, Array<T>>;
+  declare function adjust<T>(index: number, fn: (a: T) => T): CurriedFunction1<$ReadOnlyArray<T>, Array<T>>;
+  declare function adjust<T>(index: number, fn: (a: T) => T, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function all<T>(fn: UnaryPredicateFn<T>): CurriedFunction1<$ReadOnlyArray<T>, boolean>;
+  declare function all<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+
+  declare function any<T>(fn: UnaryPredicateFn<T>): CurriedFunction1<$ReadOnlyArray<T>, boolean>;
+  declare function any<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+
+  declare function aperture<T>(n: number): CurriedFunction1<$ReadOnlyArray<T>, Array<Array<T>>>;
+  declare function aperture<T>(n: number, xs: $ReadOnlyArray<T>): Array<Array<T>>;
+
+  declare function append<A, E>(A, $ReadOnlyArray<E>): Array<E|A>;
+  declare function append<A, E>(A): CurriedFunction1<$ReadOnlyArray<E>, Array<E|A>>;
+
+  declare function prepend<E>(x: E, xs: $ReadOnlyArray<E>): Array<E>;
+  declare function prepend<E>(x: E): (xs: $ReadOnlyArray<E>) => Array<E>;
+
+  declare function chain<A, B>(f: (x: A) => B[], xs: $ReadOnlyArray<A>): B[]
+  declare function chain<A, B>(f: (x: A) => B[]): (xs: $ReadOnlyArray<A>) => B[]
+
+  // Additional chain functionality documented at https://ramdajs.com/docs/#chain:
+  //
+  // Dispatches to the chain method of the second argument, if present, according to the FantasyLand Chain spec (https://github.com/fantasyland/fantasy-land#chain).
+  //
+  // If second argument is a function, chain(f, g)(x) is equivalent to f(g(x), x).
+  //
+  // Acts as a transducer if a transformer is given in list position.
+  declare function chain<A, B, R>(f: (x: A, y: B) => R, g: (y: B) => A):(y: B) => R;
+
+  declare function concat<A, B>(x: $ReadOnlyArray<A>, y: $ReadOnlyArray<B>): Array<A | B>;
+  declare function concat<A, B>(x: $ReadOnlyArray<A>): CurriedFunction1<$ReadOnlyArray<B>, Array<A | B>>;
+
+  declare function concat(x: string, y: string): string;
+  declare function concat(x: string): CurriedFunction1<string, string>;
+
+  declare type Includes =
+    & ((string, string) => boolean)
+    & ((string) => ((string => boolean)))
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A) => (b: T) => boolean)
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A, b: T) => boolean)
+
+  declare var includes: Includes;
+
+  declare function drop(n: number): (xs: string) => string;
+  declare function drop(n: number, xs: string): string;
+  declare function drop<V, T: $ReadOnlyArray<V>>(n: number): (xs: T) => V[];
+  declare function drop<V, T: $ReadOnlyArray<V>>(n: number, xs: T): V[];
+
+  declare function dropLast(n: number): (xs: string) => string;
+  declare function dropLast(n: number, xs: string): string;
+  declare function dropLast<V, T: $ReadOnlyArray<V>>(n: number): (xs: T) => V[];
+  declare function dropLast<V, T: $ReadOnlyArray<V>>(n: number, xs: T): V[];
+
+  declare function dropLastWhile(fn: UnaryPredicateFn<string>): (xs: string) => string;
+  declare function dropLastWhile(fn: UnaryPredicateFn<string>, xs: string): string;
+  declare function dropLastWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>): (xs: T) => V[];
+  declare function dropLastWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>, xs: T): V[];
+
+  declare function dropWhile(fn: UnaryPredicateFn<string>): (xs: string) => string;
+  declare function dropWhile(fn: UnaryPredicateFn<string>, xs: string): string;
+  declare function dropWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>): (xs: T) => V[];
+  declare function dropWhile<V, T: $ReadOnlyArray<V>>(fn: UnaryPredicateFn<V>, xs: T): V[];
+
+  declare function dropRepeats<V>(xs: $ReadOnlyArray<V>): V[];
+
+  declare function dropRepeatsWith<V>(fn: BinaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => V[];
+  declare function dropRepeatsWith<V>(fn: BinaryPredicateFn<V>, xs: $ReadOnlyArray<V>): V[];
+
+  declare function groupBy<T>(fn: (x: T) => string, xs: $ReadOnlyArray<T>): { [key: string]: Array<T>, ... };
+  declare function groupBy<T>(fn: (x: T) => string): CurriedFunction1<$ReadOnlyArray<T>, { [string]: Array<T>, ... }>;
+
+  declare function groupWith<V>(fn: BinaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => V[][];
+  declare function groupWith<V>(fn: BinaryPredicateFn<V>, xs: $ReadOnlyArray<V>): V[][];
+  declare function groupWith(fn: BinaryPredicateFn<string>): (xs: $ReadOnlyArray<string>) => string[];
+  declare function groupWith(fn: BinaryPredicateFn<string>, xs: $ReadOnlyArray<string>): string[];
+
+  declare function head<T, V: $ReadOnlyArray<T>>(xs: V): $ElementType<V, 0>;
+  declare function head(xs: string): string;
+
+  declare function into<I, T, A: $ReadOnlyArray<T>, R>(
+    accum: R,
+    xf: (a: A) => I,
+    input: A
+  ): R;
+  declare function into<I, T, A: $ReadOnlyArray<T>, R>(
+    accum: Transformer<I, R>,
+    xf: (a: A) => R,
+    input: A
+  ): R;
+
+  declare function indexOf<E>(x: ?E, xs: $ReadOnlyArray<E>): number;
+  declare function indexOf<E>(x: ?E): (xs: $ReadOnlyArray<E>) => number;
+
+  declare function indexBy<V>(fn: (x: V) => string): (xs: $ReadOnlyArray<V>) => { [key: string]: V, ... };
+  declare function indexBy<V>(fn: (x: V) => string, xs: $ReadOnlyArray<V>): { [key: string]: V, ... };
+
+  declare function insert<T>(index: number): (
+    & ((elem: T) => (src: $ReadOnlyArray<T>) => Array<T>)
+    & ((elem: T, src: $ReadOnlyArray<T>) => Array<T>)
+  );
+  declare function insert<T>(index: number, elem: T): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function insert<T>(index: number, elem: T, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function insertAll<T, S>(index: number): (
+    & ((elem: $ReadOnlyArray<S>) => (src: $ReadOnlyArray<T>) => Array<S | T>)
+    & ((elem: $ReadOnlyArray<S>, src: $ReadOnlyArray<T>) => Array<S | T>)
+  );
+  declare function insertAll<T, S>(index: number, elems: $ReadOnlyArray<S>): (src: $ReadOnlyArray<T>) => Array<S | T>;
+  declare function insertAll<T, S>(index: number, elems: $ReadOnlyArray<S>, src: $ReadOnlyArray<T>): Array<S | T>;
+
+  declare function join(x: string, xs: $ReadOnlyArray<string | number>): string;
+  declare function join(x: string): (xs: $ReadOnlyArray<string | number>) => string;
+
+  declare function last<T>(xs: $ReadOnlyArray<T>): ?T;
+  declare function last(xs: string): string;
+
+  declare function none<T>(fn: UnaryPredicateFn<T>, xs: $ReadOnlyArray<T>): boolean;
+  declare function none<T>(fn: UnaryPredicateFn<T>): (xs: $ReadOnlyArray<T>) => boolean;
+
+  declare function nth<V>(i: number, xs: $ReadOnlyArray<V>): ?V;
+  declare function nth(i: number, xs: string): string;
+  declare function nth<V>(i: number): (
+    & ((xs: string) => string)
+    & ((xs: $ReadOnlyArray<V>) => ?V)
+  );
+
+  declare type Find = (
+    & (<V>(fn: UnaryPredicateFn<V>) => (xs: $ReadOnlyArray<V>) => ?V)
+    & (<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>) => ?V)
+  );
+
+  declare var find: Find;
+
+  declare function findLast<V>(fn: UnaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => ?V;
+  declare function findLast<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): ?V;
+
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+  ): (xs: T) => number;
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): number;
+
+  declare function findLastIndex<K, V>(fn: UnaryPredicateFn<V>): (xs: $ReadOnlyArray<V>) => number;
+  declare function findLastIndex<K, V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): number;
+
+  declare function forEach<T, V>(fn: (x: T) => mixed, xs: $ReadOnlyArray<T>): Array<T>;
+  declare function forEach<T, V>(fn: (x: T) => mixed): (xs: $ReadOnlyArray<T>) => Array<T>;
+
+  declare function forEachObjIndexed<O, K: $Keys<O>, V: $Values<O>>(
+    fn: (val: V, key: K, o: O) => mixed,
+    o: O
+  ): O;
+  declare function forEachObjIndexed<O, K: $Keys<O>, V: $Values<O>>(
+    fn: (val: V, key: K, o: O) => mixed,
+  ): O => O;
+
+  declare function lastIndexOf<E>(x: E, xs: $ReadOnlyArray<E>): number;
+  declare function lastIndexOf<E>(x: E): (xs: $ReadOnlyArray<E>) => number;
+
+  declare var map: {
+    <T, R, FN: (x: T) => R, SR, S: { +map: FN => SR, ... }>(fn: FN, xs: S): SR,
+
+    <T, R, FN: (x: T) => R>(fn: FN): (
+      (<SR, S: { +map: FN => SR, ... }>(xs: S) => SR) &
+      ((xs: { +[key: string]: T, ... }) => { [key: string]: R, ... }) &
+      ((xs: $ReadOnlyArray<T> | Array<T>) => Array<R>)
+    ),
+    <T, R>(fn: (x: T) => R, xs: $ReadOnlyArray<T>): Array<R>,
+    <T, R>(fn: (x: T) => R, xs: { +[key: string]: T, ... }): { [key: string]: R, ... },
+    ...
+  };
+
+  declare type AccumIterator<A, B, R> = (acc: R, x: A) => [R, B];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: $ReadOnlyArray<A>
+  ): [R, Array<B>];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+  ): (acc: R, xs: $ReadOnlyArray<A>) => [R, Array<B>];
+
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: $ReadOnlyArray<A>
+  ): [R, Array<B>];
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+  ): (acc: R, xs: $ReadOnlyArray<A>) => [R, Array<B>];
+
+  declare function intersperse<E>(x: E, xs: $ReadOnlyArray<E>): Array<E>;
+  declare function intersperse<E>(
+    x: E,
+  ): (xs: $ReadOnlyArray<E>) => Array<E>;
+
+  declare function pair<A, B>(a: A, b: B): [A, B];
+  declare function pair<A, B>(a: A): (b: B) => [A, B];
+
+  declare function partition<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function partition<O, V: $Values<O>>(fn: UnaryPredicateFn<V>, xs: O): [$Shape<O>, $Shape<O>];
+  declare function partition<V>(fn: UnaryPredicateFn<V>): ((xs: $ReadOnlyArray<V>) => [V[], V[]]);
+  declare function partition<O, V>(fn: UnaryPredicateFn<V>): ((xs: O) => [$Shape<O>, $Shape<O>]);
+
+  declare function pluck<
+    V,
+    K: $Keys<V>,
+  >(key: K, list: $ReadOnlyArray<V>): Array<$ElementType<V, K>>;
+  declare function pluck<
+    V,
+    K: $Keys<V>,
+  >(key: K): (list: $ReadOnlyArray<V>) => Array<$ElementType<V, K>>;
+  declare function pluck<
+    T,
+    V: $ReadOnlyArray<T>,
+  >(key: number, list: $ReadOnlyArray<V>): Array<$ElementType<V, number>>;
+  declare function pluck<
+    T,
+    V: $ReadOnlyArray<T>,
+  >(key: number): (list: $ReadOnlyArray<V>) => Array<$ElementType<V, number>>;
+
+  declare var range: CurriedFunction2<number, number, Array<number>>;
+
+  declare function reduced<T>(x: T): $npm$ramda$Reduced<T>;
+
+  declare function remove<T>(
+    from: number,
+  ): ((to: number) => (src: $ReadOnlyArray<T>) => Array<T>) &
+    ((to: number, src: $ReadOnlyArray<T>) => Array<T>);
+  declare function remove<T>(
+    from: number,
+    to: number,
+  ): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function remove<T>(from: number, to: number, src: $ReadOnlyArray<T>): Array<T>;
+
+  declare function repeat<T>(x: T, times: number): Array<T>;
+  declare function repeat<T>(x: T): (times: number) => Array<T>;
+
+  declare function slice(from: number): (
+    & ((to: number) => (
+        & (<V>(src: $ReadOnlyArray<V>) => V[])
+        & ((src: string) => string)
+    ))
+    & (<V>(to: number, src: $ReadOnlyArray<V>) => V[])
+    & ((to: number, src: string) => string)
+  );
+  declare function slice(from: number, to: number): (
+    & (<V>(src: $ReadOnlyArray<V>) => V[])
+    & ((src: string) => string)
+  );
+  declare function slice<V>(
+    from: number,
+    to: number,
+    src: $ReadOnlyArray<V>,
+  ): V[];
+  declare function slice(
+    from: number,
+    to: number,
+    src: string,
+  ): string;
+
+  declare function sort<V, T: Array<V>>(fn: (a: V, b: V) => number, xs: $ReadOnlyArray<V>): T;
+  declare function sort<V, T: Array<V>>(
+    fn: (a: V, b: V) => number,
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function sortWith<V, T: Array<V>>(
+    fns: $ReadOnlyArray<(a: V, b: V) => number>,
+    xs: $ReadOnlyArray<V>
+  ): T;
+  declare function sortWith<V, T: Array<V>>(
+    fns: $ReadOnlyArray<(a: V, b: V) => number>,
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  /**
+   * In the examples for ascend and descend, its result is plugged into sort.
+   * In order for this to function properly ascend and descend need to yield a
+   * function that can take two arguments. In our case we'll declare the result
+   * function as curried, which matches the ramda behavior.
+   */
+  declare type MakeComparator = <A, B>(A => B) => CurriedFunction2<A, A, number>
+
+  declare var descend: MakeComparator
+  declare var ascend: MakeComparator
+
+  declare function times<T>(fn: (i: number) => T, n: number): Array<T>;
+  declare function times<T>(
+    fn: (i: number) => T,
+  ): (n: number) => Array<T>;
+
+  declare function take<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function take<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLast<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function takeLast<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>,
+    xs: $ReadOnlyArray<V>
+  ): T;
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function takeWhile<V, T: Array<V>>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): T;
+  declare function takeWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: $ReadOnlyArray<V>) => T;
+
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean,
+  ): (seed: T) => Array<R>;
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean,
+    seed: T
+  ): Array<R>;
+
+  declare function uniqBy<T, V>(
+    fn: (x: T) => V,
+  ): (xs: $ReadOnlyArray<T>) => Array<T>;
+  declare function uniqBy<T, V>(fn: (x: T) => V, xs: $ReadOnlyArray<T>): Array<T>;
+
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): (xs: $ReadOnlyArray<T>) => Array<T>;
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function update<T>(
+    index: number,
+  ): ((elem: T) => (src: $ReadOnlyArray<T>) => Array<T>) &
+    ((elem: T, src: $ReadOnlyArray<T>) => Array<T>);
+  declare function update<T>(
+    index: number,
+    elem: T,
+  ): (src: $ReadOnlyArray<T>) => Array<T>;
+  declare function update<T>(index: number, elem: T, src: $ReadOnlyArray<T>): Array<T>;
+
+  // TODO `without` as a transducer
+  declare function without<T, E>($ReadOnlyArray<E>, $ReadOnlyArray<E|T>): Array<E|T>;
+  declare function without<T, E>($ReadOnlyArray<E>): CurriedFunction1<$ReadOnlyArray<E|T>, Array<E|T>>;
+
+  declare function xprod<T, S>(xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>): Array<[T, S]>;
+  declare function xprod<T, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<[T, S]>;
+
+  declare function zip<T, S>(xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>): Array<[T, S]>;
+  declare function zip<T, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<[T, S]>;
+
+  declare function zipObj<T: string, S>(
+    xs: $ReadOnlyArray<T>,
+    ys: $ReadOnlyArray<S>
+  ): { [key: T]: S, ... };
+  declare function zipObj<T: string, S>(
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => { [key: T]: S, ... };
+
+  declare type NestedArray<T> = $ReadOnlyArray<T | NestedArray<T>>;
+  declare function flatten<T>(xs: NestedArray<T>): Array<T>;
+
+  declare function fromPairs<T, V>(pairs: $ReadOnlyArray<[T, V]>): { [key: string]: V, ... };
+
+  declare function init<T>(xs: $ReadOnlyArray<T>): T[];
+  declare function init(xs: string): string;
+
+  declare function length<T>(xs: $ReadOnlyArray<T> | string | { length: number, ... }): number;
+
+  declare function reverse<T, V: Array<T> | string>(xs: $ReadOnlyArray<T>): V;
+
+  declare type Reduce = (
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A) => (
+        & ((init: I) => (xs: $ReadOnlyArray<B>) => (A | I))
+        & ((init: I, xs: $ReadOnlyArray<B>) => (A | I))
+      )
+    )
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A, init: I) => (xs: $ReadOnlyArray<B>) => (A | I)
+    )
+    & (
+      <A, B, I = A>(fn: (acc: A | I, elm: B) => $npm$ramda$Reduced<A> | A, init: I, xs: $ReadOnlyArray<B>) => (A | I)
+    )
+  );
+
+  declare var reduce: Reduce;
+
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+  ): ((acc: B) => ((
+    keyFn: (elem: A) => string,
+  ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... })) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string,
+    ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string,
+      xs: Array<A>
+    ) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+  ): ((
+    keyFn: (elem: A) => string,
+  ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string
+  ): (xs: Array<A>) => { [key: string]: B, ... };
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string,
+    xs: Array<A>
+  ): { [key: string]: B, ... };
+
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+  ): ((init: A, xs: Array<B>) => A) &
+    ((init: A) => (xs: Array<B>) => A);
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A,
+  ): (xs: Array<B>) => A;
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function reduceWhile<A, B>(pred: (acc: A, curr: B) => boolean): ((
+    fn: (a: A, b: B) => A,
+  ) => (init: A) => (
+    xs: Array<B>
+  ) => A &
+    ((
+      fn: (a: A, b: B) => A,
+    ) => (init: A, xs: Array<B>) => A)) &
+    ((
+      fn: (a: A, b: B) => A,
+      init: A,
+    ) => (xs: Array<B>) => A) &
+    ((fn: (a: A, b: B) => A, init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    pred: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A,
+  ): ((init: A) => (xs: Array<B>) => A) &
+    ((init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    fn: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+  ): ((init: A, xs: Array<B>) => Array<A>) &
+    ((init: A) => (xs: Array<B>) => Array<A>);
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A,
+  ): (xs: Array<B>) => Array<A>;
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A,
+    xs: Array<B>
+  ): Array<A>;
+
+  declare function splitAt<V>(i: number, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function splitAt(i: number, xs: string): [string, string];
+  declare function splitAt(i: number): (
+    & (string => [string, string])
+    & <V>($ReadOnlyArray<V>) => [V[], V[]]
+  );
+
+  declare function splitEvery<V>(i: number, xs: $ReadOnlyArray<V>): V[][];
+  declare function splitEvery(i: number, xs: string): string[];
+  declare function splitEvery(i: number): (
+    & (string => string[])
+    & <V>($ReadOnlyArray<V>) => V[][]
+  );
+
+  declare function splitWhen<V>(fn: UnaryPredicateFn<V>, xs: $ReadOnlyArray<V>): [V[], V[]];
+  declare function splitWhen(fn: UnaryPredicateFn<string>, xs: string): [string, string];
+  declare function splitWhen<V>(fn: V => boolean): (
+  	& ($ReadOnlyArray<V> => [V[], V[]])
+  	& ((V & string) => [string, string])
+  );
+
+  declare function tail<V>(xs: $ReadOnlyArray<V>): V[];
+  declare function tail<V>(xs: string): string;
+
+  declare function transpose<T>(xs: $ReadOnlyArray<$ReadOnlyArray<T>>): Array<Array<T>>;
+
+  declare function uniq<T>(xs: $ReadOnlyArray<T>): Array<T>;
+
+  declare function unnest<T>(xs: $ReadOnlyArray<T | $ReadOnlyArray<T>>): $ReadOnlyArray<T>;
+
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+  ): ((xs: $ReadOnlyArray<T>, ys: $ReadOnlyArray<S>) => Array<R>) &
+    ((xs: $ReadOnlyArray<T>) => (ys: $ReadOnlyArray<S>) => Array<R>);
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: $ReadOnlyArray<T>,
+  ): (ys: $ReadOnlyArray<S>) => Array<R>;
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: $ReadOnlyArray<T>,
+    ys: $ReadOnlyArray<S>
+  ): Array<R>;
+
+  // *Relation
+  declare function equals<T>(x: T): (y: T) => boolean;
+  declare function equals<T>(x: T, y: T): boolean;
+
+  declare function eqBy<A, B>(
+    fn: (x: A) => B,
+      ): ((x: A, y: A) => boolean) &
+    ((x: A) => (y: A) => boolean);
+  declare function eqBy<A, B>(
+    fn: (x: A) => B,
+    x: A,
+      ): (y: A) => boolean;
+  declare function eqBy<A, B>(fn: (x: A) => B, x: A, y: A): boolean;
+
+  // Flow cares about the order in which these appear. Generally function
+  // siguatures should go from smallest arity to largest arity.
+  declare type PropEq = (
+    & (
+        <T>(prop: $Keys<T>) => (
+          & ((val: mixed) => (obj: T) => boolean)
+          & ((val: mixed, obj: T) => boolean)
+        )
+    )
+    & (
+      <T>(prop: $Keys<T>, val: mixed) => (obj: T) => boolean
+    )
+    & (
+      <T>(prop: $Keys<T>, val: mixed, obj: T) => boolean
+    )
+    // Array variants.
+    & (
+      <T>(prop: number) => (
+        & ((val: mixed) => (obj: $ReadOnlyArray<T>) => boolean)
+        & ((val: mixed, obj: $ReadOnlyArray<T>) => boolean)
+      )
+    )
+    & (
+      <T>(prop: number, val: mixed) => (obj: $ReadOnlyArray<T>) => boolean
+    )
+    & (
+      <T>(prop: number, val: mixed, obj: $ReadOnlyArray<T>) => boolean
+    )
+  );
+  declare var propEq: PropEq;
+
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>): (
+    & ((val: mixed) => (o: O) => boolean)
+    & ((val: mixed, o: O) => boolean)
+  );
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>, val: mixed): (o: O) => boolean;
+  declare function pathEq<
+    T: string | number, E, O: { ... } | $ReadOnlyArray<E>
+  >(path: $ReadOnlyArray<T>, val: mixed, O): boolean;
+
+  declare function clamp<T: number | string | Date>(
+    min: T,
+  ): ((max: T) => (v: T) => T) & ((max: T, v: T) => T);
+  declare function clamp<T: number | string | Date>(
+    min: T,
+    max: T,
+  ): (v: T) => T;
+  declare function clamp<T: number | string | Date>(min: T, max: T, v: T): T;
+
+  declare function countBy<T>(
+    fn: (x: T) => string,
+  ): (list: $ReadOnlyArray<T>) => { [key: string]: number, ... };
+  declare function countBy<T>(
+    fn: (x: T) => string,
+    list: $ReadOnlyArray<T>
+  ): { [key: string]: number, ... };
+
+  declare function difference<T>(
+    xs1: $ReadOnlyArray<T>,
+  ): (xs2: $ReadOnlyArray<T>) => Array<T>;
+  declare function difference<T>(xs1: $ReadOnlyArray<T>, xs2: $ReadOnlyArray<T>): Array<T>;
+
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((xs1: $ReadOnlyArray<T>) => (xs2: $ReadOnlyArray<T>) => Array<T>) &
+    ((xs1: $ReadOnlyArray<T>, xs2: $ReadOnlyArray<T>) => Array<T>);
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: $ReadOnlyArray<T>,
+  ): (xs2: $ReadOnlyArray<T>) => Array<T>;
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: $ReadOnlyArray<T>,
+    xs2: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function eqBy<T>(fn: (x: T) => T, x: T, y: T): boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T, y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T, x: T): (y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T) => (y: T) => boolean;
+
+  declare type RelationCompare =
+    & ((x: number) => (y: number) => bool)
+    & ((x: number, y: number) => bool)
+    & ((x: string) => (y: string) => bool)
+    & ((x: string, y: string) => bool)
+
+  declare var gt: RelationCompare
+  declare var gte: RelationCompare
+  declare var lt: RelationCompare
+  declare var lte: RelationCompare
+
+  declare function identical<T>(x: T): (y: T) => boolean;
+  declare function identical<T>(x: T, y: T): boolean;
+
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+  ): (
+    a: $ReadOnlyArray<A>,
+  ) => (b: $ReadOnlyArray<B>) => Array<A> & ((a: $ReadOnlyArray<A>, b: $ReadOnlyArray<B>) => Array<A>);
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: $ReadOnlyArray<A>,
+  ): (b: $ReadOnlyArray<B>) => Array<A>;
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: $ReadOnlyArray<A>,
+    b: $ReadOnlyArray<B>
+  ): Array<A>;
+
+  declare function intersection<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+  declare function intersection<T>(x: $ReadOnlyArray<T>): (y: $ReadOnlyArray<T>) => Array<T>;
+
+  declare function max<T>(x: T): (y: T) => T;
+  declare function max<T>(x: T, y: T): T;
+
+  declare function maxBy<T, V>(
+    fn: (x: T) => V,
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function maxBy<T, V>(
+    fn: (x: T) => V,
+    x: T,
+  ): (y: T) => T;
+  declare function maxBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function min<T>(x: T): (y: T) => T;
+  declare function min<T>(x: T, y: T): T;
+
+  declare function minBy<T, V>(
+    fn: (x: T) => V,
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function minBy<T, V>(fn: (x: T) => V, x: T): (y: T) => T;
+  declare function minBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function sortBy<T, V>(
+    fn: (x: T) => V,
+  ): (x: $ReadOnlyArray<T>) => Array<T>;
+  declare function sortBy<T, V>(fn: (x: T) => V, x: $ReadOnlyArray<T>): Array<T>;
+
+  declare function symmetricDifference<T>(
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function symmetricDifference<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((x: $ReadOnlyArray<T>) => (y: Array<T>) => Array<T>) &
+    ((x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>) => Array<T>);
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+    y: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  declare function union<T>(
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function union<T>(x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>): Array<T>;
+
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+  ): ((x: $ReadOnlyArray<T>) => (y: Array<T>) => Array<T>) &
+    ((x: $ReadOnlyArray<T>, y: $ReadOnlyArray<T>) => Array<T>);
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+  ): (y: $ReadOnlyArray<T>) => Array<T>;
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: $ReadOnlyArray<T>,
+    y: $ReadOnlyArray<T>
+  ): Array<T>;
+
+  // *Object
+  declare var assoc: {
+    <T, S>(
+      key: string,
+      ...args: Array<void>
+    ):
+      & ((val: T) => (src: S) => ({ [k: string]: T, ... }))
+      & ((val: T, src: S) => ({ [k: string]: T, ... } & S)),
+    <T, S>(
+      key: string,
+      val: T,
+      ...args: Array<void>
+    ): (src: S) => ({ [k: string]: T, ... } & S),
+    <T, S: { ... }, K: $Keys<S>> (key: K, val: T, src: S):      ({ [k: string]: T, ... } & S),
+    <T, S: { ... }>              (key: string, val: T, src: S): ({
+      [k: string]: T,
+      ...$Exact<S>,
+      ...
+    }),
+    ...
+  };
+
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    ...args: Array<void>
+  ): ((val: V) => (src: S) => { [k: string]: V, ... }) &
+    ((val: V) => (src: S) => { [k: string]: V, ... } & S);
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    val: V,
+    ...args: Array<void>
+  ): (src: S) => { [k: string]: V, ... } & S;
+  declare function assocPath<T: string | number, S, V>(
+    key: $ReadOnlyArray<T>,
+    val: V,
+    src: S
+  ): { [k: string]: V, ... } & S;
+
+  declare function clone<T>(src: T): $Shape<T>;
+
+  declare function dissoc<T>(
+    key: string,
+    ...args: Array<void>
+  ): (src: { [k: string]: T, ... }) => { [k: string]: T, ... };
+  declare function dissoc<T>(
+    key: string,
+    src: { [k: string]: T, ... }
+  ): { [k: string]: T, ... };
+
+  declare function dissocPath<T: string | number, U>(
+    key: $ReadOnlyArray<T>,
+    ...args: Array<void>
+  ): (src: { [k: string]: U, ... }) => { [k: string]: U, ... };
+  declare function dissocPath<T: string | number, U>(
+    key: $ReadOnlyArray<T>,
+    src: { [k: string]: U, ... }
+  ): { [k: string]: U, ... };
+
+  declare function evolve(NestedObject<Function>): { ... } => { ... };
+  declare function evolve(NestedObject<Function>, { ... }): { ... };
+
+  declare function eqProps(
+    key: string,
+    ...args: Array<void>
+  ): ((o1: { ... }) => (o2: { ... }) => boolean) &
+    ((o1: { ... }, o2: { ... }) => boolean);
+  declare function eqProps(
+    key: string,
+    o1: { ... },
+    ...args: Array<void>
+  ): (o2: { ... }) => boolean;
+  declare function eqProps(key: string, o1: { ... }, o2: { ... }): boolean;
+
+  declare function has(key: string): (o: ?{ ... }) => boolean;
+  declare function has(key: string, o: ?{ ... }): boolean;
+
+  declare function hasPath<T: string | number>(path: $ReadOnlyArray<T>): (o: { ... }) => boolean;
+  declare function hasPath<T: string | number>(path: $ReadOnlyArray<T>, o: { ... }): boolean;
+
+  declare function hasIn(key: string, o: { ... }): boolean;
+  declare function hasIn(key: string): (o: { ... }) => boolean;
+
+  declare function invert(o: { ... }): { [k: string]: Array<string>, ... };
+  declare function invertObj(o: { ... }): { [k: string]: string, ... };
+
+  declare function keys(o: ?{ ... }): Array<string>;
+
+  declare type Lens<A, B, Fa: Functor<A>, Fb: Functor<B>> = (A => Fb) => Fb;
+  /**
+   * Because it is difficult to treat objects as if they are Functors, let's
+   * just have a lens type that works with objects, since Ramda supports objects
+   * as Functors in this context.
+   */
+  declare type LensObj<F, A, O> = (A => O) => O;
+
+  declare var lens:
+    & (<A, B, Fa, Fb>(
+      getter: (f: Fa) => A) => (
+      setter: (b: B, f: Fa) => Fb
+    ) => LensObj<Fa, A, Fb>)
+    & (<A, B, Fa, Fb>(
+      getter: (f: Fa) => A,
+      setter: (b: B, f: Fa) => Fb
+    ) => LensObj<Fa, A, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(
+      getter: (f: Fa) => A) => (
+      setter: (b: B, f: Fa) => Fb
+    ) => Lens<A, B, Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(
+      getter: (f: Fa) => A,
+      setter: (b: B, f: Fa) => Fb
+    ) => Lens<A, B, Fa, Fb>)
+
+  declare function lensIndex<A, B, Fa: Functor<A>, Fb: Functor<B>, N: number, V: $ElementType<Fa, N>>(N): Lens<V, B, Fa, Fb>;
+
+  /**
+   * lensPath requires a tuple rather than an Array for its parameter. This
+   * allows us to make rested $ElementType uses in order to walk down the object
+   * hierarchy. This remains something TODO.
+   */
+  declare function lensPath<O, F, K: $Keys<F>>(p: [K]): LensObj<F, $ElementType<F, K>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>
+  >(p: [K0, K1]): LensObj<F, $ElementType<E0, K1>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>
+  >(p: [K0, K1, K2]): LensObj<F, $ElementType<E1, K2>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>, E2: $ElementType<E1, K2>,
+    K3: $Keys<E2>
+  >(p: [K0, K1, K2, K3]): LensObj<F, $ElementType<E2, K3>, O>;
+  declare function lensPath<
+    O, F,
+    K0: $Keys<F>, E0: $ElementType<F, K0>,
+    K1: $Keys<E0>, E1: $ElementType<E0, K1>,
+    K2: $Keys<E1>, E2: $ElementType<E1, K2>,
+    K3: $Keys<E2>, E3: $ElementType<E2, K3>,
+    K4: $Keys<E3>
+  >(p: [K0, K1, K2, K3, K4]): LensObj<F, $ElementType<E3, K4>, O>;
+
+  // declare function lensProp(str: string): Lens;
+  declare function lensProp<O, F, K: $Keys<F>>(K): LensObj<F, $ElementType<F, K>, O>;
+
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: { ... }) => B,
+    o: { [key: string]: A, ... }
+  ): { [key: string]: B, ... };
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: { ... }) => B,
+    ...args: Array<void>
+  ): (o: { [key: string]: A, ... }) => { [key: string]: B, ... };
+
+  declare type Merge =
+    (<A, B>(a: A) => (b: B) => A & B) &
+    (<A, B>(a: A, b: B) => A & B);
+
+  declare var mergeLeft: Merge;
+  declare var mergeDeepLeft: Merge;
+  declare var mergeRight: Merge;
+
+  declare function mergeAll<T>(
+    os: $ReadOnlyArray<{ [k: string]: T, ... }>
+  ): { [k: string]: T, ... };
+
+  declare var mergeDeepRight: (<A, B>(a: A, b: B) => B & A) &
+    (<A, B>(a: A) => (b: B) => B & A);
+
+  declare type MergeWith = (<A, B, T: $Values<A> & $Values<B>>(
+    fn: (a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+    ) => (a: A) => (b: B) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+    ) => (a: A, b: B) => A & B) &
+    (<A, B, T>(
+      fn: (a: T, b: T) => T,
+      a: A,
+    ) => (b: B) => A & B);
+
+  declare type MergeWithKey = (<
+    A,
+    B,
+    S: $Keys<A> & $Keys<B>,
+    T: $ElementType<A, $Keys<A>> & $ElementType<B, $Keys<B>>,
+  >(
+    fn: (s: S, a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+    ) => (a: A, b: B) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+    ) => (a: A) => (b: B) => A & B) &
+    (<S, T, A, B>(
+      fn: (s: S, a: T, b: T) => T,
+      a: A,
+    ) => (b: B) => A & B);
+
+  declare var mergeDeepWith: MergeWith;
+
+  declare var mergeDeepWithKey: MergeWithKey;
+
+  declare var mergeWith: MergeWith;
+
+  declare var mergeWithKey: MergeWithKey;
+
+  declare function objOf<T>(
+    key: string,
+  ): (val: T) => { [key: string]: T, ... };
+  declare function objOf<T>(key: string, val: T): { [key: string]: T, ... };
+
+  declare function omit<T: { ... }>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: T) => $Shape<T>;
+  declare function omit<T: { ... }>(keys: $ReadOnlyArray<string>, val: T): $Shape<T>;
+
+  declare type Functor<A> =
+    | { @@iterator(): Iterator<A>, ... }
+    | FunctorObj<A>
+    | FunctorFantasyLand<A>
+    | Array<A>
+    | $ReadOnlyArray<A>
+
+  declare var over:
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>) => CurriedFunction2<A => B, Oa, Ob>)
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, A => B) => CurriedFunction1<Oa, Ob>)
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, A => B, Oa) => Ob)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>) => CurriedFunction2<A => B, Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, A => B) => CurriedFunction1<Fa, Fb>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, A => B, Fa) => Fb)
+
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: NestedObject<V>) => V;
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: null | void) => void;
+  declare function path<T: string | number, V>(
+    p: $ReadOnlyArray<T>,
+  ): (o: mixed) => ?V;
+  declare function path<T: string | number, V, A: NestedObject<V>>(p: $ReadOnlyArray<T>, o: A): V;
+  declare function path<T: string | number, V, A: null | void>(p: $ReadOnlyArray<T>, o: A): void;
+  declare function path<T: string | number, V, A>(p: $ReadOnlyArray<T>, o: A): ?V;
+
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: NestedObject<V>) => V;
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: null | void) => void;
+  declare function path<V>(
+    p: $ReadOnlyArray<string>,
+  ): (o: mixed) => ?V;
+  declare function path<V, A: NestedObject<V>>(p: $ReadOnlyArray<string>, o: A): V;
+  declare function path<V, A: null | void>(p: $ReadOnlyArray<string>, o: A): void;
+  declare function path<V, A: mixed>(p: $ReadOnlyArray<string>, o: A): ?V;
+
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+  ): ((p: $ReadOnlyArray<U>) => (o: ?A) => V | T) &
+    ((p: $ReadOnlyArray<U>, o: ?A) => V | T);
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+    p: $ReadOnlyArray<U>,
+  ): (o: ?A) => V | T;
+  declare function pathOr<T, U: string | number, V, A: NestedObject<V>>(
+    or: T,
+    p: $ReadOnlyArray<U>,
+    o: ?A
+  ): V | T;
+
+  declare function pick<O, K: $ReadOnlyArray<$Keys<O>>>(
+    keys: K,
+  ): (val: O) => O;
+  declare function pick<O, K: $ReadOnlyArray<$Keys<O>>>(
+    keys: K,
+    val: O
+  ): O;
+
+  declare function pickAll<A>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: { [key: string]: A, ... }) => { [key: string]: ?A, ... };
+  declare function pickAll<A>(
+    keys: $ReadOnlyArray<string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: ?A, ... };
+
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>,
+  ): (val: { [key: string]: A, ... }) => { [key: string]: A, ... };
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: A, ... };
+
+  declare function project<T>(
+    keys: $ReadOnlyArray<string>,
+  ): (val: $ReadOnlyArray<{ [key: string]: T, ... }>) => Array<{ [key: string]: T, ... }>;
+  declare function project<T>(
+    keys: $ReadOnlyArray<string>,
+    val: $ReadOnlyArray<{ [key: string]: T, ... }>
+  ): Array<{ [key: string]: T, ... }>;
+
+  declare function prop<T: string, O>(
+    key: T,
+  ): (o: O) => $ElementType<O, T>;
+  declare function prop<T: string, O>(
+    __: $npm$ramda$Placeholder,
+    o: O
+  ): (key: T) => $ElementType<O, T>;
+  declare function prop<T: string, O>(key: T, o: O): $ElementType<O, T>;
+
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+  ): ((p: string) => (o: A) => V | T) &
+    ((p: string, o: A) => V | T);
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+    p: string,
+  ): (o: A) => V | T;
+  declare function propOr<T, V, A: { [k: string]: V, ... }>(
+    or: T,
+    p: string,
+    o: A
+  ): V | T;
+
+  declare function keysIn(o: { ... }): Array<string>;
+
+  declare function props<T: string, O>(
+    keys: $ReadOnlyArray<T>,
+  ): (o: O) => Array<$ElementType<O, T>>;
+  declare function props<T: string, O>(
+    keys: $ReadOnlyArray<T>,
+    o: O
+  ): Array<$ElementType<O, T>>;
+
+  declare var set:
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>) => (
+      & (B => Oa => Ob)
+      & ((B, Oa) => Ob)
+    ))
+    & (<A, B, Oa, Ob>(lens: LensObj<Oa, A, B>, B, Oa) => Ob)
+    // NOTE: Other functor types might need to be directly supported here.
+    & (<A, B, Fa: Array<A>>(lens: Lens<A, B, Fa, Array<B>>) => (
+      & (B => Fa => Array<B>)
+      & ((B, Fa) => Array<B>)
+    ))
+    & (<A, B, Fa: Array<A>>(lens: Lens<A, B, Fa, Array<B>>, B, Fa) => Array<B>)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>) => (
+      & (B => Fa => Fb)
+      & ((B, Fa) => Fb)
+    ))
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(lens: Lens<A, B, Fa, Fb>, B, Fa) => Fb)
+
+  declare function toPairs<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[$Keys<O>, T]>;
+
+  declare function toPairsIn<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[string, T]>;
+
+  declare function values<T>(o: T): Array<$Values<T>>;
+
+  declare function valuesIn<T, O>(o: O): Array<$Values<T> | mixed>;
+
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>,
+    o: O
+  ): boolean;
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>
+  ): O => boolean;
+
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O,
+  ): (o: $Shape<O & Q>) => boolean;
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O,
+    o: $Shape<O & Q>
+  ): boolean;
+
+  declare var view:
+    & (<A, B, Oa, Ob>(LensObj<Oa, A, B>) => Oa => A)
+    & (<A, B, Oa, Ob>(LensObj<Oa, A, B>, Oa) => A)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(Lens<A, B, Fa, Fb>) => Fa => A)
+    & (<A, B, Fa: Functor<A>, Fb: Functor<B>>(Lens<A, B, Fa, Fb>, Fa) => A)
+
+  // *Function
+  declare var __: $npm$ramda$Placeholder;
+
+  declare var T: (_: mixed) => true;
+  declare var F: (_: mixed) => false;
+
+  declare function addIndex<A, B>(
+    iterFn: (fn: (x: A) => B, xs: $ReadOnlyArray<A>) => Array<B>
+  ): (fn: (x: A, idx: number, xs: $ReadOnlyArray<A>) => B, xs: $ReadOnlyArray<A>) => Array<B>;
+
+  declare function always<T>(x: T): (x: mixed) => T;
+
+  declare function ap<T, V>(
+    fns: $ReadOnlyArray<(x: T) => V>,
+  ): (xs: $ReadOnlyArray<T>) => Array<V>;
+  declare function ap<T, V>(fns: $ReadOnlyArray<(x: T) => V>, xs: $ReadOnlyArray<T>): Array<V>;
+
+  declare function apply<T, V>(
+    fn: (...args: Array<T>) => V,
+  ): (xs: $ReadOnlyArray<T>) => V;
+  declare function apply<T, V>(fn: (...args: Array<T>) => V, xs: $ReadOnlyArray<T>): V;
+
+  declare function applySpec<
+    V,
+    S,
+    A: $ReadOnlyArray<V>,
+    T: NestedObject<(...args: A) => S>
+  >(
+    spec: T
+  ): (...args: A) => NestedObject<S>;
+
+  declare function applyTo<A, B>(a: A): (fn: (x: A) => B) => B;
+  declare function applyTo<A, B>(a: A, fn: (x: A) => B): B;
+
+  declare function binary<T, A, B>(
+    fn: (a: A, b: B, ...args: Array<mixed>) => T
+  ): (x: A, y: B) => T;
+
+  declare function bind<T, A, R, F: (...args: A) => R>(
+    fn: F,
+    thisObj: T
+  ): F;
+
+  declare function call<T, V>(
+    fn: (...args: Array<V>) => T,
+    ...args: Array<V>
+  ): T;
+
+  declare function comparator<T>(
+    fn: BinaryPredicateFn<T>
+  ): (x: T, y: T) => number;
+
+  // TODO add tests
+  declare function construct<T>(
+    ctor: Class<GenericContructor<T>>
+  ): (x: T) => GenericContructor<T>;
+
+  // TODO add tests
+  declare function constructN<T, E>(
+    n: number,
+    ctor: Class<GenericContructorMulti<T>>
+  ): (...args: Array<T>) => GenericContructorMulti<T>;
+
+  // TODO make less generic
+  declare function converge(after: Function, fns: $ReadOnlyArray<Function>): Function;
+
+  declare function empty<T>(x: T): T;
+
+  declare function flip<A, B, TResult>(
+    fn: (arg0: A, arg1: B) => TResult
+  ): CurriedFunction2<B, A, TResult>;
+  declare function flip<A, B, C, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C) => TResult
+  ): ((arg0: B, arg1: A) => (arg2: C) => TResult) &
+    ((arg0: B, arg1: A, arg2: C) => TResult);
+  declare function flip<A, B, C, D, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D) => TResult
+  ): ((
+    arg1: B,
+    arg0: A,
+  ) => (arg2: C, arg3: D) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D) => TResult);
+  declare function flip<A, B, C, D, E, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D, arg4: E) => TResult
+  ): ((
+    arg1: B,
+    arg0: A,
+  ) => (arg2: C, arg3: D, arg4: E) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D, arg4: E) => TResult);
+
+  declare function identity<T>(x: T): T;
+
+  declare function invoker<A, B, C, D, O: { [k: string]: Function, ... }>(
+    arity: number,
+    name: $Keys<O>
+  ): CurriedFunction2<A, O, D> &
+    CurriedFunction3<A, B, O, D> &
+    CurriedFunction4<A, B, C, O, D>;
+
+  declare function juxt<T, S>(
+    fns: $ReadOnlyArray<(...args: Array<S>) => T>
+  ): (...args: Array<S>) => Array<T>;
+
+  // TODO lift
+
+  // TODO liftN
+
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: $ReadOnlyArray<A>) => C
+  ): (...args: Array<A>) => (...args: Array<A>) => B;
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: $ReadOnlyArray<A>) => C,
+    fn: (...args: Array<A>) => B
+  ): (...args: Array<A>) => B;
+
+  declare function nAry<T, V>(
+    arity: number,
+    fn: (...args: Array<V>) => T
+  ): (...args: Array<V>) => T;
+
+  declare function nthArg<T>(n: number): (...args: Array<T>) => T;
+
+  declare var o: (<A, B, C>(
+    fn1: (b: B) => C,
+    ...rest: void[]
+  ) => ((fn2: (a: A) => B, ...rest: void[]) => (x: A) => C) &
+    ((fn2: (a: A) => B, x: A) => C)) &
+    (<A, B, C>(
+      fn1: (b: B) => C,
+      fn2: (a: A) => B,
+      ...rest: void[]
+    ) => (x: A) => C) &
+    (<A, B, C>(fn1: (b: B) => C, fn2: (a: A) => B, x: A) => C);
+
+  declare function of<T>(x: T): Array<T>;
+
+  declare function once<A, B, T: (...args: Array<A>) => B>(fn: T): T;
+
+  declare var partial: Partial;
+  // TODO partialRight
+
+  declare type UnaryMonadFn<A, R> = UnaryFn<A, Monad<R>>;
+
+  declare function tap<T>(fn: (x: T) => mixed): (x: T) => T;
+  declare function tap<T>(fn: (x: T) => mixed, x: T): T;
+
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B
+  ): ((catcher: (e: E, a: A) => B) => (a: A) => B) &
+    ((catcher: (e: E, a: A) => B, a: A) => B);
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B
+  ): (a: A) => B;
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B,
+    a: A
+  ): B;
+
+  declare function unapply<T, V>(
+    fn: (xs: $ReadOnlyArray<T>) => V
+  ): (...args: Array<T>) => V;
+
+  declare function unary<T, A, V>(fn: (A, ...args: Array<V>) => T): (x: A) => T;
+
+  declare var uncurryN: (<A, B, C>(2, (A) => B => C) => (A, B) => C) &
+    (<A, B, C, D>(3, (A) => B => C => D) => (A, B, C) => D) &
+    (<A, B, C, D, E>(4, (A) => B => C => D => E) => (A, B, C, D) => E) &
+    (<A, B, C, D, E, F>(
+      5,
+      (A) => B => C => D => E => F
+    ) => (A, B, C, D, E) => F) &
+    (<A, B, C, D, E, F, G>(
+      6,
+      (A) => B => C => D => E => F => G
+    ) => (A, B, C, D, E, F) => G) &
+    (<A, B, C, D, E, F, G, H>(
+      7,
+      (A) => B => C => D => E => F => G => H
+    ) => (A, B, C, D, E, F, G) => H) &
+    (<A, B, C, D, E, F, G, H, I>(
+      8,
+      (A) => B => C => D => E => F => G => H => I
+    ) => (A, B, C, D, E, F, G, H) => I);
+
+  //TODO useWith
+
+  // *Logic
+
+  declare function allPass<T>(
+    fns: $ReadOnlyArray<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function and<X, Y>(x: X): (y: Y) => X | Y;
+  declare function and<X, Y>(x: X, y: Y): X | Y;
+
+  declare function anyPass<T>(
+    fns: $ReadOnlyArray<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function both<T, F: (...args: Array<T>) => boolean>(x: F): (y: F) => F;
+  declare function both<T, F: (...args: Array<T>) => boolean>(x: F, y: F): F;
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement declaration.
+
+  declare function complement< Fn: () => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, Fn: (A) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, Fn: (A, B) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, Fn: (A, B, C) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, Fn: (A, B, C, D) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, Fn: (A, B, C, D, E) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, Fn: (A, B, C, D, E, F) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, Fn: (A, B, C, D, E, F, G) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, Fn: (A, B, C, D, E, F, G, H) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, Fn: (A, B, C, D, E, F, G, H, I) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, J, Fn: (A, B, C, D, E, F, G, H, I, J) => boolean>(
+    f: Fn
+  ): Fn;
+  // End generated complement declaration.
+
+  declare function cond<A, B>(
+    fns: $ReadOnlyArray<[
+      (...r: Array<A>) => boolean,
+      (...r: Array<A>) => B
+    ]>
+  ): (...r: Array<A>) => B;
+
+  declare function defaultTo<T, V>(d: T): (x: ?V) => V | T;
+  declare function defaultTo<T, V>(d: T, x: ?V): V | T;
+
+  declare function either<A, F: (...args: Array<A>) => boolean>(x: F): (y: F) => F;
+  declare function either<A, F: (...args: Array<A>) => boolean>(x: F, y: F): F;
+
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean
+  ): ((
+    f1: (...args: Args) => B
+  ) => (f2: (...args: Args) => C) => (...args: Args) => B | C) &
+    ((
+      f1: (...args: Args) => B,
+      f2: (...args: Args) => C
+    ) => (...args: Args) => B | C);
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean,
+    f1: (...args: Args) => B,
+    f2: (...args: Args) => C
+  ): (...args: Args) => B | C;
+
+  declare function isEmpty<A>(x: ?$ReadOnlyArray<A> | { ... } | string): boolean;
+
+  declare function not(x: boolean): boolean;
+
+  declare function or<X, Y>(x: X): (y: Y) => X | Y;
+  declare function or<X, Y>(x: X, y: Y): X | Y;
+
+  declare var pathSatisfies: CurriedFunction3<
+    UnaryPredicateFn<mixed>,
+    $ReadOnlyArray<string | number>,
+    { ... },
+    boolean
+  >;
+
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+  ): ((prop:  K) => (o: T) => boolean) &
+    ((prop:  K, o: T) => boolean);
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+    prop: K,
+  ): (o: T) => boolean;
+  declare function propSatisfies<T, K>(
+    cond: (x: $ElementType<T, K>) => boolean,
+    prop: K,
+    o: T
+  ): boolean;
+
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+  ): (x: T | S) => V | T;
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: T) => T) => (x: T) => T) &
+    ((fn: (x: T) => T, x: T) => T);
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T,
+  ): (x: T) => T;
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T,
+    x: T
+  ): T;
+
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+  ): (x: T | S) => V | T;
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_cjs_modules.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_cjs_modules.js
new file mode 100644
index 0000000000..0978170a45
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_cjs_modules.js
@@ -0,0 +1,41 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+const _ = require("ramda");
+const { compose, match, toLower, trim, zipWith } = _;
+
+// $FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const zipped: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3],
+  ["1", "2", "3"]
+);
+const zipped2: Array<{
+  s: number,
+  y: string,
+  ...
+}> = zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3]
+)(["1", "2", "3"]);
+const zipped3: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith((a, b) => ({
+  s: a,
+  y: b
+}))([1, 2, 3])(["1", "2", "3"]);
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_compose.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_compose.js
new file mode 100644
index 0000000000..e2d39f1915
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_compose.js
@@ -0,0 +1,31 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { compose } from 'ramda';
+
+const f1 = (a: number): number => 1;
+
+describe("compose()", () => {
+  describe('call "compose" with different number of arguments', () => {
+    it('rises an error when more then 10 arguments', () => {
+      // $FlowExpectedError - compose can't take more than 10 arguments
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when 10 arguments are provided', () => {
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when less than 10 arguments are provided', () => {
+      compose(f1, f1, f1, f1, f1, f1, f1, f1, f1)(1);
+    });
+
+    it('should pass when 1 argument is provided', () => {
+      compose(f1)(1);
+    });
+
+    it('raises and error when no argument is provided', () => {
+      // $FlowExpectedError - compose needs at least one argument
+      compose()(1);
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_es_modules.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_es_modules.js
new file mode 100644
index 0000000000..bd79f5724c
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_es_modules.js
@@ -0,0 +1,14 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, match, toLower, trim } from "ramda";
+
+//$FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_filter.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_filter.js
new file mode 100644
index 0000000000..ddd0ef0d00
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_filter.js
@@ -0,0 +1,94 @@
+// @flow
+import R, { filter, type RefineFilter } from "ramda";
+import { it, describe } from "flow-typed-test";
+
+describe("filter", () => {
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<number> = filter(x => x > 1, [1, 2]);
+  });
+
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<string> = R.filter(x => x === "2", ["2", "3"]);
+  });
+
+  it("filters objects by passing the value to the predicate", () => {
+    const s: { [key: string]: string, ... } = R.filter(x => x === "2", {
+      a: "2",
+      b: "3"
+    });
+  });
+
+  it("refines the element type using the predicate", () => {
+    const notNull = (x): boolean %checks => x != null;
+    const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null]);
+  });
+
+  it("fails when type refinement is incorrect", () => {
+    const isString = (x): boolean %checks => typeof x === "string";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isString, ["1", 2]);
+  });
+
+  it("fails when attempting to refine from a non $Pred predicate", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = filter(isNumber, ["1", 2]);
+  });
+
+  it("does not accept predicates missing %checks when using RefineFilter", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isNumber, ["1", 2]);
+  });
+
+  describe("read only", () => {
+    it("should return readonly Array<number>", () => {
+      const readOnlyArrNumbers: $ReadOnlyArray<number> = Object.freeze([1, 2, 3]);
+
+      const result1 = filter(x => x > 1, readOnlyArrNumbers);
+      (result1: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result1: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: Array<number>);
+
+      const result2 = filter(x => x > 1)(readOnlyArrNumbers);
+
+      (result2: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result2: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: Array<number>);
+    });
+
+    it("should return readonly Object", () => {
+      type O = {| key: number |};
+      const readOnlyObj: { +[k: string]: O, ... } = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        ),
+        readOnlyObj
+      ): $ReadOnly<{ [k: string]: O, ... }>);
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        )
+      )(readOnlyObj): { +[k: string]: O, ... });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_functions.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_functions.js
new file mode 100644
index 0000000000..8b3877c21d
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_functions.js
@@ -0,0 +1,421 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, pipe, uncurryN, curry, tryCatch, applyTo } from "ramda";
+// Function
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// TODO: "Gap" Functions: Started failing in v31...
+// const g = _.propIs
+// const __ = _.__
+// const g1: boolean = g(1, '2', {p: 3})
+// const g2: boolean = g(__, '2', {p: 3})(1)
+// const g3: boolean = g(__, __, {p: 3})(1)('2')
+// const g4: boolean = g(__, __, {p: 3})(1, '2')
+// const g5: boolean = g(__, '2', __)(1, {p: 3})
+// const g6: boolean = g(__, '2')(1)({p: 3})
+// const g7: boolean = g(__, '2')(1, {p: 3})
+// const g8: boolean = g(__, '2')(__, {p: 3})(1)
+
+type R = {
+  sum: number,
+  nested: { mul: number, ... },
+  ...
+};
+// TODO: "Gap" Functions: Started failing in v31...
+// const greet: string = _.replace('{name}', _.__, 'Hello, {name}!')('John')
+const truth: boolean = _.T("ddd");
+const lie: boolean = _.F("ddd");
+const mapIndexed = _.addIndex(_.map);
+
+const mi: Array<string> = mapIndexed((val, idx) => idx + "-" + val, [
+  "f",
+  "o",
+  "o",
+  "b",
+  "a",
+  "r"
+]);
+
+const t: string = _.always("Tee")();
+const app: Array<number> = _.ap([_.multiply(2), _.add(3)], [1, 2, 3]);
+const app1: Array<string | number> = _.ap([_.toString, _.add(3)], [1, 2, 3]);
+
+const nums = [1, 2, 3, -99, 42, 6, 7];
+const applied: number = _.apply(Math.max, nums);
+const spec = {
+  sum: _.add,
+  nested: { mul: _.multiply }
+};
+
+const applyToResult1 = applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult1: string);
+// $FlowExpectedError
+(applyToResult1: number);
+
+const applyToResult2 = applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult2: string);
+// $FlowExpectedError
+(applyToResult2: number);
+
+const getMetrics = _.applySpec(spec);
+const apspec: $Shape<R> = getMetrics(2, 2);
+
+const applyToResult3 = _.applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult3: string);
+// $FlowExpectedError
+(applyToResult3: number);
+
+const applyToResult4 = _.applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult4: string);
+// $FlowExpectedError
+(applyToResult4: number);
+
+const cmp: (x: Object, y: Object) => number = _.comparator(
+  (a, b) => a.age < b.age
+);
+const compf: number = _.compose(_.inc, _.negate)(2);
+
+const fn = compose(_.add);
+const fn1: (n: number) => number = fn(2);
+const add2 = _.compose(_.add(2));
+const four: number = add2(2);
+const str0: Array<string | void> = _.compose(_.match(/2/), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const fn2: (n: number) => (n: number) => number = pipe(_.add);
+const fn3: (n: number) => number = fn2(2);
+const add2p = _.pipe(_.add(2));
+const b: number = add2p(2);
+const fail: string = _.pipe(_.trim)("h");
+const str3: Array<string | void> = _.pipe(_.toLower, _.trim, _.match(/2/))(
+  " 1,2,3 "
+);
+const str4: Array<string> = _.pipe(_.toLower, _.trim, _.split(","))(" 1,2,3 ");
+const str5: string = _.pipe(_.replace("3", "4"), _.toLower, _.trim)(" 1,2,3 ");
+
+// --- Curry ---
+declare var bar1: string => "bar1";
+declare var bar2: (string, number) => "bar2";
+declare var bar6: (string, number, boolean, null, {...}, []) => "bar6";
+
+const foo1 = curry(bar1);
+const foo2 = curry(bar2);
+const foo6 = curry(bar6);
+
+const foo1_1: "bar1" = foo1("");
+const foo2_1: "bar2" = foo2("", 0);
+const foo2_2: "bar2" = foo2("")(0);
+
+const foo6_1: "bar6" = foo6("", 0, true, null, {}, []);
+const foo6_2: "bar6" = foo6("")(0, true, null, {}, []);
+const foo6_3: "bar6" = foo6("", 0)(true, null, {}, []);
+const foo6_4: "bar6" = foo6("", 0, true)(null, {}, []);
+const foo6_5: "bar6" = foo6("", 0, true, null)({}, []);
+const foo6_6: "bar6" = foo6("", 0, true, null, {})([]);
+const foo6_7: "bar6" = foo6("")(0)(true, null, {}, []);
+const foo6_8: "bar6" = foo6("", 0)(true)(null, {}, []);
+const foo6_9: "bar6" = foo6("", 0, true)(null)({}, []);
+const foo6_10: "bar6" = foo6("", 0, true, null)({})([]);
+const foo6_11: "bar6" = foo6("")(0, true)(null, {}, []);
+const foo6_12: "bar6" = foo6("", 0)(true, null)({}, []);
+const foo6_13: "bar6" = foo6("", 0, true)(null, {})([]);
+const foo6_14: "bar6" = foo6("")(0, true, null)({}, []);
+const foo6_15: "bar6" = foo6("", 0)(true, null, {})([]);
+const foo6_16: "bar6" = foo6("")(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error1: "bar6" = foo6(false, 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error1: "bar6" = foo6(false)(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error1: "bar6" = foo6(false, 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error1: "bar6" = foo6(false, 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error1: "bar6" = foo6(false, 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error1: "bar6" = foo6(false, 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error1: "bar6" = foo6(false)(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error1: "bar6" = foo6(false, 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error1: "bar6" = foo6(false, 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error1: "bar6" = foo6(false, 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error1: "bar6" = foo6(false)(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error1: "bar6" = foo6(false, 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error1: "bar6" = foo6(false, 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error1: "bar6" = foo6(false)(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error1: "bar6" = foo6(false, 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error1: "bar6" = foo6(false)(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error2: "bar6" = foo6("", 0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_2_Error2: "bar6" = foo6("")(0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_3_Error2: "bar6" = foo6("", 0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_4_Error2: "bar6" = foo6("", 0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_5_Error2: "bar6" = foo6("", 0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_6_Error2: "bar6" = foo6("", 0, true, "", {})([]);
+// $FlowExpectedError
+const foo6_7_Error2: "bar6" = foo6("")(0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_8_Error2: "bar6" = foo6("", 0)(true)("", {}, []);
+// $FlowExpectedError
+const foo6_9_Error2: "bar6" = foo6("", 0, true)("")({}, []);
+// $FlowExpectedError
+const foo6_10_Error2: "bar6" = foo6("", 0, true, "")({})([]);
+// $FlowExpectedError
+const foo6_11_Error2: "bar6" = foo6("")(0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_12_Error2: "bar6" = foo6("", 0)(true, "")({}, []);
+// $FlowExpectedError
+const foo6_13_Error2: "bar6" = foo6("", 0, true)("", {})([]);
+// $FlowExpectedError
+const foo6_14_Error2: "bar6" = foo6("")(0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_15_Error2: "bar6" = foo6("", 0)(true, "", {})([]);
+// $FlowExpectedError
+const foo6_16_Error2: "bar6" = foo6("")(0, true, "", {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error3: "bar6" = foo6("", 0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_2_Error3: "bar6" = foo6("")(0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_3_Error3: "bar6" = foo6("", 0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_4_Error3: "bar6" = foo6("", 0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_5_Error3: "bar6" = foo6("", 0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_6_Error3: "bar6" = foo6("", 0, true, null, {})("");
+// $FlowExpectedError
+const foo6_7_Error3: "bar6" = foo6("")(0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_8_Error3: "bar6" = foo6("", 0)(true)(null, {}, "");
+// $FlowExpectedError
+const foo6_9_Error3: "bar6" = foo6("", 0, true)(null)({}, "");
+// $FlowExpectedError
+const foo6_10_Error3: "bar6" = foo6("", 0, true, null)({})("");
+// $FlowExpectedError
+const foo6_11_Error3: "bar6" = foo6("")(0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_12_Error3: "bar6" = foo6("", 0)(true, null)({}, "");
+// $FlowExpectedError
+const foo6_13_Error3: "bar6" = foo6("", 0, true)(null, {})("");
+// $FlowExpectedError
+const foo6_14_Error3: "bar6" = foo6("")(0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_15_Error3: "bar6" = foo6("", 0)(true, null, {})("");
+// $FlowExpectedError
+const foo6_16_Error3: "bar6" = foo6("")(0, true, null, {})("");
+
+// $FlowExpectedError
+const foo6_1_Error4: "error" = foo6("", 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error4: "error" = foo6("")(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error4: "error" = foo6("", 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error4: "error" = foo6("", 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error4: "error" = foo6("", 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error4: "error" = foo6("", 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error4: "error" = foo6("")(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error4: "error" = foo6("", 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error4: "error" = foo6("", 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error4: "error" = foo6("", 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error4: "error" = foo6("")(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error4: "error" = foo6("", 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error4: "error" = foo6("", 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error4: "error" = foo6("")(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error4: "error" = foo6("", 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error4: "error" = foo6("")(0, true, null, {})([]);
+
+// -------------
+
+const currfn1: (y: number) => number = _.curryN(
+  2,
+  (x: number, y: number): number => x + y
+)(2);
+
+const flipped: (x: number, y: boolean, z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const flipped2: (x: number, y: boolean) => (z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const obb = {
+  doStuff(x: string, y: number, z: boolean) {
+    return 1;
+  },
+  doLessStuff(x: string, y: number) {
+    return "hello";
+  },
+  doEvenLessStuff(x: string) {
+    return true;
+  }
+};
+const doStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doStuff");
+//$FlowExpectedError
+const doLessStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doLStuff");
+const stuffDone: number = doStuff("dd", 1, true, obb);
+
+const range = _.juxt([_.toString, Math.min, Math.max]);
+const ju: Array<number | string> = range(3, 4, 9, -3);
+
+
+let _memoizeWith = 0;
+const _memoizeWithFactorial = _.memoizeWith(_.identity, n => {
+  _memoizeWith += 1;
+  return _.product(_.range(1, n + 1));
+});
+const memWith: number = _memoizeWithFactorial(5);
+
+const narg: string | number = _.nthArg(1)(1, "b", "c");
+
+const nameIs = ({ first, last }) => `The name's ${last}, ${first} ${last}`;
+const o1: string = _.o(_.toUpper, nameIs)({ first: "James", last: "Bond" });
+const oNum: number = _.o(_.multiply(10), _.add(10))(-4);
+
+const oof: Array<Array<number>> = _.of([42]);
+
+const unap: string = _.unapply(JSON.stringify)(1, 2, 3);
+
+const greetName = name => "Hello " + name;
+
+// Uncurry
+const needs3: string => string => string => string = a => b => c => a + b + c;
+
+//$FlowExpectedError
+const needs3_error1: number = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error2: string => string = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error3: string => string => string = uncurryN(3, needs3)(
+  "",
+  "",
+  ""
+);
+
+const needs3_no_error: string = uncurryN(3, needs3)("", "", "");
+
+// -------------
+
+// --- TryCatch ---
+const tryFn: boolean => string = a => String(a);
+
+const tryFn_2: boolean => boolean = a => a;
+
+const catchFn: (Error, boolean) => string = (e, a) => e.message;
+
+const catchFn_2: (Error, boolean) => boolean = (e, a) => a;
+
+const tc1: string = tryCatch(tryFn, catchFn, true);
+const tc2: boolean => string = tryCatch(tryFn, catchFn);
+const tc3: string = tc2(true);
+//const tc7: string = tryCatch(tryFn)(catchFn)(true);
+const tc4: string = tryCatch(tryFn)(catchFn, true);
+const tc5: string = tryCatch(tryFn)(catchFn)(true);
+
+//$FlowExpectedError
+const tc_error1: boolean = tryCatch(tryFn, catchFn, true);
+//$FlowExpectedError
+const tc_error2: boolean = tryCatch(tryFn, catchFn)(true);
+//$FlowExpectedError
+const tc_error3: boolean = tryCatch(tryFn)(catchFn, true);
+//$FlowExpectedError
+const tc_error4: boolean = tryCatch(tryFn)(catchFn)(true);
+//$FlowExpectedError
+const tc_error5: string = tryCatch(tryFn_2, catchFn, "string");
+//$FlowExpectedError
+const tc_error6: string = tryCatch(tryFn_2, catchFn)("string");
+//$FlowExpectedError
+const tc_error7: string = tryCatch(tryFn_2)(catchFn, "string");
+//$FlowExpectedError
+const tc_error8: string = tryCatch(tryFn_2)(catchFn)("string");
+//$FlowExpectedError
+const tc_error9: string = tryCatch(tryFn_2, catchFn, true);
+//$FlowExpectedError
+const tc_error10: string = tryCatch(tryFn_2, catchFn)(true);
+//$FlowExpectedError
+const tc_error11: string = tryCatch(tryFn_2)(catchFn, true);
+//$FlowExpectedError
+const tc_error12: string = tryCatch(tryFn_2)(catchFn)(true);
+//$FlowExpectedError
+const tc_error13: string = tryCatch(tryFn, catchFn_2, true);
+//$FlowExpectedError
+const tc_error14: string = tryCatch(tryFn, catchFn_2)(true);
+//$FlowExpectedError
+const tc_error15: string = tryCatch(tryFn)(catchFn_2, true);
+//$FlowExpectedError
+const tc_error16: string = tryCatch(tryFn)(catchFn_2)(true);
+
+// -------------
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_list.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_list.js
new file mode 100644
index 0000000000..55d512a20e
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_list.js
@@ -0,0 +1,896 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  type RefineFilter,
+  adjust,
+  append,
+  chain,
+  compose,
+  concat,
+  curry,
+  filter,
+  find,
+  groupBy,
+  includes,
+  last,
+  length,
+  nth,
+  pipe,
+  reduce,
+  repeat,
+  subtract,
+  uniq,
+  without,
+  zipWith
+} from "ramda";
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: number | string, ... }> = [
+  { a: 1, c: "d" },
+  { b: 2 }
+];
+const str: string = "hello world";
+
+// List
+{
+  const xs: Array<number> = _.adjust(2, x => x + 1, ns);
+  const xs1: Array<number> = _.adjust(2, x => x + 1)(ns);
+  //$FlowExpectedError
+  const xs3: Array<string> = _.adjust(2)(x => x + 1)(ns);
+
+  const as: boolean = _.all(x => x > 1, ns);
+  const asf: (s: Array<string>) => boolean = _.any(x => x.length > 1);
+  const as1: boolean = asf(ss);
+
+  const aps: Array<Array<number>> = _.aperture(2, ns);
+  const aps2: Array<Array<string>> = _.aperture(2)(ss);
+
+  const newXs1: Array<number> = _.prepend(1)(ns);
+
+  describe('concat', () => {
+    it('should support array', () => {
+      const r1: Array<number> = concat([4, 5, 6], [1, 2, 3]);
+      const r2: Array<number> = concat([4, 5, 6])([1, 2, 3]);
+    });
+    it('should supports strings', () => {
+      const r1: string = concat("ABC", "DEF");
+      const r2: string = concat("ABC")("DEF");
+    });
+    it('should support readonly arrays', () => {
+      const arr1: $ReadOnlyArray<number> = [4, 5, 6];
+      const arr2: $ReadOnlyArray<string> = ['1', '2', '3'];
+      const r1: Array<number|string> = concat(arr1, arr2);
+      const r2: Array<number|string> = concat(arr1)(arr2);
+
+      // $FlowExpectedError
+      const r3: Array<number> = concat(arr1)(arr2);
+      // $FlowExpectedError
+      const r4: Array<string> = concat(arr1)(arr2);
+    });
+    it('should error when concat array with string', () => {
+      // $FlowExpectedError
+      concat("ABC", ["DEF"]);
+    });
+  });
+
+  const dropxs: Array<string> = _.drop(4, ss);
+  const dropxs1: string = _.drop(3)(str);
+  const dropxs2: Array<string> = _.dropLast(4, ss);
+  const dropxs3: string = _.dropLast(3)(str);
+  const dropxs4: Array<number> = _.dropLastWhile(x => x <= 3, ns);
+  const dropxs5: Array<string> = _.dropRepeats(ss);
+  const dropxs6: Array<number> = _.dropRepeatsWith(_.eqBy(Math.abs), ns);
+  const dropxs7: Array<number> = _.dropWhile(x => x === 1, ns);
+
+  describe('includes', () => {
+    describe('uncurried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = includes(2, xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = includes(2, xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = includes('foo', xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<string> = ['bar']
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = includes(1, xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = includes('foo', 'bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = includes(1, 'bar')
+      })
+    })
+
+    describe('1 arg curried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = includes(2)(xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = includes(2)(xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = includes('foo')(xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = includes('foo')(xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = includes('foo')('bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = includes(1)('bar')
+      })
+    })
+  })
+
+  describe('startsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.startsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is starting in another array', () => {
+      const result: boolean = _.startsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.startsWith%28%5B1%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the starting of an array', () => {
+      const result: boolean = _.startsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.startsWith%28%5B1%2C%202%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.startsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.startsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.startsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  describe('endsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.endsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is ending in another array', () => {
+      const result: boolean = _.endsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.endsWith%28%5B3%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the ending of an array', () => {
+      const result: boolean = _.endsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.endsWith%28%5B2%2C%203%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.endsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.endsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.endsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  const chainxs: number[] = _.chain((n) => [n, n], [1, 2])
+  const chainxs1: number[] = _.chain((n) => [n, n])([1, 2])
+
+  const findxs: ?{ [k: string]: number | string, ... } = _.find(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs1: ?{ [k: string]: number | string, ... } = _.find(_.propEq("a", 4))(
+    os
+  );
+  // Ramda doesn't strictly break if you pass it an object, but it always
+  // returns undefined.
+  // $FlowExpectedError
+  const findObj = find(o => o == "bar", { foo: "bar" });
+
+  const findxs2: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs3: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 4)
+  )(os);
+  const findxs4: number = _.findIndex(_.propEq("a", 2), os);
+  const findxs5: number = _.findIndex(_.propEq("a", 4))(os);
+  const findxs6: number = _.findLastIndex(_.propEq("a", 2), os);
+  const findxs7: number = _.findLastIndex(_.propEq("a", 4))(os);
+
+
+  describe('length', () => {
+    describe('works on', () => {
+      it('empty array', () => {
+        length([])
+      })
+      it('simple array of strings', () => {
+        length(ss)
+      })
+      it('heterogeneous arrays', () => {
+        length([1, '', ss, true, ns])
+      })
+      it('strings', () => {
+        length(str)
+      })
+      it('objects defining numeric .length property', () => {
+        length({length: 12})
+      })
+    })
+    describe('fails on', () => {
+      it('null and undefined', () => {
+        // $FlowExpectedError
+        length(null)
+        // $FlowExpectedError
+        length()
+      })
+      it('types that has no length', () => {
+        // $FlowExpectedError
+        length(123)
+      })
+      it('non-numeric .length property', () => {
+        // $FlowExpectedError
+        length({length: 'size'})
+      })
+    })
+  })
+
+  const s4 = _.find(x => x === "2", ["1", "2"]);
+  //$FlowExpectedError
+  const s5: ?{ [key: string]: string, ... } = _.find(x => x === "2", { a: 1, b: 2 });
+  const s6: number = _.findIndex(x => x === "2", ["1", "2"]);
+  const s7: number = _.findIndex(x => x === "2", { a: "1", b: "2" });
+  const forEachxs = _.forEach(x => console.log(x), ns);
+
+  const forEachObj = _.forEachObjIndexed((value, key) => {}, { x: 1, y: 2 });
+
+  describe('groupBy', () => {
+    it('should work with basic array', () => {
+      const fn = x => `${x}`;
+      const groupedBy: { [k: string]: Array<number>, ... } = groupBy(fn, [1, 2, 3]);
+      const groupedBy1: { [k: string]: Array<string>, ... } = groupBy(fn)(['one', 'two', 'three']);
+    });
+    it('group function should return string', () => {
+      const fn: number => number = x => x;
+
+      // $FlowExpectedError
+      groupBy(fn, [1,2,3]);
+      // $FlowExpectedError
+      groupBy(fn)([1,2,3]);
+    });
+    it('group function param should match array element', () => {
+      const fn: string => string = x => x;
+
+      // $FlowExpectedError
+      groupBy(fn, [1,2,3]);
+      // $FlowExpectedError
+      groupBy(fn)([1,2,3]);
+    });
+    it('should support readonly array', () => {
+      const fn: (number | string) => string = x => `${x}`;
+      const arr: $ReadOnlyArray<number> = [1, 2, 3];
+      const groupedBy: { [k: string]: Array<number>, ... } = groupBy(fn, arr);
+      const arr1: $ReadOnlyArray<number|string> = [1, 'two', 3];
+      const groupedBy1: { [k: string]: Array<number|string>, ... } = groupBy(fn)(arr1);
+
+      const fn1: number => string = x => `${x}`;
+      // $FlowExpectedError
+      groupBy(fn1, arr1);
+      // $FlowExpectedError
+      const groupedBy2: { [k: string]: Array<number> } = groupBy(fn)(arr1);
+    });
+  });
+
+  const groupedWith: Array<Array<number>> = _.groupWith(x => x > 1, ns);
+  const groupedWith1: Array<Array<string>> = _.groupWith(x => x === "one")(ss);
+
+  describe('head', () => {
+    describe('with array', () => {
+      it('should returns MaybeOf element type', () => {
+        const fn = (arr: number[]) => {
+          const xOfXs: ?number = _.head(arr);
+          //$FlowExpectedError
+          const xOfXs: number = _.head(arr);
+        }
+      });
+      it('should works with refinement', () => {
+        const fn = (arr: number[]) => {
+          if (arr.length > 0) {
+            const xOfXs: number = _.head(arr);
+          }
+        }
+      });
+      it('should works with mixed-type arrays', () => {
+        const fn = (arr: Array<number|string>) => {
+          const xOfXs: ?(number|string) = _.head(arr);
+          //$FlowExpectedError
+          const xOfXs: ?number = _.head(arr);
+          if (arr.length > 0) {
+            const xOfXs: number|string = _.head(arr);
+            //$FlowExpectedError
+            const xOfXs: number = _.head(arr);
+          }
+        }
+      });
+    });
+    describe('with string', () => {
+      it('should works', () => {
+        const xOfStr: string = _.head(str);
+      });
+    })
+  });
+
+  const transducer = _.compose(_.map(_.add(1)), _.take(2));
+
+  const txs: Array<number> = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs1: string = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs2: string = _.into([], transducer, ss);
+
+  const ind: number = _.indexOf(1, ns);
+  const ind1: number = _.indexOf(str)(ss);
+  const ind2: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s",
+    os
+  );
+  const ind3: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s"
+  )(os);
+  const ind4: number = _.indexOf(null)(ss);
+
+  const insxs: Array<number> = _.insert(1, 2, ns);
+  const insxs2: Array<string> = _.insert(1, "2", ss);
+
+  const insxs3: Array<number> = _.insertAll(1, [2, 3], ns);
+  // this is disgusting — don't do this :)
+  // Technically it's a tuple with arbitrary size
+  const insxs4: Array<number | boolean | string> = _.insertAll(
+    1,
+    ["2", false],
+    ns
+  );
+  const insxs5: Array<string | number> = _.insertAll(1, [2], ss);
+
+  const joinxs: string = _.join("|", ns);
+
+  const lastxs: ?number = _.last(ns);
+  const laststr: string = _.last(str);
+
+  const lasti: number = _.lastIndexOf(3, [-1, 3, 3, 0, 1, 2, 3, 4]);
+
+  const mapxs: Array<number> = _.map(x => x + 1, ns);
+
+  const someObj: {
+    a: string,
+    b: number,
+    ...
+  } = { a: 'a', b: 2 }
+  const someMap: { [string]: {
+    a: string,
+    b: number,
+    ...
+  }, ... } = { so: someObj }
+  const mapObj: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a)(someMap)
+  const mapObj2: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a, someMap)
+
+  const functor = {
+    x: 1,
+    map(f) {
+      return f(this.x);
+    }
+  };
+
+  // Doesn't typecheck (yet) but at least doesn't break
+  const mapFxs = _.map(_.toString, functor);
+
+  const double = x => x * 2;
+  const dxs: Array<number> = _.map(double, [1, 2, 3]);
+  const dos: $Shape<typeof obj> = _.map(double, obj);
+
+  const appender = (a, b) => [a + b, a + b];
+  const mapacc: [number, Array<number>] = _.mapAccum(appender, 0, ns);
+  const mapacc1: [number, Array<number>] = _.mapAccumRight(appender, 0, ns);
+
+  const nxs: boolean = _.none(x => x > 1, ns);
+
+  describe('append', () => {
+    it('should supports arrays', () => {
+      const appendResult1: Array<number> = append(1, [1, 2, 3]);
+      const appendResult2: Array<string> = append('four')(['one', 'two', 'three']);
+    });
+    it('should works with read-only array', (readOnly: $ReadOnlyArray<number>) => {
+      const appendResult1: $ReadOnlyArray<number> = append(1, readOnly);
+      const appendResult2: $ReadOnlyArray<number> = append(1)(readOnly);
+    });
+    it('should result array element should be correct', () => {
+      const readOnly: $ReadOnlyArray<number> = [1, 2, 3];
+      const appendResult1: $ReadOnlyArray<number|string> = append('s', readOnly);
+      const appendResult2: $ReadOnlyArray<number|string> = append('s')(readOnly);
+
+      //$FlowExpectedError
+      const appendResult3: $ReadOnlyArray<number|null> = append('s', readOnly);
+      //$FlowExpectedError
+      const appendResult4: $ReadOnlyArray<number> = append('s')(readOnly);
+    });
+  });
+
+  const xxxs: Array<number> = _.intersperse(1, [1, 2, 3]);
+
+  const pairxs: [number, string] = _.pair(2, "str");
+
+  const partxs: [Array<string>, Array<string>] = _.partition(includes("s"), [
+    "sss",
+    "ttt",
+    "foo",
+    "bars"
+  ]);
+  const partxs1: [
+    { [k: string]: string, ... },
+    { [k: string]: string, ... }
+  ] = _.partition(includes("s"), { a: "sss", b: "ttt", foo: "bars" });
+
+  describe('pluck', () => {
+    it('should works on array of objects as maps', () => {
+      const arr: Array<{ [string]: number | string, ... }> = [{ a: "1" }, { a: 2 }];
+      const pl: Array<number | string> = _.pluck("a")(arr);
+      const p2: Array<number | string> = _.pluck("b")(arr);
+    });
+    it('should works on array of arrays', () => {
+      const pl: Array<number> = _.pluck(0)([[1, 2], [3, 4]]);
+    });
+    it('should works on array of objects', () => {
+      const arr: Array<{
+        key: number,
+        other?: string,
+        ...
+      }> = [{ key: 42 }, { key: 28, other: 'string' }];
+      const pl: number[] = _.pluck('key', arr);
+    });
+    it('should fails on non existing property', () => {
+      //$FlowExpectedError
+      const pl = _.pluck('notExistingKey', [{ key: 42 }, { key: 28, other: 'string' }]);
+      //$FlowExpectedError
+      const pl = _.pluck('other', [{ key: 42 }, { key: 28, other: 'string' }]);
+    });
+    it('should returns union type of selected property', () => {
+      const arr = [{ key: 42 }, { key: 'string', other: 'string' }];
+      const pl: Array<number | string> = _.pluck('key', arr);
+      //$FlowExpectedError
+      const pl: number[] = _.pluck('key', arr);
+    });
+  });
+
+  const rxs: Array<number> = _.range(1, 10);
+
+  const remxs: Array<string> = _.remove(0, 2, ss);
+  const remxs1: Array<string> = _.remove(0, 2)(ss);
+  const remxs2: Array<string> = _.remove(0)(2)(ss);
+  const remxs3: Array<string> = _.remove(0)(2, ss);
+
+  const ys4: Array<string> = _.repeat("1", 10);
+  const ys5: Array<number> = _.repeat(1, 10);
+
+  // reduce
+  const redxs: number = reduce(_.add, 10, ns);
+  const redxs1: string = reduce(concat, "", ss);
+  const redxs2: Array<string> = reduce<string[], string[]>(concat, [])(_.map(x => [x], ss));
+  // Example used in docs: http://ramdajs.com/docs/#reduce
+  const redxs4: number = reduce(subtract, 0, [1, 2, 3, 4]);
+  // Using accumulator type that differs from the element type (A and B).
+  const redxs5: number = reduce((acc, s) => acc + parseInt(s), 0, [
+    "1",
+    "2",
+    "3"
+  ]);
+
+  const redux6a: number = reduce((acc, s) => _.reduced(acc), 0, ns)
+  const redux6b: number = reduce((acc: number, s: number) => _.reduced(acc), 0, ns)
+  const redxs7: number = reduce(
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(acc),
+    0,
+    ["1", "2", "3"]
+  );
+  // $FlowExpectedError
+  const redxs8: number = reduce(
+    // $FlowExpectedError
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(s),
+    0,
+    ["1", "2", "3"]
+  );
+
+  // Ramda works with $ReadOnlyArray as it is immutable.
+  const readOnlyArray: $ReadOnlyArray<number> = [1, 2, 3, 4];
+  // $ReadOnlyArray with curried permutations:
+  const redxsReadOnly3: number = reduce(subtract, 0, readOnlyArray);
+  const redxsReadOnly2_1: number = reduce(subtract, 0)(readOnlyArray);
+  const redxsReadOnly1_2: number = reduce<number, number>(subtract)(0, readOnlyArray);
+  const redxsReadOnly1_1_1: number = reduce(subtract)(0)(readOnlyArray);
+
+  // $FlowExpectedError reduce will not work with an object.
+  reduce(subtract, 0, { foo: 1, bar: 2 });
+
+  // reduceRight
+  const redrxs1: number = _.reduceRight(_.add, 10, ns);
+  const redrxs2: string = _.reduceRight(concat, "", ss);
+  const redrxs3: Array<string> = _.reduceRight(concat, [])(
+    _.map(x => [x], ss)
+  );
+  const redrxs3a: string = _.reduceRight(
+    //$FlowExpectedError
+    (acc: string, value: number): string => acc,
+    "",
+    ns
+  );
+  const redrxs3b: string = _.reduceRight(
+    (value: number, acc: string): string => acc,
+    "",
+    ns
+  );
+
+  // $FlowExpectedError reduceRight does not support reduced.
+  const redrxs4: number = _.reduceRight(
+    // $FlowExpectedError reduceRight does not support reduced.
+    (acc, n) => acc < 4 ? acc + n : _.reduced(acc),
+    0,
+    ns
+  );
+
+  const scanxs6: Array<number> = _.scan(_.add)(10)(ns);
+  const scanxs7: Array<number> = _.scan(_.add, 10)(ns);
+  const scanxs8: Array<number> = _.scan(_.add)(10, ns);
+  const scanxs9: Array<number> = _.scan(_.add, 10, ns);
+  const scanxs10: Array<string> = _.scan(concat)("")(ss);
+  const scanxs11: Array<string> = _.scan(concat, "")(ss);
+  const scanxs12: Array<string> = _.scan(concat)("", ss);
+  const scanxs13: Array<string> = _.scan(concat, "", ss);
+
+  const reduceToNamesBy = _.reduceBy(
+    (acc, student) => acc.concat(student.name),
+    []
+  );
+  const namesByGrade = reduceToNamesBy(student => {
+    const score = student.score;
+    return score < 65
+      ? "F"
+      : score < 70 ? "D" : score < 80 ? "C" : score < 90 ? "B" : "A";
+  });
+  const students = [
+    { name: "Lucy", score: 92 },
+    { name: "Drew", score: 85 },
+    { name: "Bart", score: 62 }
+  ];
+  const names1: { [k: string]: Array<string>, ... } = namesByGrade(students);
+
+  const isOdd = (acc, x) => x % 2 === 1;
+  const reduceWhile1: number = _.reduceWhile(isOdd, _.add, 0, [1, 3, 5, 60, 777, 800]);
+  const reduceWhile2: number = _.reduceWhile(isOdd, _.add, 111, [2, 4, 6]);
+
+  const spl: Array<string> = _.split(/\./, "a.b.c.xyz.d");
+
+  const spl1: [Array<number>, Array<number>] = _.splitAt(1, [1, 2, 3]);
+  const spl2: [string, string] = _.splitAt(5, "hello world");
+  const spl3: [string, string] = _.splitAt(-1, "foobar");
+  const spl4: Array<Array<number>> = _.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]);
+  const spl5: Array<string> = _.splitEvery(3, "foobarbaz");
+  const spl6: [Array<number>, Array<number>] = _.splitWhen(_.equals(2))([
+    1,
+    2,
+    3,
+    1,
+    2,
+    3
+  ]);
+
+  const slixs: Array<string> = _.slice(0, 2, ss);
+  const slixs1: Array<string> = _.slice(0, 2)(ss);
+  const slixs2: Array<string> = _.slice(0)(2)(ss);
+  const slixs3: Array<string> = _.slice(0)(2, ss);
+
+  const diff = function(a, b) {
+    return a - b;
+  };
+  const sortxs: Array<number> = _.sort(diff, [4, 2, 7, 5]);
+
+  const timesxs: Array<number> = _.times(_.identity, 5);
+
+  const unf: (x: string) => Array<string> = _.unfold(
+    (x: string) => x.length > 10 || [x, x + "0"]
+  );
+  const unf1: Array<number> = _.unfold(x => x > 10 || [x, x + 1], 0);
+  const f = n => (n > 50 ? false : [-n, n + 10]);
+  const unf11: Array<number> = _.unfold(f, 10);
+
+  //$FlowExpectedError
+  const unf2 = _.unfold(x => x.length > 10 || [x, x + "0"], 2);
+
+  const unby: Array<number> = _.uniqBy(Math.abs)([-1, -5, 2, 10, 1, 2]);
+
+  const strEq = _.eqBy(String);
+  const strEq2 = _.eqBy(String, 1, 2);
+  const unw = _.uniqWith(strEq)([1, "1", 2, 1]);
+  const unw1 = _.uniqWith(strEq)([{}, {}]);
+  const unw2 = _.uniqWith(strEq)([1, "1", 1]);
+  const unw3 = _.uniqWith(strEq)(["1", 1, 1]);
+
+  //$FlowExpectedError
+  const ys6: { [key: string]: string, ... } = _.fromPairs([["h", 2]]);
+
+  describe('without', () => {
+    it('should work with basic array', () => {
+      const arr1: Array<number> = without([1, 2], [1, 2, 3, 4, 5]);
+      const arr2: Array<string> = without(['a'])(['a', 'b', 'c']);
+    });
+    it('should fail when first list does not match second list type', () => {
+      // $FlowExpectedError
+      const arr1: Array<number> = without(['1', '2'], [1, 2, 3, 4, 5]);
+      // $FlowExpectedError
+      const arr2: Array<string> = without([1])(['a', 'b', 'c']);
+    });
+    it('should work with readonly array', () => {
+      const list1: $ReadOnlyArray<number|string> =  [1, 'four', 5];
+      const list2: $ReadOnlyArray<number|string> =  [1, 'two', 3, 'four', 5];
+      const arr1: Array<number|string> = without(list1, list2);
+      const arr2: Array<number|string> = without(list1)(list2);
+    });
+    it('should list1 be a subset of list2', () => {
+      const list1: $ReadOnlyArray<number> =  [1, 3, 5];
+      const list2: $ReadOnlyArray<number|string> =  [1, 'four', 5];
+      const arr1: Array<number|string> = without(list1, list2);
+      // $FlowExpectedError
+      const arr2: Array<number> = without(list2, list1);
+    });
+  });
+
+  const xprodxs: Array<[number, string]> = _.xprod([1, 2], ["a", "b", "c"]);
+  const xprodxs1: Array<[boolean, string]> = _.xprod([true, false])(["a", "b"]);
+
+  const zipxs: Array<[number, string]> = _.zip([1, 2, 3], ["a", "b", "c"]);
+
+  //$FlowExpectedError
+  const zipxs1: Array<[number, string]> = _.zip([true, false])(["a", "b"]);
+
+  const zipos: { [k: string]: number, ... } = _.zipObj(["a", "b", "c"], [1, 2, 3]);
+
+  const ys9: { [k: string]: number, ... } = _.zipObj(["me", "you"], [1, 2]);
+  const zipped: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3],
+    ["1", "2", "3"]
+  );
+  const zipped2: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3]
+  )(["1", "2", "3"]);
+  const zipped3: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith((a, b) => ({
+    s: a,
+    y: b
+  }))([1, 2, 3])(["1", "2", "3"]);
+
+  describe('chain', () => {
+    it('should accept read only list as input', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const duplicate = n => [n, n];
+      const result1: Array<string> = chain(duplicate, arr);
+      const result2: Array<string> = chain(duplicate)(arr);
+    });
+
+    it('should fail when input out type mismatch', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const castType = n => (parseInt(n): number);
+      //$FlowExpectedError
+      const result: Array<string> = chain(castType, arr);
+    });
+
+    it('should take second argument as function', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const result: Array<?string> = chain(append, x => x[x.length - 1])(arr)
+    });
+
+    it('should error out when second arugment is function but type mismatches', () => {
+      const arr:$ReadOnlyArray<string> = ['1', '2', '3'];
+      const castType = n => (parseInt(n): number);
+      //$FlowExpectedError
+      const result: Array<string> = chain(append, castType)(arr)
+    });
+  });
+
+  describe('nth', () => {
+    it('should get a maybe type back on input is an array of given types', () => {
+      const nthxs1: ?number = nth(2, [1,2,3]);
+      const nthxs2: ?number = nth(2)([1,2]);
+      const nthxs3: ?number = nth(3)([1,2]);
+      const nthxs4: ?string = nth(2, ["curry"]);
+      const nthxs5: ?string = nth(2)(["curry", "bean"]);
+      const nthxs6: ?string = nth(3)(['foo', 'bar']);
+    });
+
+    it('should get a string back when input is string', () => {
+      const nthxs: string = nth(2)("curry");
+      const nthxs1: string = nth(2, "curry");
+    });
+
+    it('should take read only array as second argument', () => {
+      const readOnlyArray: $ReadOnlyArray<number>  = [1, 2, 3];
+      const nthxs = nth(2)(readOnlyArray)
+      const nthxs1 = nth(2, readOnlyArray)
+    });
+
+    it('should take a mutable array as second arugment', () => {
+      const array: Array<string> = ['foo', 'bar'];
+      const nthxs = nth(1)(array)
+      const nthxs1 = nth(1, array)
+      const nthxs2 = nth(1)(array)
+    });
+
+    it('should take tuple as second argument', () => {
+      const tuple:[number, boolean] = [1, true]
+      const n = nth(0, tuple)
+      const ns = nth(1)(tuple)
+    });
+
+    it('should fail on expecting return type to be a maybe type of the element of the input list', () => {
+      const arr: Array<number> = [1, 2, 3]
+      //$FlowExpectedError
+      const nthxs: ?string = nth(2)(arr);
+      //$FlowExpectedError
+      const nthxs1: ?boolean = nth(1)(arr);
+    });
+
+    it('should fail on expecting return type to mismatch the input array type', () => {
+      const arr: Array<number> = [1, 2, 3]
+      //$FlowExpectedError
+      const nthxs: string = nth(2, arr);
+      //$FlowExpectedError
+      const nthxs1: string = nth(2)(arr);
+      //$FlowExpectedError
+      const nthxs2: string = nth(1, ['foo'])
+      //$FlowExpectedError
+      const nthxs3: number = nth(1, arr);
+      //$FlowExpectedError
+      const nthxs4: number = nth(1)(arr);
+      //$FlowExpectedError
+      const nthxs5: number = nth(1, [1])
+      //$FlowExpectedError
+      const nthxs: ?number = nth(2)(['foo']);
+    });
+
+    it('should fail on passing a non-number to first argument', () => {
+      //$FlowExpectedError
+      const nthxs = nth('foo')(['foo', 'bar'])
+    });
+
+    it('should fail on passing a non-array to second argument', () => {
+      //$FlowExpectedError
+      const nthxs = nth(2)({})
+    });
+  });
+
+  describe('adjust', () => {
+    it('should allow both Array and $ReadOnlyArray output', () => {
+      const arr: Array<number> = [1, 2, 3]
+      const ro: $ReadOnlyArray<number> = [1, 2, 3]
+      const result: $ReadOnlyArray<number> = adjust(1, x => x + 1, arr)
+      const result1: Array<number> = adjust(1, x => x + 1, arr)
+      const result2: $ReadOnlyArray<number> = adjust(1, x => x + 1, ro)
+      const result3: Array<number> = adjust(1, x => x + 1, ro)
+    });
+  });
+
+  describe('uniq', () => {
+    it('should accept read only array', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      const result:$ReadOnlyArray<number> = uniq(readOnlyNumbers);
+    });
+
+    it('should fail when element type mismatches', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      //$FlowExpectedError
+      const result:$ReadOnlyArray<string> = uniq(readOnlyNumbers);
+
+      const mix = ['1', 2, true];
+      //$FlowExpectedError
+      const result: $ReadOnlyArray<string> = uniq(mix);
+    });
+
+    it('should accept read only array when expecting mutable array as output', () => {
+      const readOnlyNumbers: $ReadOnlyArray<number> = [1,1,2,3,4,3];
+      const result: Array<number> = uniq(readOnlyNumbers);
+    });
+
+    it('should accept mutable array as input and read only array as output', () => {
+      const readOnlyStrings: Array<string> = ['foo', 'bar'];
+      const result1: $ReadOnlyArray<string> = uniq(readOnlyStrings)
+    });
+
+    it('should accept mutable array', () => {
+      const arr: Array<string> = ['1', '2', '3'];
+      const result: Array<string> = uniq(arr);
+    });
+
+    it('should accept a mixed element type array', () => {
+      const arr: Array<string|number|boolean> = ['foo', 1, false]
+      const result: Array<string|number|boolean> = uniq(arr)
+    });
+
+    //Reason not to test the other way around, namely, Array<A> to $ReadOnlyArray<A> is because
+    //$ReadOnlyArray is a supertype of Array https://flow.org/en/docs/types/arrays/#toc-readonlyarray
+  })
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_logic.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_logic.js
new file mode 100644
index 0000000000..e909102721
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_logic.js
@@ -0,0 +1,319 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { describe, it } from 'flow-typed-test';
+import _, {
+  complement,
+  compose,
+  curry,
+  filter,
+  find,
+  ifElse,
+  pipe,
+  repeat,
+  zipWith,
+} from 'ramda';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ['one', 'two', 'three', 'four'];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: 'd' };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: 'd' }, { b: 2 }];
+const str: string = 'hello world';
+
+//Logic
+// TODO: Fix flow issues
+// const isQueen = _.propEq("rank", "Q");
+// const isSpade = _.propEq("suit", "♠︎");
+// const isQueenOfSpades = _.allPass([isQueen, isSpade]);
+
+//$FlowExpectedError
+const allp: boolean = isQueenOfSpades(1);
+const allp1: boolean = isQueenOfSpades({ rank: 'Q', suit: '♣︎' });
+
+const a: boolean = _.and(true, true);
+const a_: (a: boolean) => boolean = _.and(true);
+
+const nonBooleanAnd: number = _.and(69, 42);
+const nonBooleanAnd_: (nonBooleanAnd: number) => any = _.and(69);
+
+const gte = _.anyPass([_.gt, _.equals]);
+const ge: boolean = gte(3, 2);
+
+//$FlowExpectedError
+const gt10 = x => x > 10;
+//$FlowExpectedError
+const even = x => x % 2 === 0;
+const f = _.both(gt10, even);
+
+const b: boolean = f('');
+const b_: boolean = f(100);
+
+const fn = _.cond([
+  [_.equals(0), _.always('water freezes at 0°C')],
+  [_.equals(100), _.always(1)],
+  [_.T, temp => 'nothing special happens at ' + temp + '°C'],
+]);
+const cond_: number | string = fn(0);
+
+// This is abit awkward — if a non-null value of type
+// differrent to number is passed flow will infer a union type
+// for all of them
+const defaultTo42 = _.defaultTo(42);
+const def: number = defaultTo42(null);
+const def1: number = defaultTo42(undefined);
+
+const feither = _.either(gt10, even);
+const feitherR: boolean = f(101);
+
+describe('complement', () => {
+  it('accepts a function that returns a boolean', () => {
+    complement(() => true)
+    complement(() => false)
+    // $FlowExpectedError
+    complement(() => 'foo')
+    // $FlowExpectedError
+    complement(() => 5)
+    // $FlowExpectedError
+    complement(() => [])
+    // $FlowExpectedError
+    complement(() => ({}))
+    // $FlowExpectedError
+    complement(() => null)
+    // $FlowExpectedError
+    complement(() => undefined)
+  })
+
+  it('returns a function that returns a boolean', () => {
+    const fn = complement(() => true)
+    const b: boolean = fn()
+    // $FlowExpectedError
+    const s: string = fn()
+    // $FlowExpectedError
+    const n: number = fn()
+    // $FlowExpectedError
+    const xs: Array<mixed> = fn()
+    // $FlowExpectedError
+    const obj: {[string]: mixed} = fn()
+    // $FlowExpectedError
+    const v: void = fn()
+    // $FlowExpectedError
+    const nil: null = fn()
+  })
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement test cases.
+  it('returns a function whose parameters match the input function (0)', () => {
+    const fn = complement(() => true)
+    fn()
+    // Extra arguments are discarded, so there is no negative case here.
+  })
+
+  it('returns a function whose parameters match the input function (1)', () => {
+    const fn = complement((a: 'a',) => true)
+    fn('a',)
+    // $FlowExpectedError
+    fn(0)
+  })
+
+  it('returns a function whose parameters match the input function (2)', () => {
+    const fn = complement((a: 'a', b: 'b',) => true)
+    fn('a', 'b',)
+    // $FlowExpectedError
+    fn(0, 1)
+  })
+
+  it('returns a function whose parameters match the input function (3)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c',) => true)
+    fn('a', 'b', 'c',)
+    // $FlowExpectedError
+    fn(0, 1, 2)
+  })
+
+  it('returns a function whose parameters match the input function (4)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd',) => true)
+    fn('a', 'b', 'c', 'd',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3)
+  })
+
+  it('returns a function whose parameters match the input function (5)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e',) => true)
+    fn('a', 'b', 'c', 'd', 'e',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4)
+  })
+
+  it('returns a function whose parameters match the input function (6)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5)
+  })
+
+  it('returns a function whose parameters match the input function (7)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6)
+  })
+
+  it('returns a function whose parameters match the input function (8)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7)
+  })
+
+  it('returns a function whose parameters match the input function (9)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8)
+  })
+
+  it('returns a function whose parameters match the input function (10)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i', j: 'j',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+  })
+
+  // End generated complement test cases.
+})
+
+
+describe('ifElse', () => {
+  it('uses a union of both branches as the return type', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    const ie: number | string = incCount(1);
+  })
+
+  it('checks the condition input matches the branch inputs', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    // Because the object literal ({}) isn't a number it
+    // $FlowExpectedError
+    const ie: number | string = incCount({});
+  })
+
+  it('works with variadic arg inputs', () => {
+    const ifElseFn = ifElse(
+      // Without this test, variadic argument input functions will produce an
+      // error like this:
+      //
+      // Cannot call `ifElse` because rest array [1] has an unknown number of
+      // elements, so is incompatible with tuple type [2].
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    const result: void | string = ifElseFn('input')
+  })
+
+  it('preserves the types used with variadic argument condition functions', () => {
+    const ifElseFn = ifElse(
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    // $FlowExpectedError
+    const result: void | string = ifElseFn(5)
+  })
+
+  // This was the original test for ifElse, which depends on the implementation
+  // of "is". "is" in its present form does not perform type refinement, so the
+  // stricter form of ifElse fails the check with this test. This test below
+  // captures the issue, and is left for reference and/or if some brave soul
+  // wishes to expand the definition of ifElse (and possibly also "is") to
+  // refine the predicate correctly. At time of writing, $Pred and $Refine are
+  // considered experimental/internal and abandoned:
+  // https://github.com/facebook/flow/issues/2464#issuecomment-471115953
+  //
+  // it('feeds a predicate-refined type to the branches', () => {
+  //   const incCount = ifElse(is(Number), x => x + 1, x => x.toString());
+  //   const ie: number | string = incCount(1);
+  // })
+})
+
+const em: boolean = _.isEmpty([1, 2, 3]);
+
+const n: boolean = _.not(true);
+//$FlowExpectedError
+const n1: boolean = _.not(1);
+
+const oor: boolean = _.or(true, true);
+
+const nonBooleanOr: ?string = _.or('watskeburt', undefined);
+const nonBooleanOr_: (arg: { key: string, ... }) => string | { key: string, ... } = _.or(
+  'watskeburt'
+);
+
+// type refinement is important here
+// which might be awkward for some
+// but can actually catch some bugs statically
+
+const psatE: boolean = _.pathSatisfies(y => y > 0, ['x', 'y', 0], {
+  x: { y: [2] },
+});
+const psat: boolean = _.pathSatisfies(
+  y => typeof y === 'number' && y > 0,
+  ['x', 'y', 0],
+  { x: { y: [2] } }
+);
+const psatPart = _.pathSatisfies(y => typeof y === 'number' && y > 0);
+const psat2: boolean = psatPart(['x', 'y', 0])({ x: { y: 2 }, z: true });
+const psatPart2 = _.pathSatisfies(y => typeof y === 'number' && y > 0, [
+  'x',
+  'y',
+  0,
+]);
+const psat3: boolean = psatPart2({ x: { y: 2 }, z: true });
+
+describe('propSatisfies', () => {
+  describe('with object', () => {
+    it('should works with object', () => {
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'x', { x: 1, y: 2 });
+    });
+    it('should works with object with properties of different types', () => {
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'x', { x: 1, y: 2, str: 'different type' });
+      // same again but this time using a curried function
+      const propSatCurry: boolean = _.propSatisfies((x: number) => x > 0, 'x')({ x: 1, y: 2, str: 'different type' });
+    });
+    it('should error when property does not exist', () => {
+      //$FlowExpectedError
+      const propSat3: boolean = _.propSatisfies((x: number) => x > 0, 'z', { x: 1, y: 2 });
+    });
+    it('should error when condition param does not match property type', () => {
+      //$FlowExpectedError
+      const propSat: boolean = _.propSatisfies(x => x > 0, 'str', { x: 1, y: 2, str: 'different type' });
+      //$FlowExpectedError
+      const propSatCurry: boolean = _.propSatisfies((x: number) => x > 0, 'str')({ x: 1, y: 2, str: 'different type' });
+    });
+  });
+  describe('with object as maps', () => {
+    const o: { [string]: number, ... } = { x: 1, y: 2 };
+    it('should works with object map', () => {
+      const propSat: boolean = _.propSatisfies((x: number) => x > 0, 'x', o);
+    });
+    it('should error when condition param does not match property type', () => {
+      //$FlowExpectedError
+      const propSat2: boolean = _.propSatisfies((x: string) => x > 0, 'x', o);
+    });
+  });
+});
+
+const coerceArray = _.unless(_.is(Array), _.of);
+const coer: Array<number | Array<number>> | number = coerceArray([1, 2, 3]);
+const coer1: Array<number | Array<number>> | number = coerceArray(1);
+
+const coerceString = _.unless(_.is(String), _.toString);
+const coer2: string | Array<number> = coerceString([1, 2, 3]);
+const coer3: string | Array<number> = coerceString('s');
+
+const unlPrt = _.unless(_.is(Number), _.T);
+const unl: number | boolean | Array<number> = unlPrt([1, 2, 3]);
+const unl2: number | boolean | Array<number> = unlPrt(1);
+
+const un: number = _.until(_.gt(100), _.multiply(2))(1);
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_map.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_map.js
new file mode 100644
index 0000000000..0134d30784
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_map.js
@@ -0,0 +1,97 @@
+// @flow
+import * as R from "ramda";
+import { it, describe } from "flow-typed-test";
+
+const NumberToString = (v: number): string => `${v}`;
+
+describe("R.map()", () => {
+  describe("Not read only", () => {
+    it("should return Array<string>", () => {
+      const ArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, ArrNumbers): Array<string>);
+
+      (R.map(NumberToString)(ArrNumbers): Array<string>);
+    });
+
+    it("should return Object {key: number}", () => {
+      const Obj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), Obj): { [key: string]: number, ... });
+
+      (R.map(R.prop("key"))(Obj): { [key: string]: number, ... });
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: Array<number>;
+
+        map<T>(fn: (e: number) => T): Array<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return array string", () => {
+        (R.map(NumberToString, new Index()): Array<string>);
+
+        (R.map(NumberToString)(new Index()): Array<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): Array<string>);
+      });
+    });
+  });
+
+  describe("Read Only", () => {
+    it("should return readonly Array", () => {
+      const readOnlyArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, readOnlyArrNumbers): $ReadOnlyArray<string>);
+
+      (R.map(NumberToString)(readOnlyArrNumbers): $ReadOnlyArray<string>);
+    });
+
+    it("should return readonly Object", () => {
+      const readOnlyObj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+
+      (R.map(R.prop("key"))(readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: $ReadOnlyArray<number>;
+
+        map<T>(fn: (e: number) => T): $ReadOnlyArray<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return read only Array<string>", () => {
+        (R.map(NumberToString, new Index()): $ReadOnlyArray<string>);
+
+        (R.map(NumberToString)(new Index()): $ReadOnlyArray<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): $ReadOnlyArray<string>);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_math.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_math.js
new file mode 100644
index 0000000000..4e47ef7d1f
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_math.js
@@ -0,0 +1,32 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+
+import { describe, it } from 'flow-typed-test';
+import {
+  subtract,
+} from 'ramda'
+
+describe('subtract', () => {
+  it('works with two numbers', () => {
+    const result: number = subtract(1, 2)
+  })
+
+  // To see Ramda working with various date combinations, see:
+
+  it('works with dates to produce a number', () => {
+    const result: number = subtract(new Date(), new Date())
+  })
+
+  it('works with a date and a number to produce a number', () => {
+    const result: number = subtract(new Date(), 1000)
+  })
+
+  it('works with a number and a date to produce a number', () => {
+    const result: number = subtract(1000, new Date())
+  })
+
+  it('does not accept strings as inputs', () => {
+    // $FlowExpectedError
+    const result: number = subtract('foo', 'o')
+  })
+})
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_misc.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_misc.js
new file mode 100644
index 0000000000..f87706e3bd
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_misc.js
@@ -0,0 +1,81 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  compose,
+  pipe,
+  curry,
+  filter,
+  find,
+  isNil,
+  repeat,
+  replace,
+  zipWith
+} from "ramda";
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// Math
+{
+  const partDiv: (a: number) => number = _.divide(6);
+  const div: number = _.divide(6, 2);
+  //$FlowExpectedError
+  const div2: number = _.divide(6, true);
+}
+
+// String
+{
+  const ss: Array<string | void> = _.match(/h/, "b");
+  describe('replace', () => {
+    it('should supports replace by string', () => {
+      const r1: string = replace(",", "|", "b,d,d");
+      const r2: string = replace(",")("|", "b,d,d");
+      const r3: string = replace(",")("|")("b,d,d");
+      const r4: string = replace(",", "|")("b,d,d");
+    });
+    it('should supports replace by RegExp', () => {
+      const r1: string = replace(/[,]/, "|", "b,d,d");
+      const r2: string = replace(/[,]/)("|", "b,d,d");
+      const r3: string = replace(/[,]/)("|")("b,d,d");
+      const r4: string = replace(/[,]/, "|")("b,d,d");
+    });
+    it('should supports replace by RegExp with replacement fn', () => {
+      const fn = (match: string, g1: string): string => g1;
+      const r1: string = replace(/([,])d/, fn, "b,d,d");
+      const r2: string = replace(/([,])d/)(fn, "b,d,d");
+      const r3: string = replace(/([,])d/)(fn)("b,d,d");
+      const r4: string = replace(/([,])d/, fn)("b,d,d");
+    });
+  });
+  const ss2: Array<string> = _.split(",", "b,d,d");
+  const ss1: boolean = _.test(/h/, "b");
+  const s: string = _.trim("s");
+  const x: string = _.head("one");
+  const sss: string = _.concat("H", "E");
+  const sss1: string = _.concat("H")("E");
+  const ssss: string = _.drop(1, "EF");
+  const ssss1: string = _.drop(1)("E");
+  const ssss2: string = _.dropLast(1, "EF");
+  const ys: string = _.nth(2, "curry");
+  const ys1: string = _.nth(2)("curry");
+}
+//Type
+{
+  const x: boolean = _.is(Number, 1);
+  const x1: boolean = isNil(1);
+
+  // should refine type
+  const x1a: ?{ a: number, ... } = { a: 1 };
+  //$FlowExpectedError
+  x1a.a;
+  if (!isNil(x1a)) {
+    x1a.a;
+  }
+
+  const x2: boolean = _.propIs(1, "num", { num: 1 });
+}
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_object.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_object.js
new file mode 100644
index 0000000000..fc86d83f7f
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_object.js
@@ -0,0 +1,654 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { describe, it } from 'flow-typed-test';
+import _, {
+  compose,
+  curry,
+  filter,
+  find,
+  lens,
+  lensProp,
+  lensPath,
+  lensIndex,
+  mergeRight,
+  pipe,
+  over,
+  repeat,
+  set,
+  values,
+  view,
+  zipWith,
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+describe("Object", () => {
+  describe("assoc", () => {
+    it("should return more exact type when passed key hasn't in passed object", () => {
+      (_.assoc("c", "s", { a: 1, b: 2 }): {
+        a: number,
+        b: number,
+        c: string,
+        ...
+      });
+
+      (_.assoc("x", { x1: 11 }, { y: ["y1"] }): {
+        x: { [string]: number, ... },
+        y: Array<string>,
+        ...
+      });
+    });
+
+    it("should return sum types when passed key already has in passed object", () => {
+      (_.assoc("a", "s", { a: 1, b: 2 }): {
+        a: number | string,
+        b: number | string,
+        ...
+      });
+    });
+  });
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's over works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with over because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('over', () => {
+    it('works with lens', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: typeof data = over(l, x => -x, data)
+    })
+
+    it('works with lensIndex', () => {
+      const xs: Array<number> = [1, 2, 3]
+      const result: Array<number> = over(lensIndex(0), x => x + 1, xs)
+    })
+
+    it('works with lensProp', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = over(lensProp('c'), () => true, data)
+    })
+
+    it('works with lensPath', () => {
+      const data = {
+        a: 'foo',
+        b: {
+          d: 4,
+          e: ['h'],
+        },
+        c: true,
+      }
+
+      const result: typeof data = over(lensPath(['b', 'd']), () => 56, data)
+    })
+
+    it('works with lensPath down to level 5', () => {
+      type NestedData = { a: { b: { c: { d: { e: string, ... }, ... }, ... }, ... }, ... };
+      const nestedData: NestedData = {
+        a: {
+          b: {
+            c: {
+              d: {
+                e: 'bar',
+              }
+            }
+          }
+        }
+      }
+
+      const result: NestedData = over(lensPath(['a', 'b', 'c', 'd', 'e']), () => 56, nestedData)
+    })
+
+    it('produces an output type that results from the mapping function and input (object)', () => {
+      type TransformedData = { a: number, ... }
+      const data = {
+        a: 'foo',
+      }
+
+      const result: TransformedData = over(lensProp('a'), s => 0, data)
+    })
+
+    it('requires the lens works with the functor provided (object)', () => {
+      type Data = { a: string, ... }
+      const data: Data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result = over(lensProp('b'), s => s.toUpperCase(), data)
+    })
+
+    it('requires the mapping function provides the correct type (object)', () => {
+      const data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result = over(lensProp('a'), (s: number) => s + 1, data)
+    })
+
+    it('requires the mapping function provides the correct type (non-object)', () => {
+      const xs: Array<number> = [1, 2, 3]
+      // $FlowExpectedError
+      const result: Array<number> = over(lensIndex(0), (x: string) => x.toUpperCase(), xs)
+    })
+
+    it('should be curried', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = over(lensProp('c'), () => true, data)
+      const result1: typeof data = over(lensProp('c'))(() => true, data)
+      const result2: typeof data = over(lensProp('c'))(() => true)(data)
+      const result3: typeof data = over(lensProp('c'))(() => true, data)
+    });
+  })
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's set works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with set because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('set', () => {
+    it('works with lens', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: typeof data = set(l, 3, data)
+    })
+
+    it('works with lensIndex', () => {
+      const xs: Array<string> = ['a', 'b', 'c']
+      const result: Array<string> = set(lensIndex(0), 'd', xs)
+    })
+
+    it('works with lensProp', () => {
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const result: typeof data = set(lensProp('c'), true, data)
+    })
+
+    // This scenario doesn't work in the present form.
+    it('produces an output type that results from the mapping function and input (functor)', () => {
+      const data: [number] = [0]
+      // $FlowExpectedError
+      const result: [string] = over(lensIndex(0), 'foo', data)
+    })
+
+    it('requires the lens works with the functor provided (object)', () => {
+      type Data = { a: string, ... }
+      const data: Data = {
+        a: 'foo',
+      }
+
+      // $FlowExpectedError
+      const result: Data = set(lensProp('b'), 'FOO', data)
+    })
+  })
+
+  /**
+   * Normally we don't want to mix our tests with multiple functions (dependent
+   * tests can be difficult to reason about). Ramda's view works specifically
+   * with the various lens types, however.
+   *
+   * lensPath is not covered as cooperating with view because lensPath may not
+   * be expressible in Flow.
+   */
+  describe('view', () => {
+    it('works with lens', () => {
+      type Data = {
+        a: string,
+        b: number,
+        c: boolean,
+        ...
+      }
+      const data = {
+        a: 'foo',
+        b: 4,
+        c: true,
+      }
+
+      const l = lens(x => x.b, (v, d) => ({
+        a: d.a,
+        b: v,
+        c: d.c,
+      }))
+      const result: Data = set(l, 3, data)
+    })
+
+    it('works with lensIndex', () => {
+      type Data = { a: string, ... }
+      const xs: Array<number> = [1, 2, 3]
+      const result: number = view(lensIndex(0), xs)
+    })
+
+    it('works with lensProp', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      const result: string = view(lensProp('a'), data)
+    })
+
+    it('fails when the lensProp refers to a non-existent field', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      // $FlowExpectedError
+      const result: string = view(lensProp('b'), data)
+    })
+
+    it('produces the correct result type', () => {
+      type Data = { a: string, ... }
+      const data = { a: 'foo' }
+      // $FlowExpectedError
+      const result: number = view(lensProp('a'), data)
+    })
+  })
+});
+
+const apath: { [k: string]: number | string | Object, ... } = _.assocPath(
+  ["a", 0, "c"],
+  "s",
+  { a: [ { c: 0 } ] }
+);
+
+const tomato = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 },
+  id: 123
+};
+const tomato1 = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 }
+};
+
+// TODO: Started failing in v31...
+// const transformations = {
+//   firstName: _.trim,
+//   lastName: _.trim,
+//   data: {
+//     elapsed: _.add(1),
+//     remaining: _.add(-1),
+//   },
+// }
+// const evolved:{firstName: string, data: {elapsed: number, remaining: number}, id: number} = _.evolve(transformations, tomato)
+
+const objects = [{}, {}, {}];
+const objectsClone: Array<Object> = _.clone(objects);
+const objectsClone1: number = _.clone(1);
+const objectsClone2: typeof tomato = _.clone(tomato);
+//$FlowExpectedError
+const objectsClone3: $Shape<typeof tomato1> = _.clone(tomato);
+const objectsClone4: $Shape<typeof tomato1> = _.clone(tomato1);
+
+const id = objectsClone2.id;
+//$FlowExpectedError
+const idE = objectsClone4.id;
+
+const dissocd: { a: number, ... } = _.dissoc("b", { a: 1, b: 2 });
+const dissocd2: { a: number, ... } = _.dissoc("b")({ a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd3: { a: string, ... } = _.dissoc("b", { a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd4: { a: string, ... } = _.dissoc("b")({ a: 1, b: 2 });
+
+const dissocPathd: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+const dissocPathd2: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+const dissocPathd3: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c", 0])({
+  a: { b: 1, c: [2] }
+});
+//$FlowExpectedError
+const dissocPathd4: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+//$FlowExpectedError
+const dissocPathd5: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+
+
+const o1 = { a: 1, b: 2, c: 3, d: 4 };
+const o2 = { a: 10, b: 20, c: 3, d: 40 };
+
+const ep: boolean = _.eqProps("a", o1, o2);
+
+// curried versions
+const epCurr: boolean = _.eqProps("a")(o1, o2);
+const ep2: boolean = _.eqProps("c", o1)(o2);
+
+const evolved1 = _.evolve(
+  {
+    foo: x => x + 1,
+    bar: x => x + 2
+  },
+  {
+    foo: 1,
+    bar: 2
+  }
+);
+const evolved2 = _.evolve({
+  foo: x => x + 1,
+  bar: x => x + 2
+})({
+  foo: 1,
+  bar: 2
+});
+const evolved3 = _.evolve(
+  {
+    foo: x => x + 1
+  },
+  {
+    bar: 1
+  }
+);
+const evolved4 = _.evolve({
+  foo: x => x + 1
+})({
+  bar: 1
+});
+//$FlowExpectedError
+const evolved5: number = evolved4.foo;
+//$FlowExpectedError
+const evolved6 = _.evolve(["foo"]);
+
+const has: boolean = _.has("id", tomato);
+const has2: boolean = _.has("id")(tomato);
+
+const hasPath1: boolean = _.hasPath(['a', 'b'], {a: {b: 2}});
+const hasPath2: boolean = _.hasPath(['a', 0, 'c'])({a: [{c: 2}]});
+
+function Rectangle(width, height) {
+  this.width = width;
+  this.height = height;
+}
+Rectangle.prototype.area = function() {
+  return this.width * this.height;
+};
+
+const square = new Rectangle(2, 2);
+const hasIn: boolean = _.hasIn("width", square);
+const hasIn1: boolean = _.hasIn("area", square);
+
+const raceResultsByFirstName = {
+  first: "alice",
+  second: "jake",
+  third: "alice"
+};
+const inverted: { [k: string]: Array<string>, ... } = _.invert(
+  raceResultsByFirstName
+);
+const inverted1: { [k: string]: string, ... } = _.invertObj(raceResultsByFirstName);
+
+const ks: Array<string> = _.keys(raceResultsByFirstName);
+const ksMaybe: Array<string> = _.keys(null)
+const ksi: Array<string> = _.keysIn(square);
+
+const xs = { x: 1, y: 2, z: 3 };
+const prependKeyAndDouble = (num, key, obj) => key + num * 2;
+
+const obI: { [k: string]: string, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+//$FlowExpectedError
+const obI2: { [k: string]: number, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+
+const ob1 = { a: 1 };
+const ob2 = { b: 3 };
+const ob3 = mergeRight(ob1, ob2);
+//$FlowExpectedError
+const propX = ob3.x;
+const propA = ob3.a;
+
+const mLeft: Object = _.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
+const mLeftName: string = mLeft.name;
+const mLeftAge: number = mLeft.age;
+const mLeft2: Object = _.mergeLeft({x: 0})({x: 5, y: 2});
+const mLeftX: number = mLeft2.x;
+const mLeftY: number = mLeft2.y;
+
+type User = {
+  name: string,
+  age: number,
+  ...
+}
+const mRight: User = mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
+const mRightName: string = mRight.name;
+// $FlowExpectedError
+const mRightAge: number = mRight.name;
+type Point = {
+  x: number,
+  y: number,
+  ...
+}
+const mRight2: Point = mergeRight({x: 0, y: 0})({y: 2});
+const mRightX: number = mRight2.x;
+const mRightY: number = mRight2.y;
+
+const mwith = _.mergeWith(
+  (a, b) => Array.isArray(a) && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB: boolean = mwith.b;
+
+const mwithK = _.mergeWithKey(
+  (k, a, b) => Array.isArray(a) && k === "d" && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB1: boolean = mwithK.b;
+
+const mDwith = _.mergeDeepWith(
+  _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propmDwithB: boolean = mDwith.b;
+
+const concatValues = (k, l, r) => k == 'values' ? _.concat(l, r) : r
+const mDwithKey = _.mergeDeepWithKey(
+  concatValues,
+  { a: true, c: { thing: 'foo', values: [10, 20] }},
+  { b: true, c: { thing: 'bar', values: [15, 35] }}
+);
+const propmDwithKeyB: boolean = mDwithKey.b;
+
+const mDLeft = _.mergeDeepLeft(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB2: boolean = mDLeft.a;
+const propB3: boolean = mDLeft.b;
+const propB4: 10 = mDLeft.values[0];
+
+const mDRight = _.mergeDeepRight(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB5: boolean = mDRight.a;
+const propB6: boolean = mDRight.b;
+const propB7: 15 = mDRight.values[0];
+
+const objA = _.objOf("a", false);
+//$FlowExpectedError
+const propAA: number = objA.a;
+
+const om: Object = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4 });
+const omap1 = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4, h: 7 });
+const omap2 = _.omit(["a", "d", "h"])({ a: 1, b: 2, c: 3, d: 4 });
+
+const path1: Object | number = _.path(["a", "b"], { a: { b: 2 } });
+const path2: Object | number = _.path(["a", 1], { a: { "1": 2 } });
+const path3: ?Object = _.path(["a", "b"], { c: { b: 2 } });
+const path4: void = _.path(["a"], null);
+
+const pathOr: string | Object | number = _.pathOr("N/A", ["a", "b", 0], {
+  a: { b: [2] }
+});
+
+describe('pick', () => {
+  it('should works', () => {
+    const pck = _.pick(["a", "d"], { a: 1, b: 2, c: 3, d: '4' });
+    const a: number = pck.a;
+    const d: string = pck.d;
+
+    //$FlowExpectedError
+    const e = pck.e;
+  });
+  it('should fail with not existing props', () => {
+    //$FlowExpectedError
+    const pck = _.pick(["b", "r"], { a: 1, b: 2, c: 3, d: '4' });
+  });
+});
+
+
+const ooo = { a: 1, b: 2, A: 3, B: 4 };
+const isUpperCase = (val, key) => key.toUpperCase() === key;
+const pb: Object = _.pickBy(isUpperCase, ooo);
+
+const ppp: number = _.prop("x", { x: 100 });
+//$FlowExpectedError
+const ppp1: number = _.prop("y", { x: 100 });
+const ppp2: number = _.prop("x")({ x: 100 });
+//$FlowExpectedError
+const ppp3: string = _.prop("x", { x: 100 });
+const ppp4: number = _.prop(_.__, { x: 100 })("x");
+//$FlowExpectedError
+const ppp5: number = _.prop(_.__, { x: 100 })("y");
+const ppp6: number = _.prop("x", ({ x: 1, y: "a" }: {
+  x: number,
+  y: string,
+  ...
+}));
+const ppp7: number = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+//$FlowExpectedError
+const ppp8: string = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+
+const alice = {
+  name: "ALICE",
+  age: 101
+};
+
+const favoriteWithDefault = _.propOr("Ramda", "favoriteLibrary");
+const fav = favoriteWithDefault(alice);
+
+const nameWithDefault = _.propOr("Ramda", "name");
+const nm: number | string = nameWithDefault(alice);
+
+const pss1: Array<number | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+const pss2: Array<number | boolean> = _.props(
+  ["x", "y"],
+  ({ x: true, y: 2, z: "foo" }: {
+  x: boolean,
+  y: number,
+  ...
+})
+);
+const pss3: Array<number> = _.props(["y"], { x: true, y: 2, z: "foo" });
+const pss4: Array<number> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+//$FlowExpectedError -- wrong key
+const pssE1: Array<number | boolean> = _.props(["d", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type
+const pssE2: Array<string | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type on indexer value
+const pssE3: Array<string> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+
+const top: Array<["a" | "b" | "c", number]> = _.toPairs({ a: 1, b: 2, c: 3 });
+
+//$FlowExpectedError
+const topE: Array<["a" | "b" | "c" | "z", number]> = _.toPairs({
+  a: 1,
+  b: 2,
+  c: 3
+});
+
+const F = function() {
+  this.x = "X";
+};
+F.prototype.y = "Y";
+const f = new F();
+const topin = _.toPairsIn(f);
+
+describe('values', () => {
+  it('provides a union per element when the types of all values vary', () => {
+    const val = values({ a: 1, b: 2, c: true });
+    const val1: number | boolean = val[0];
+  })
+
+  it('works with the example in the docs http://ramdajs.com/docs/#values', () => {
+    const vs: Array<number> = values({a: 1, b: 2, c: 3})
+  })
+})
+
+const pred = _.where({
+  a: (a: string) => a === "foo",
+  b: _.complement(_.equals("bar")),
+  c: (c: Object) => !!c,
+  x: _.gt(10),
+  y: _.lt(20),
+});
+
+const w: boolean = pred({ a: "foo", b: "xxx", c: {}, x: 11, y: 19 });
+
+const pred1 = _.whereEq({ a: 1, b: 2 });
+
+const win: boolean = pred1({ a: 1, d: 1 });
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_partial.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_partial.js
new file mode 100644
index 0000000000..531bf883f4
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_partial.js
@@ -0,0 +1,17 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { partial } from "ramda";
+
+// --- Partial ---
+const method1 = (foo: string, bah: number, baz: boolean) => baz;
+
+const partial1: (number, boolean) => boolean = partial(method1, ["foo"]);
+const partial2: boolean = partial(method1, ["foo"])(4, true);
+// $FlowExpectedError
+const partial3 = partial(method1, [4]);
+const partial4: boolean = partial(method1, ["foo", 4])(true);
+const partial5: boolean = partial(method1, ["foo", 4, true])();
+
+// Functions produced from partial are not curried.
+// $FlowExpectedError
+const partial6 = partial(method1, ["foo"])(4);
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_pipe.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_pipe.js
new file mode 100644
index 0000000000..0ccac55966
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_pipe.js
@@ -0,0 +1,224 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { pipe } from "ramda";
+
+// f - function
+// a - argument
+// unf - unary function
+function f1(a1: number): number {
+  return 69;
+}
+
+function f2(a1: number, a2: string): number {
+  return 69;
+}
+
+function f3(a1: number, a2: string, a3: boolean): number {
+  return 69;
+}
+
+function f4(a1: number, a2: string, a3: boolean, a4: number): number {
+  return 69;
+}
+
+function f5(a1: number, a2: string, a3: boolean, a4: number, a5: string): number {
+  return 69;
+}
+
+function unf1(a1: number): string {
+  return "69";
+}
+
+function unf2(a1: string): boolean {
+  return false;
+}
+
+function unf3(a1: boolean): number {
+  return 69;
+}
+
+function unf4(a1: number): string {
+  return "69";
+}
+
+function unf5(a1: string): boolean {
+  return true;
+}
+
+describe("pipe(...fn)", () => {
+  describe('call "pipe" with unary function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f1, unf1, unf3, unf4, unf5)(1);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f1, unf1, unf2, unf3, unf4, unf5)(1): boolean);
+      (pipe(f1, unf1, unf2, unf3, unf4)(1): string);
+      (pipe(f1, unf1, unf2, unf3)(1): number);
+      (pipe(f1, unf1, unf2)(1): boolean);
+      (pipe(f1, unf1)(1): string);
+      (pipe(f1)(1): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f1)(1, "1", true);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f1)();
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with number
+      pipe(f1, unf1)(true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f1, unf1)(1): boolean);
+    });
+  });
+
+  describe('call "pipe" with double function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f2, unf1, unf3, unf4, unf5)(1, "2");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f2, unf1, unf2, unf3, unf4, unf5)(1, "2"): boolean);
+      (pipe(f2, unf1, unf2, unf3, unf4)(1, "2"): string);
+      (pipe(f2, unf1, unf2, unf3)(1, "2"): number);
+      (pipe(f2, unf1, unf2)(1, "2"): boolean);
+      (pipe(f2, unf1)(1, "2"): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f2)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f2)(1);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      pipe(f2, unf1)(1, true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f2, unf1)(1, "2"): boolean);
+    });
+  });
+
+  describe('call "pipe" with triple function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f3, unf1, unf3, unf4, unf5)(1, "2", true);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f3, unf1, unf2, unf3, unf4, unf5)(1, "2", true): boolean);
+      (pipe(f3, unf1, unf2, unf3, unf4)(1, "2", true): string);
+      (pipe(f3, unf1, unf2, unf3)(1, "2", true): number);
+      (pipe(f3, unf1, unf2)(1, "2", true): boolean);
+      (pipe(f3, unf1)(1, "2", true): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f3)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f3)(1, "2");
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - number is incompatible with boolean
+      pipe(f3, unf1)(1, "2", 999);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f3, unf1)(1, "2", true): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 4 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f4, unf1, unf3, unf4, unf5)(1, "2", true, 4);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f4, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1, unf2, unf3, unf4)(1, "2", true, 4): string);
+      (pipe(f4, unf1, unf2, unf3)(1, "2", true, 4): number);
+      (pipe(f4, unf1, unf2)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1)(1, "2", true, 4): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f4)(1, "2", true, 4, "5", 6, false);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f4)(1, "2", true);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - string is incompatible with number
+      pipe(f4, unf1)(1, "2", true, "new number");
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f4, unf1)(1, "2", true, 4): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 5 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f5, unf1, unf3, unf4, unf5)(1, "2", true, 4, "5");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f5, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1, unf2, unf3, unf4)(1, "2", true, 4, "5"): string);
+      (pipe(f5, unf1, unf2, unf3)(1, "2", true, 4, "5"): number);
+      (pipe(f5, unf1, unf2)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): string);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f5)(1, "2", true, 4, "5", 6, 7, 8);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f5)(1, "2", true, 4);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean is incompatible with string
+      pipe(f5, unf1)(1, "2", true, 4, false);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): boolean);
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_relation.js b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_relation.js
new file mode 100644
index 0000000000..19ccf08a1a
--- /dev/null
+++ b/definitions/npm/ramda_v0.27.x/flow_v0.201.x-/test_ramda_v0.27.x_relation.js
@@ -0,0 +1,334 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { it, describe } from "flow-typed-test";
+import _, {
+  ascend,
+  compose,
+  curry,
+  descend,
+  filter,
+  find,
+  gt,
+  gte,
+  intersection,
+  lt,
+  lte,
+  pipe,
+  prop,
+  repeat,
+  sort,
+  zipWith,
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const objArr: { [k: string]: mixed, ... } = { a: 1, b: [1,2,3], c: "d"};
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+const cl: number = _.clamp(1, 10, -1);
+const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
+const letters = _.split("", "abcABCaaaBBc");
+// In ramda docs example it's just `Math.floor`
+// but we don't want the implicit number -> string
+const countB = _.countBy(_.compose(_.toString, Math.floor))(numbers);
+const countB1: { [k: string]: number, ... } = _.countBy(_.toLower)(letters);
+const diff: Array<number> = _.difference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+//$FlowExpectedError
+const diff1: Array<string> = _.difference(
+  ["1", "2", "3", "4"],
+  [7, 6, 5, 4, 3]
+);
+
+const cmp = (x, y) => x.a === y.a;
+const l1 = [{ a: 1 }, { a: 2 }, { a: 3 }];
+const l2 = [{ a: 3 }, { a: 4 }];
+const diff2 = _.differenceWith(cmp, l1, l2);
+
+const eqb: boolean = _.eqBy(Math.abs, 5, -5);
+
+const es: boolean = _.equals([1, 2, 3], [1, 2, 3]);
+
+describe('ascend', () => {
+  /**
+   * In the examples for ascend, its result is plugged into sort. In order
+   * for this to function properly ascend needs to yield a function that can
+   * take two arguments.
+   */
+  it('works as an input to sort', () => {
+    const byAge = ascend(prop('age'));
+    const people = [
+      { name: 'Emma', age: 70 },
+      { name: 'Peter', age: 78 },
+      { name: 'Mikhail', age: 62 },
+    ];
+    const peopleByYoungestFirst = sort(byAge, people);
+  })
+
+  it('returns a curried function', () => {
+    const byAge = ascend(prop('age'))
+    byAge({ name: 'Emma', age: 70 })({ name: 'Peter', age: 78 })
+  })
+})
+
+describe('descend', () => {
+  /**
+   * In the examples for descend, its result is plugged into sort. In order
+   * for this to function properly descend needs to yield a function that can
+   * take two arguments.
+   */
+  it('works as an input to sort', () => {
+    const byAge = descend(prop('age'));
+    const people = [
+      { name: 'Emma', age: 70 },
+      { name: 'Peter', age: 78 },
+      { name: 'Mikhail', age: 62 },
+    ];
+    const peopleByYoungestFirst = sort(byAge, people);
+  })
+
+  it('returns a curried function', () => {
+    const byAge = descend(prop('age'))
+    byAge({ name: 'Emma', age: 70 })({ name: 'Peter', age: 78 })
+  })
+})
+
+describe('gt', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = gt(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = gt(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = gt('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = gt('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    gt('a', 1)
+    // $FlowExpectedError
+    gt(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    gt(() => 1, () => 2)
+  })
+})
+
+describe('gte', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = gte(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = gte(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = gte('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = gte('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    gte('a', 1)
+    // $FlowExpectedError
+    gte(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    gte(() => 1, () => 2)
+  })
+})
+
+describe('lt', () => {
+  it('works with two numbers and produces a bool', () => {
+    const result: bool = lt(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const result: bool = lt(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const result: bool = lt('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const result: bool = lt('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    lt('a', 1)
+    // $FlowExpectedError
+    lt(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    lt(() => 1, () => 2)
+  })
+})
+
+describe('lte', () => {
+  it('works with two numbers and produces a bool', () => {
+    const resulte: bool = lte(2, 1)
+  })
+
+  it('works with two curried numbers and produces a bool', () => {
+    const resulte: bool = lte(2)(1)
+  })
+
+  it('works with two strings and produces a bool', () => {
+    const resulte: bool = lte('a', 'b')
+  })
+
+  it('works with two curried strings and produces a bool', () => {
+    const resulte: bool = lte('a')('b')
+  })
+
+  it('does not work with mixed numbers and strings', () => {
+    // $FlowExpectedError
+    lte('a', 1)
+    // $FlowExpectedError
+    lte(1, 'a')
+  })
+
+  it('does not work with functions', () => {
+    // $FlowExpectedError
+    lte(() => 1, () => 2)
+  })
+})
+
+const _max: number = _.max(2, 1);
+const _min: number = _.min(2, 1);
+
+const _maxBy: number = _.maxBy(Math.abs)(2, 1);
+const _minBy: number = _.minBy(Math.abs, 2, 1);
+
+const _identical: boolean = _.identical(2, 1);
+
+const _innerJoin: Array<{ [k: string]: mixed, ... }> = _.innerJoin(
+  (record, id) => record.id === id,
+  [{id: 824, name: 'Richie Furay'},
+   {id: 956, name: 'Dewey Martin'},
+   {id: 313, name: 'Bruce Palmer'},
+   {id: 456, name: 'Stephen Stills'},
+   {id: 177, name: 'Neil Young'}],
+  [177, 456, 999]
+);
+
+const pathEqObj: boolean = _.pathEq(["b", 1], 1, objArr);
+const pathEqObj2: boolean = _.pathEq(["b", 1])(1)(objArr);
+
+// It's good to test this with multiple params since $Keys<T> is a union.
+type PropEqObj = {
+  bar: number,
+  baz: string,
+  ...
+};
+const propEqObj: PropEqObj = { bar: 2, baz: "qux" };
+
+const isQueen = _.propEq("rank", "Q");
+
+const propEqResult1a: boolean = _.propEq("bar", 1, propEqObj);
+// Test curried versions.
+const propEqResult1b: boolean = _.propEq("bar")(1)(propEqObj);
+const propEqResult1c: boolean = _.propEq("bar")(1, propEqObj);
+const propEqResult1d: boolean = _.propEq("bar", 1)(propEqObj);
+
+// The type compared can be any type just like any other === comparison.
+// Also test the various arities.
+const propEqResult2a: boolean = _.propEq("bar", "always false", propEqObj);
+const propEqResult2b: boolean = _.propEq("bar")("always false")(propEqObj);
+const propEqResult2c: boolean = _.propEq("bar")("always false", propEqObj);
+const propEqResult2d: boolean = _.propEq("bar", "always false")(propEqObj);
+
+// The property name must be a property on the object supplied.
+// $FlowExpectedError
+const propEqResultError: boolean = _.propEq("missing", 1, propEqObj);
+
+// propEq must work with key value pairs.
+const propEqKvp: { [string]: mixed, ... } = { foo: 1, bar: "2", baz: 3 };
+const propEqResult3a: boolean = _.propEq("qux", "value", propEqKvp);
+const propEqResult3b: boolean = _.propEq("qux")("value")(propEqKvp);
+const propEqResult3c: boolean = _.propEq("qux")("value", propEqKvp);
+const propEqResult3d: boolean = _.propEq("qux", "value")(propEqKvp);
+
+// propEq must work with arrays.
+const propEqArray = [1, 2, 3];
+const propEqResult4a: boolean = _.propEq(1, 2, propEqArray);
+const propEqResult4b: boolean = _.propEq(1)(2)(propEqArray);
+const propEqResult4c: boolean = _.propEq(1)(2, propEqArray);
+const propEqResult4d: boolean = _.propEq(1, 2)(propEqArray);
+
+const sortByFirstItem = _.sortBy(([first]) => first);
+const pairs = [[-1, 1], [-2, 2], [-3, 3]];
+const sorted: Array<[number, number]> = sortByFirstItem(pairs);
+
+const sortWithData = [
+  {name: 'alice', age: 40},
+  {name: 'bob', age: 30},
+  {name: 'clara', age: 40}
+];
+const descAge = (l, r) => l.age < r.age ? -1 : 1;
+const ascName = (l, r) => l.name < r.name ? -1 : 1;
+_.sortWith([descAge, ascName], sortWithData);
+_.sortWith([descAge, ascName])(sortWithData);
+
+const eqA = _.eqBy(prop("a"));
+const ls1: Array<{ [k: string]: number, ... }> = [
+  { a: 1 },
+  { a: 2 },
+  { a: 3 },
+  { a: 4 }
+];
+const ls2: Array<{ [k: string]: number, ... }> = [
+  { a: 3 },
+  { b: 4 },
+  { a: 5 },
+  { a: 6 }
+];
+const symW: Array<{ [k: string]: number, ... }> = _.symmetricDifferenceWith(
+  eqA,
+  ls1,
+  ls2
+);
+const sym: Array<number> = _.symmetricDifference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+
+const un: Array<number> = _.union([1, 2, 3])([2, 3, 4]);
+const un1: Array<{ [k: string]: number, ... }> = _.unionWith(eqA, ls1, ls2);
+
+// Given $ReadOnlyArray is super type of Array, no need to test Array -> $ReadOnlyArray case
+describe('intersection', () => {
+  it('should accept read only input', () => {
+    const readOnlyArray: $ReadOnlyArray<number> = [1, 2, 3]
+    const inters1: Array<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters2: Array<number> = intersection(readOnlyArray)(readOnlyArray)
+    const inters3: $ReadOnlyArray<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters4: $ReadOnlyArray<number> = intersection(readOnlyArray)(readOnlyArray)
+  });
+
+  it('should allow mutable array in and out', () => {
+    const readOnlyArray: Array<number> = [1, 2, 3]
+    const inters1: Array<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters2: Array<number> = intersection(readOnlyArray)(readOnlyArray)
+    const inters3: $ReadOnlyArray<number> = intersection(readOnlyArray, readOnlyArray)
+    const inters4: $ReadOnlyArray<number> = intersection(readOnlyArray)(readOnlyArray)
+  });
+})
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/ramda_v0.x.x.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/ramda_v0.x.x.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/ramda_v0.x.x.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/ramda_v0.x.x.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0..x.x_partial.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0..x.x_partial.js
new file mode 100644
index 0000000000..531bf883f4
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0..x.x_partial.js
@@ -0,0 +1,17 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { partial } from "ramda";
+
+// --- Partial ---
+const method1 = (foo: string, bah: number, baz: boolean) => baz;
+
+const partial1: (number, boolean) => boolean = partial(method1, ["foo"]);
+const partial2: boolean = partial(method1, ["foo"])(4, true);
+// $FlowExpectedError
+const partial3 = partial(method1, [4]);
+const partial4: boolean = partial(method1, ["foo", 4])(true);
+const partial5: boolean = partial(method1, ["foo", 4, true])();
+
+// Functions produced from partial are not curried.
+// $FlowExpectedError
+const partial6 = partial(method1, ["foo"])(4);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_cjs_modules.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_cjs_modules.js
new file mode 100644
index 0000000000..0978170a45
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_cjs_modules.js
@@ -0,0 +1,41 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+const _ = require("ramda");
+const { compose, match, toLower, trim, zipWith } = _;
+
+// $FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const zipped: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3],
+  ["1", "2", "3"]
+);
+const zipped2: Array<{
+  s: number,
+  y: string,
+  ...
+}> = zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3]
+)(["1", "2", "3"]);
+const zipped3: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith((a, b) => ({
+  s: a,
+  y: b
+}))([1, 2, 3])(["1", "2", "3"]);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_es_modules.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_es_modules.js
new file mode 100644
index 0000000000..bd79f5724c
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_es_modules.js
@@ -0,0 +1,14 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, match, toLower, trim } from "ramda";
+
+//$FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_filter.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_filter.js
new file mode 100644
index 0000000000..ddd0ef0d00
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_filter.js
@@ -0,0 +1,94 @@
+// @flow
+import R, { filter, type RefineFilter } from "ramda";
+import { it, describe } from "flow-typed-test";
+
+describe("filter", () => {
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<number> = filter(x => x > 1, [1, 2]);
+  });
+
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<string> = R.filter(x => x === "2", ["2", "3"]);
+  });
+
+  it("filters objects by passing the value to the predicate", () => {
+    const s: { [key: string]: string, ... } = R.filter(x => x === "2", {
+      a: "2",
+      b: "3"
+    });
+  });
+
+  it("refines the element type using the predicate", () => {
+    const notNull = (x): boolean %checks => x != null;
+    const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null]);
+  });
+
+  it("fails when type refinement is incorrect", () => {
+    const isString = (x): boolean %checks => typeof x === "string";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isString, ["1", 2]);
+  });
+
+  it("fails when attempting to refine from a non $Pred predicate", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = filter(isNumber, ["1", 2]);
+  });
+
+  it("does not accept predicates missing %checks when using RefineFilter", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isNumber, ["1", 2]);
+  });
+
+  describe("read only", () => {
+    it("should return readonly Array<number>", () => {
+      const readOnlyArrNumbers: $ReadOnlyArray<number> = Object.freeze([1, 2, 3]);
+
+      const result1 = filter(x => x > 1, readOnlyArrNumbers);
+      (result1: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result1: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: Array<number>);
+
+      const result2 = filter(x => x > 1)(readOnlyArrNumbers);
+
+      (result2: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result2: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: Array<number>);
+    });
+
+    it("should return readonly Object", () => {
+      type O = {| key: number |};
+      const readOnlyObj: { +[k: string]: O, ... } = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        ),
+        readOnlyObj
+      ): $ReadOnly<{ [k: string]: O, ... }>);
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        )
+      )(readOnlyObj): { +[k: string]: O, ... });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_functions.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_functions.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_functions.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_functions.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_lensPath.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_lensPath.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_lensPath.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_lensPath.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_list.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_list.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_list.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_list.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_logic.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_logic.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_logic.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_logic.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_map.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_map.js
new file mode 100644
index 0000000000..0134d30784
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_map.js
@@ -0,0 +1,97 @@
+// @flow
+import * as R from "ramda";
+import { it, describe } from "flow-typed-test";
+
+const NumberToString = (v: number): string => `${v}`;
+
+describe("R.map()", () => {
+  describe("Not read only", () => {
+    it("should return Array<string>", () => {
+      const ArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, ArrNumbers): Array<string>);
+
+      (R.map(NumberToString)(ArrNumbers): Array<string>);
+    });
+
+    it("should return Object {key: number}", () => {
+      const Obj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), Obj): { [key: string]: number, ... });
+
+      (R.map(R.prop("key"))(Obj): { [key: string]: number, ... });
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: Array<number>;
+
+        map<T>(fn: (e: number) => T): Array<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return array string", () => {
+        (R.map(NumberToString, new Index()): Array<string>);
+
+        (R.map(NumberToString)(new Index()): Array<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): Array<string>);
+      });
+    });
+  });
+
+  describe("Read Only", () => {
+    it("should return readonly Array", () => {
+      const readOnlyArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, readOnlyArrNumbers): $ReadOnlyArray<string>);
+
+      (R.map(NumberToString)(readOnlyArrNumbers): $ReadOnlyArray<string>);
+    });
+
+    it("should return readonly Object", () => {
+      const readOnlyObj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+
+      (R.map(R.prop("key"))(readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: $ReadOnlyArray<number>;
+
+        map<T>(fn: (e: number) => T): $ReadOnlyArray<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return read only Array<string>", () => {
+        (R.map(NumberToString, new Index()): $ReadOnlyArray<string>);
+
+        (R.map(NumberToString)(new Index()): $ReadOnlyArray<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): $ReadOnlyArray<string>);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_math.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_math.js
new file mode 100644
index 0000000000..4e47ef7d1f
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_math.js
@@ -0,0 +1,32 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+
+import { describe, it } from 'flow-typed-test';
+import {
+  subtract,
+} from 'ramda'
+
+describe('subtract', () => {
+  it('works with two numbers', () => {
+    const result: number = subtract(1, 2)
+  })
+
+  // To see Ramda working with various date combinations, see:
+
+  it('works with dates to produce a number', () => {
+    const result: number = subtract(new Date(), new Date())
+  })
+
+  it('works with a date and a number to produce a number', () => {
+    const result: number = subtract(new Date(), 1000)
+  })
+
+  it('works with a number and a date to produce a number', () => {
+    const result: number = subtract(1000, new Date())
+  })
+
+  it('does not accept strings as inputs', () => {
+    // $FlowExpectedError
+    const result: number = subtract('foo', 'o')
+  })
+})
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_misc.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_misc.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_misc.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_misc.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_object.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_object.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_object.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_object.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_pipe.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_pipe.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_pipe.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_pipe.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_relation.js b/definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_relation.js
similarity index 100%
rename from definitions/npm/ramda_v0.x.x/flow_v0.104.x-/test_ramda_v0.x.x_relation.js
rename to definitions/npm/ramda_v0.x.x/flow_v0.104.x-v.200.x/test_ramda_v0.x.x_relation.js
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/ramda_v0.x.x.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/ramda_v0.x.x.js
new file mode 100644
index 0000000000..9ee4583c1d
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/ramda_v0.x.x.js
@@ -0,0 +1,2220 @@
+/* eslint-disable no-unused-vars, no-redeclare */
+
+type Transformer<A, B> = {
+  '@@transducer/step': <I, R>(r: A, a: any) => R,
+  '@@transducer/init': () => A,
+  '@@transducer/result': (result: any) => B,
+  ...
+};
+
+type Primitives = string | number | null | void | boolean;
+
+declare type $npm$ramda$Placeholder = { '@@functional/placeholder': true, ... };
+
+declare opaque type $npm$ramda$Reduced<T>;
+
+declare module ramda {
+  declare type UnaryFn<A, R> = (a: A) => R;
+  declare type UnaryPromiseFn<A, R> = UnaryFn<A, Promise<R>>;
+  declare type BinaryFn<A, B, R> = ((a: A, b: B) => R) &
+    ((a: A) => (b: B) => R);
+  declare type UnarySameTypeFn<T> = UnaryFn<T, T>;
+  declare type BinarySameTypeFn<T> = BinaryFn<T, T, T>;
+  declare type NestedObject<T> = { [k: string]: T | NestedObject<T>, ... };
+  declare type UnaryPredicateFn<T> = (x: T) => boolean;
+  declare type MapUnaryPredicateFn = <V>(V) => V => boolean;
+  declare type BinaryPredicateFn<T> = (x: T, y: T) => boolean;
+  declare type BinaryPredicateFn2<T, S> = (x: T, y: S) => boolean;
+
+  declare interface ObjPredicate {
+    (value: any, key: string): boolean;
+  }
+
+  declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
+  declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, any>;
+
+  declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
+    ...r: [AA]
+  ) => CurriedFunction1<BB, R>) &
+    ((...r: [AA, BB]) => R);
+  declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, any, any>;
+
+  declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
+    ...r: [AA]
+  ) => CurriedFunction2<BB, CC, R>) &
+    ((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
+    ((...r: [AA, BB, CC]) => R);
+  declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<A, B, C, R, any, any, any>;
+
+  declare type __CurriedFunction4<
+    A,
+    B,
+    C,
+    D,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D
+  > = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
+    ((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
+    ((...r: [AA, BB, CC, DD]) => R);
+  declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<A, B, C, D, R, any, any, any, any>;
+
+  declare type __CurriedFunction5<
+    A,
+    B,
+    C,
+    D,
+    E,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E
+  > = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
+    ((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => R);
+  declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<A, B, C, D, E, R, any, any, any, any, any>;
+
+  declare type __CurriedFunction6<
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    R,
+    AA: A,
+    BB: B,
+    CC: C,
+    DD: D,
+    EE: E,
+    FF: F
+  > = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
+    ((...r: [AA, BB, CC, DD, EE, FF]) => R);
+  declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<A, B, C, D, E, F, R, any, any, any, any, any, any>;
+
+  declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
+    (<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
+    (<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R
+    ) => CurriedFunction4<A, B, C, D, R>) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R
+    ) => CurriedFunction5<A, B, C, D, E, R>) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R
+    ) => CurriedFunction6<A, B, C, D, E, F, R>);
+
+  declare type Partial = (<A, R>((...r: [A]) => R, args: [A]) => () => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A]) => B => R) &
+    (<A, B, R>((...r: [A, B]) => R, args: [A, B]) => () => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A]) => (B, C) => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B]) => C => R) &
+    (<A, B, C, R>((...r: [A, B, C]) => R, args: [A, B, C]) => () => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A]) => (B, C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B]) => (C, D) => R) &
+    (<A, B, C, D, R>((...r: [A, B, C, D]) => R, args: [A, B, C]) => D => R) &
+    (<A, B, C, D, R>(
+      (...r: [A, B, C, D]) => R,
+      args: [A, B, C, D]
+    ) => () => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A]
+    ) => (B, C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B]
+    ) => (C, D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C]
+    ) => (D, E) => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D]
+    ) => E => R) &
+    (<A, B, C, D, E, R>(
+      (...r: [A, B, C, D, E]) => R,
+      args: [A, B, C, D, E]
+    ) => () => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A]
+    ) => (B, C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B]
+    ) => (C, D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C]
+    ) => (D, E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D]
+    ) => (E, F) => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E]
+    ) => F => R) &
+    (<A, B, C, D, E, F, R>(
+      (...r: [A, B, C, D, E, F]) => R,
+      args: [A, B, C, D, E, F]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G) => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F]
+    ) => G => R) &
+    (<A, B, C, D, E, F, G, R>(
+      (...r: [A, B, C, D, E, F, G]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H) => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => H => R) &
+    (<A, B, C, D, E, F, G, H, R>(
+      (...r: [A, B, C, D, E, F, G, H]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => () => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A]
+    ) => (B, C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B]
+    ) => (C, D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C]
+    ) => (D, E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D]
+    ) => (E, F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E]
+    ) => (F, G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F]
+    ) => (G, H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G]
+    ) => (H, I) => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H]
+    ) => I => R) &
+    (<A, B, C, D, E, F, G, H, I, R>(
+      (...r: [A, B, C, D, E, F, G, H, I]) => R,
+      args: [A, B, C, D, E, F, G, H, I]
+    ) => () => R);
+
+  declare var pipe: {
+    <A, B, C, D, E, F, G>(
+      ab: UnaryFn<A, B>,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): UnaryFn<A, G>,
+    <A0, A1, B, C, D, E, F, G>(
+      ab: (A0, A1) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): (A0, A1) => G,
+    <A0, A1, A2, B, C, D, E, F, G>(
+      ab: (A0, A1, A2) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): (A0, A1, A2) => G,
+    <A0, A1, A2, A3, B, C, D, E, F, G>(
+      ab: (A0, A1, A2, A3) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): (A0, A1, A2, A3) => G,
+    <A0, A1, A2, A3, A4, B, C, D, E, F, G>(
+      ab: (A0, A1, A2, A3, A4) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): (A0, A1, A2, A3, A4) => G,
+    <A0, A1, A2, A3, A4, A5, B, C, D, E, F, G>(
+      ab: (A0, A1, A2, A3, A4, A5) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>,
+      fg: UnaryFn<F, G>
+    ): (A0, A1, A2, A3, A4, A5) => G,
+    <A, B, C, D, E, F>(
+      ab: UnaryFn<A, B>,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): UnaryFn<A, F>,
+    <A0, A1, B, C, D, E, F>(
+      ab: (A0, A1) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): (A0, A1) => F,
+    <A0, A1, A2, B, C, D, E, F>(
+      ab: (A0, A1, A2) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): (A0, A1, A2) => F,
+    <A0, A1, A2, A3, B, C, D, E, F>(
+      ab: (A0, A1, A2, A3) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): (A0, A1, A2, A3) => F,
+    <A0, A1, A2, A3, A4, B, C, D, E, F>(
+      ab: (A0, A1, A2, A3, A4) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): (A0, A1, A2, A3, A4) => F,
+    <A0, A1, A2, A3, A4, A5, B, C, D, E, F>(
+      ab: (A0, A1, A2, A3, A4, A5) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>,
+      ef: UnaryFn<E, F>
+    ): (A0, A1, A2, A3, A4, A5) => F,
+    <A, B, C, D, E>(
+      ab: UnaryFn<A, B>,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): UnaryFn<A, E>,
+    <A0, A1, B, C, D, E>(
+      ab: (A0, A1) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): (A0, A1) => E,
+    <A0, A1, A2, B, C, D, E>(
+      ab: (A0, A1, A2) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): (A0, A1, A2) => E,
+    <A0, A1, A2, A3, B, C, D, E>(
+      ab: (A0, A1, A2, A3) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): (A0, A1, A2, A3) => E,
+    <A0, A1, A2, A3, A4, B, C, D, E>(
+      ab: (A0, A1, A2, A3, A4) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): (A0, A1, A2, A3, A4) => E,
+    <A0, A1, A2, A3, A4, A5, B, C, D, E>(
+      ab: (A0, A1, A2, A3, A4, A5) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>,
+      de: UnaryFn<D, E>
+    ): (A0, A1, A2, A3, A4, A5) => E,
+    <A, B, C, D>(
+      ab: UnaryFn<A, B>,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): UnaryFn<A, D>,
+    <A0, A1, B, C, D>(
+      ab: (A0, A1) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): (A0, A1) => D,
+    <A0, A1, A2, B, C, D>(
+      ab: (A0, A1, A2) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): (A0, A1, A2) => D,
+    <A0, A1, A2, A3, B, C, D>(
+      ab: (A0, A1, A2, A3) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): (A0, A1, A2, A3) => D,
+    <A0, A1, A2, A3, A4, B, C, D>(
+      ab: (A0, A1, A2, A3, A4) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): (A0, A1, A2, A3, A4) => D,
+    <A0, A1, A2, A3, A4, A5, B, C, D>(
+      ab: (A0, A1, A2, A3, A4, A5) => B,
+      bc: UnaryFn<B, C>,
+      cd: UnaryFn<C, D>
+    ): (A0, A1, A2, A3, A4, A5) => D,
+    <A, B, C>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>): UnaryFn<A, C>,
+    <A0, A1, B, C>(ab: (A0, A1) => B, bc: UnaryFn<B, C>): (A0, A1) => C,
+    <A0, A1, A2, B, C>(
+      ab: (A0, A1, A2) => B,
+      bc: UnaryFn<B, C>
+    ): (A0, A1, A2) => C,
+    <A0, A1, A2, A3, B, C>(
+      ab: (A0, A1, A2, A3) => B,
+      bc: UnaryFn<B, C>
+    ): (A0, A1, A2, A3) => C,
+    <A0, A1, A2, A3, A4, B, C>(
+      ab: (A0, A1, A2, A3, A4) => B,
+      bc: UnaryFn<B, C>
+    ): (A0, A1, A2, A3, A4) => C,
+    <A0, A1, A2, A3, A4, A5, B, C>(
+      ab: (A0, A1, A2, A3, A4, A5) => B,
+      bc: UnaryFn<B, C>
+    ): (A0, A1, A2, A3, A4, A5) => C,
+    <A, B>(ab: UnaryFn<A, B>): UnaryFn<A, B>,
+    <A0, A1, B>(ab: (A0, A1) => B): (A0, A1) => B,
+    <A0, A1, A2, B>(ab: (A0, A1, A2) => B): (A0, A1, A2) => B,
+    <A0, A1, A2, A3, B>(ab: (A0, A1, A2, A3) => B): (A0, A1, A2, A3) => B,
+    <A0, A1, A2, A3, A4, B>(
+      ab: (A0, A1, A2, A3, A4) => B
+    ): (A0, A1, A2, A3, A4) => B,
+    <A0, A1, A2, A3, A4, A5, B>(
+      ab: (A0, A1, A2, A3, A4, A5) => B
+    ): (A0, A1, A2, A3, A4, A5) => B,
+    ...
+  };
+
+  declare type Pipe = typeof pipe;
+
+  declare type PipeP = (<A, B, C, D, E, F, G>(
+    ab: UnaryPromiseFn<A, B>,
+    bc: UnaryPromiseFn<B, C>,
+    cd: UnaryPromiseFn<C, D>,
+    de: UnaryPromiseFn<D, E>,
+    ef: UnaryPromiseFn<E, F>,
+    fg: UnaryPromiseFn<F, G>
+  ) => UnaryPromiseFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>,
+      ef: UnaryPromiseFn<E, F>
+    ) => UnaryPromiseFn<A, F>) &
+    (<A, B, C, D, E>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>,
+      de: UnaryPromiseFn<D, E>
+    ) => UnaryPromiseFn<A, E>) &
+    (<A, B, C, D>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>,
+      cd: UnaryPromiseFn<C, D>
+    ) => UnaryPromiseFn<A, D>) &
+    (<A, B, C>(
+      ab: UnaryPromiseFn<A, B>,
+      bc: UnaryPromiseFn<B, C>
+    ) => UnaryPromiseFn<A, C>) &
+    (<A, B>(ab: UnaryPromiseFn<A, B>) => UnaryPromiseFn<A, B>);
+
+  declare type Compose = (<A, B, C, D, E, F, G>(
+    fg: UnaryFn<F, G>,
+    ef: UnaryFn<E, F>,
+    de: UnaryFn<D, E>,
+    cd: UnaryFn<C, D>,
+    bc: UnaryFn<B, C>,
+    ab: UnaryFn<A, B>
+  ) => UnaryFn<A, G>) &
+    (<A, B, C, D, E, F>(
+      ef: UnaryFn<E, F>,
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, F>) &
+    (<A, B, C, D, E>(
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, E>) &
+    (<A, B, C, D>(
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>
+    ) => UnaryFn<A, D>) &
+    (<A, B, C>(bc: UnaryFn<B, C>, ab: UnaryFn<A, B>) => UnaryFn<A, C>) &
+    (<A, B>(ab: UnaryFn<A, B>) => UnaryFn<A, B>);
+
+  // This kind of filter allows us to do type refinement on the result, but we
+  // still need Filter so that non-refining predicates still pass a type check.
+  declare type RefineFilter = (<
+    K,
+    V,
+    P: $Pred<1>,
+    T: Array<V> | $ReadOnlyArray<V>
+  >(
+    fn: P,
+    xs: T
+  ) => Array<$Refine<V, P, 1>>) &
+    (<K, V, P: $Pred<1>, T: Array<V> | $ReadOnlyArray<V>>(
+      fn: P
+    ) => (xs: T) => Array<$Refine<V, P, 1>>);
+
+  declare type Filter = (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ) => T) &
+    (<K, V, T: { [key: K]: V, ... } | Array<V>>(
+      fn: UnaryPredicateFn<V>,
+      xs: T
+    ) => T) &
+    (<K, V, T: $ReadOnlyArray<V> | { +[key: K]: V, ... }>(
+      fn: UnaryPredicateFn<V>
+    ) => (xs: T) => T) &
+    (<K, V, T: Array<V> | { [key: K]: V, ... }>(
+      fn: UnaryPredicateFn<V>
+    ) => (xs: T) => T);
+
+  declare interface Monad<A> {
+    chain<B>(f: (A) => Monad<B>): Monad<B>;
+  }
+
+  declare class Semigroup<T> {}
+
+  declare class Chain {
+    chain<T, V: Monad<T> | Array<T>>(fn: (a: T) => V, x: V): V;
+    chain<T, V: Monad<T> | Array<T>>(fn: (a: T) => V): (x: V) => V;
+  }
+
+  declare class GenericContructor<T> {
+    constructor(x: T): GenericContructor<any>;
+  }
+
+  declare class GenericContructorMulti {
+    constructor(...args: Array<any>): GenericContructor<any>;
+  }
+
+  /**
+   * DONE:
+   * Function*
+   * List*
+   * Logic
+   * Math
+   * Object*
+   * Relation
+   * String
+   * Type
+   */
+
+  declare var compose: Compose;
+  declare var pipeK: PipeK;
+  declare var pipeP: PipeP;
+  declare var curry: Curry;
+  declare function curryN(
+    length: number,
+    fn: (...args: Array<any>) => any
+  ): Function;
+
+  // *Math
+  declare var add: CurriedFunction2<number, number, number>;
+  declare var inc: UnaryFn<number, number>;
+  declare var dec: UnaryFn<number, number>;
+  declare var mean: UnaryFn<Array<number>, number>;
+  declare var divide: CurriedFunction2<number, number, number>;
+  declare var mathMod: CurriedFunction2<number, number, number>;
+  declare var median: UnaryFn<Array<number>, number>;
+  declare var modulo: CurriedFunction2<number, number, number>;
+  declare var multiply: CurriedFunction2<number, number, number>;
+  declare var negate: UnaryFn<number, number>;
+  declare var product: UnaryFn<Array<number>, number>;
+  declare var subtract:
+    & CurriedFunction2<number,  number, number>
+    & CurriedFunction2<Date, Date, number>
+    & CurriedFunction2<Date, number, number>
+    & CurriedFunction2<number, Date, number>
+
+  declare var sum: UnaryFn<Array<number>, number>;
+
+  // Filter
+  // To refine with filter, be sure to import the RefineFilter type, and cast
+  // filter to a RefineFilter.
+  // ex:
+  // import { type RefineFilter, filter } from 'ramda'
+  // const notNull = (x): bool %checks => x != null
+  // const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null])
+  declare var filter: RefineFilter & Filter;
+  // reject doesn't get RefineFilter since it performs the opposite work of
+  // filter, and we don't have a kind of $NotPred type.
+  declare var reject: Filter;
+
+  // *String
+  declare var match: CurriedFunction2<RegExp, string, Array<string | void>>;
+  declare var replace: CurriedFunction3<
+    RegExp | string,
+    string | ((substring: string, ...args: Array<string>) => string),
+    string,
+    string
+  >;
+  declare var split: CurriedFunction2<RegExp | string, string, Array<string>>;
+  declare var test: CurriedFunction2<RegExp, string, boolean>;
+  // startsWith and endsWith use the same signature:
+  declare type EdgeWith<A> = (((Array<A>) => (Array<A>) => boolean) &
+    ((Array<A>, Array<A>) => boolean)) &
+    ((string => string => boolean) & ((string, string) => boolean));
+  declare var startsWith: EdgeWith<any>;
+  declare var endsWith: EdgeWith<any>;
+  declare function toLower(a: string): string;
+  declare function toString(x: any): string;
+  declare function toUpper(a: string): string;
+  declare function trim(a: string): string;
+
+  // *Type
+  declare function is<T>(t: T): (v: any) => boolean;
+  declare function is<T>(t: T, v: any): boolean;
+  declare var propIs: CurriedFunction3<any, string, Object, boolean>;
+  declare function type(x: ?any): string;
+  declare function isArrayLike(x: any): boolean;
+
+  declare function isNil(x: mixed): boolean %checks(x === undefined ||
+    x === null);
+
+  // *List
+  declare function adjust<T>(
+    fn: (a: T) => T
+  ): (index: number) => (src: Array<T>) => Array<T>;
+  declare function adjust<T>(
+    fn: (a: T) => T,
+    index: number
+  ): (src: Array<T>) => Array<T>;
+  declare function adjust<T>(
+    fn: (a: T) => T,
+    index: number,
+    src: Array<T>
+  ): Array<T>;
+
+  declare function all<T>(fn: UnaryPredicateFn<T>, xs: Array<T>): boolean;
+  declare function all<T>(fn: UnaryPredicateFn<T>): (xs: Array<T>) => boolean;
+
+  declare function any<T>(fn: UnaryPredicateFn<T>, xs: Array<T>): boolean;
+  declare function any<T>(fn: UnaryPredicateFn<T>): (xs: Array<T>) => boolean;
+
+  declare function aperture<T>(n: number, xs: Array<T>): Array<Array<T>>;
+  declare function aperture<T>(n: number): (xs: Array<T>) => Array<Array<T>>;
+
+  declare function append<E>(x: E, xs: Array<E>): Array<E>;
+  declare function append<E>(x: E): (xs: Array<E>) => Array<E>;
+
+  declare function prepend<E>(x: E, xs: Array<E>): Array<E>;
+  declare function prepend<E>(x: E): (xs: Array<E>) => Array<E>;
+
+  declare function chain<A, B>(f: (x: A) => B[], xs: A[]): B[];
+  declare function chain<A, B>(f: (x: A) => B[]): (xs: A[]) => B[];
+
+  declare function concat<V, T: Array<V>>(x: T, y: T): T;
+  declare function concat<V, T: Array<V>>(x: T): (y: T) => T;
+
+  declare function concat(x: string, y: string): string;
+  declare function concat(x: string): (y: string) => string;
+
+  declare type Contains =
+    & ((string, string) => boolean)
+    & ((string) => ((string => boolean)))
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A) => (b: T) => boolean)
+    & (<A, T: $ReadOnlyArray<A> | Array<A>>(a: A, b: T) => boolean)
+
+  declare var contains: Contains;
+
+  declare function drop<V, T: Array<V> | string>(n: number): (xs: T) => T;
+  declare function drop<V, T: Array<V> | string>(n: number, xs: T): T;
+
+  declare function dropLast<V, T: Array<V> | string>(n: number): (xs: T) => T;
+  declare function dropLast<V, T: Array<V> | string>(n: number, xs: T): T;
+
+  declare function dropLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => T;
+  declare function dropLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): T;
+
+  declare function dropWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => T;
+  declare function dropWhile<V, T: Array<V>>(fn: UnaryPredicateFn<V>, xs: T): T;
+
+  declare function dropRepeats<V, T: Array<V>>(xs: T): T;
+
+  declare function dropRepeatsWith<V, T: Array<V>>(
+    fn: BinaryPredicateFn<V>
+  ): (xs: T) => T;
+  declare function dropRepeatsWith<V, T: Array<V>>(
+    fn: BinaryPredicateFn<V>,
+    xs: T
+  ): T;
+
+  declare function groupBy<T>(
+    fn: (x: T) => string,
+    xs: Array<T>
+  ): { [key: string]: Array<T>, ... };
+  declare function groupBy<T>(
+    fn: (x: T) => string
+  ): (xs: Array<T>) => { [key: string]: Array<T>, ... };
+
+  declare function groupWith<T, V: Array<T> | string>(
+    fn: BinaryPredicateFn<T>,
+    xs: V
+  ): Array<V>;
+  declare function groupWith<T, V: Array<T> | string>(
+    fn: BinaryPredicateFn<T>
+  ): (xs: V) => Array<V>;
+
+  declare function head<T, V: Array<T>>(xs: V): ?T;
+  declare function head<T, V: string>(xs: V): V;
+
+  declare function into<I, T, A: Array<T>, R: Array<any> | string | Object>(
+    accum: R,
+    xf: (a: A) => I,
+    input: A
+  ): R;
+  declare function into<I, T, A: Array<T>, R>(
+    accum: Transformer<I, R>,
+    xf: (a: A) => R,
+    input: A
+  ): R;
+
+  declare function indexOf<E>(x: ?E, xs: Array<E>): number;
+  declare function indexOf<E>(x: ?E): (xs: Array<E>) => number;
+
+  declare function indexBy<V, T: { [key: string]: any, ... }>(
+    fn: (x: T) => string
+  ): (xs: Array<T>) => { [key: string]: T, ... };
+  declare function indexBy<V, T: { [key: string]: any, ... }>(
+    fn: (x: T) => string,
+    xs: Array<T>
+  ): { [key: string]: T, ... };
+
+  declare function insert<T>(
+    index: number
+  ): (elem: T) => (src: Array<T>) => Array<T>;
+  declare function insert<T>(
+    index: number,
+    elem: T
+  ): (src: Array<T>) => Array<T>;
+  declare function insert<T>(index: number, elem: T, src: Array<T>): Array<T>;
+
+  declare function insertAll<T, S>(
+    index: number
+  ): (elem: Array<S>) => (src: Array<T>) => Array<S | T>;
+  declare function insertAll<T, S>(
+    index: number,
+    elems: Array<S>
+  ): (src: Array<T>) => Array<S | T>;
+  declare function insertAll<T, S>(
+    index: number,
+    elems: Array<S>,
+    src: Array<T>
+  ): Array<S | T>;
+
+  declare function join(x: string, xs: Array<any>): string;
+  declare function join(x: string): (xs: Array<any>) => string;
+
+  declare function last<T, V: Array<T>>(xs: V): ?T;
+  declare function last<T, V: string>(xs: V): V;
+
+  declare function none<T>(fn: UnaryPredicateFn<T>, xs: Array<T>): boolean;
+  declare function none<T>(fn: UnaryPredicateFn<T>): (xs: Array<T>) => boolean;
+
+  declare function nth<V, T: Array<V>>(i: number, xs: T): ?V;
+  declare function nth<V, T: Array<V> | string>(
+    i: number
+  ): ((xs: string) => string) & ((xs: T) => ?V);
+  declare function nth<T: string>(i: number, xs: T): T;
+
+  declare type Find = (<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ) => (xs: T) => ?V) &
+    (<V, T: Array<V>>(fn: UnaryPredicateFn<V>, xs: T) => ?V);
+
+  declare var find: Find;
+
+  declare function findLast<V, O: { [key: string]: any, ... }, T: Array<V> | O>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T | O) => ?V | O;
+  declare function findLast<V, O: { [key: string]: any, ... }, T: Array<V> | O>(
+    fn: UnaryPredicateFn<V>,
+    xs: T | O
+  ): ?V | O;
+
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => number;
+  declare function findIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): number;
+  declare function findLastIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => number;
+  declare function findLastIndex<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): number;
+
+  declare function forEach<T, V>(fn: (x: T) => ?V, xs: Array<T>): Array<T>;
+  declare function forEach<T, V>(fn: (x: T) => ?V): (xs: Array<T>) => Array<T>;
+
+  declare function forEachObjIndexed<O: Object, A, B>(
+    fn: (val: A, key: string, o: O) => B,
+    o: { [key: string]: A, ... }
+  ): O;
+
+  declare function forEachObjIndexed<O: Object, A, B>(
+    fn: (val: A, key: string, o: O) => B,
+    ...args: Array<void>
+  ): (o: { [key: string]: A, ... }) => O;
+
+  declare function lastIndexOf<E>(x: E, xs: Array<E>): number;
+  declare function lastIndexOf<E>(x: E): (xs: Array<E>) => number;
+
+  declare var map: {
+    <T, R, R, FN: (x: T) => R, SR, S: { +map: FN => SR, ... }>(fn: FN, xs: S): SR,
+    <T, R, FN: (x: T) => R>(
+      fn: FN
+    ): (<SR, S: { +map: FN => SR, ... }>(xs: S) => SR) &
+      ((xs: { [key: string]: T, ... }) => { [key: string]: R, ... }) &
+      ((xs: { +[key: string]: T, ... }) => { +[key: string]: R, ... }) &
+      ((xs: Array<T>) => Array<R>) &
+      ((xs: $ReadOnlyArray<T>) => $ReadOnlyArray<R>),
+    <T, R>(fn: (x: T) => R, xs: Array<T>): Array<R>,
+    <T, R>(fn: (x: T) => R, xs: $ReadOnlyArray<T>): $ReadOnlyArray<R>,
+    <T, R>(fn: (x: T) => R, xs: { [key: string]: T, ... }): { [key: string]: R, ... },
+    <T, R>(fn: (x: T) => R, xs: { +[key: string]: T, ... }): { +[key: string]: R, ... },
+    ...
+  };
+
+  declare type AccumIterator<A, B, R> = (acc: R, x: A) => [R, B];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: Array<A>
+  ): [R, Array<B>];
+  declare function mapAccum<A, B, R>(
+    fn: AccumIterator<A, B, R>
+  ): (acc: R, xs: Array<A>) => [R, Array<B>];
+
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>,
+    acc: R,
+    xs: Array<A>
+  ): [R, Array<B>];
+  declare function mapAccumRight<A, B, R>(
+    fn: AccumIterator<A, B, R>
+  ): (acc: R, xs: Array<A>) => [R, Array<B>];
+
+  declare function intersperse<E>(x: E, xs: Array<E>): Array<E>;
+  declare function intersperse<E>(x: E): (xs: Array<E>) => Array<E>;
+
+  declare function pair<A, B>(a: A, b: B): [A, B];
+  declare function pair<A, B>(a: A): (b: B) => [A, B];
+
+  declare function partition<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): [T, T];
+  declare function partition<K, V, T: Array<V> | { [key: K]: V, ... }>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => [T, T];
+
+  declare function pluck<
+    V,
+    K: string | number,
+    T: Array<Array<V> | { [key: string]: V, ... }>
+  >(
+    k: K,
+    xs: T
+  ): Array<V>;
+  declare function pluck<
+    V,
+    K: string | number,
+    T: Array<Array<V> | { [key: string]: V, ... }>
+  >(
+    k: K
+  ): (xs: T) => Array<V>;
+
+  declare var range: CurriedFunction2<number, number, Array<number>>;
+
+  declare function reduced<T>(
+    x: T | $npm$ramda$Reduced<T>
+  ): $npm$ramda$Reduced<T>;
+
+  declare function remove<T>(
+    from: number
+  ): ((to: number) => (src: Array<T>) => Array<T>) &
+    ((to: number, src: Array<T>) => Array<T>);
+  declare function remove<T>(
+    from: number,
+    to: number
+  ): (src: Array<T>) => Array<T>;
+  declare function remove<T>(from: number, to: number, src: Array<T>): Array<T>;
+
+  declare function repeat<T>(x: T, times: number): Array<T>;
+  declare function repeat<T>(x: T): (times: number) => Array<T>;
+
+  declare function slice<V, T: Array<V> | string>(
+    from: number
+  ): ((to: number) => (src: T) => T) & ((to: number, src: T) => T);
+  declare function slice<V, T: Array<V> | string>(
+    from: number,
+    to: number
+  ): (src: T) => T;
+  declare function slice<V, T: Array<V> | string>(
+    from: number,
+    to: number,
+    src: T
+  ): T;
+
+  declare function sort<V, T: Array<V>>(fn: (a: V, b: V) => number, xs: T): T;
+  declare function sort<V, T: Array<V>>(
+    fn: (a: V, b: V) => number
+  ): (xs: T) => T;
+
+  declare function sortWith<V, T: Array<V>>(
+    fns: Array<(a: V, b: V) => number>,
+    xs: T
+  ): T;
+  declare function sortWith<V, T: Array<V>>(
+    fns: Array<(a: V, b: V) => number>
+  ): (xs: T) => T;
+
+  declare function descend<A, B>((A) => B): ((A) => A) => number;
+  declare function ascend<A, B>((A) => B): ((A) => A) => number;
+
+  declare function times<T>(fn: (i: number) => T, n: number): Array<T>;
+  declare function times<T>(fn: (i: number) => T): (n: number) => Array<T>;
+
+  declare function take<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function take<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLast<V, T: Array<V> | string>(n: number, xs: T): T;
+  declare function takeLast<V, T: Array<V> | string>(n: number): (xs: T) => T;
+
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): T;
+  declare function takeLastWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => T;
+
+  declare function takeWhile<V, T: Array<V>>(fn: UnaryPredicateFn<V>, xs: T): T;
+  declare function takeWhile<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => T;
+
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean
+  ): (seed: T) => Array<R>;
+  declare function unfold<T, R>(
+    fn: (seed: T) => [R, T] | boolean,
+    seed: T
+  ): Array<R>;
+
+  declare function uniqBy<T, V>(fn: (x: T) => V): (xs: Array<T>) => Array<T>;
+  declare function uniqBy<T, V>(fn: (x: T) => V, xs: Array<T>): Array<T>;
+
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>
+  ): (xs: Array<T>) => Array<T>;
+  declare function uniqWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs: Array<T>
+  ): Array<T>;
+
+  declare function update<T>(
+    index: number
+  ): ((elem: T) => (src: Array<T>) => Array<T>) &
+    ((elem: T, src: Array<T>) => Array<T>);
+  declare function update<T>(
+    index: number,
+    elem: T
+  ): (src: Array<T>) => Array<T>;
+  declare function update<T>(index: number, elem: T, src: Array<T>): Array<T>;
+
+  // TODO `without` as a transducer
+  declare function without<T>(xs: Array<T>, src: Array<T>): Array<T>;
+  declare function without<T>(xs: Array<T>): (src: Array<T>) => Array<T>;
+
+  declare function xprod<T, S>(xs: Array<T>, ys: Array<S>): Array<[T, S]>;
+  declare function xprod<T, S>(xs: Array<T>): (ys: Array<S>) => Array<[T, S]>;
+
+  declare function zip<T, S>(xs: Array<T>, ys: Array<S>): Array<[T, S]>;
+  declare function zip<T, S>(xs: Array<T>): (ys: Array<S>) => Array<[T, S]>;
+
+  declare function zipObj<T: string, S>(
+    xs: Array<T>,
+    ys: Array<S>
+  ): { [key: T]: S, ... };
+  declare function zipObj<T: string, S>(
+    xs: Array<T>
+  ): (ys: Array<S>) => { [key: T]: S, ... };
+
+  declare type NestedArray<T> = Array<T | NestedArray<T>>;
+  declare function flatten<T>(xs: NestedArray<T>): Array<T>;
+
+  declare function fromPairs<T, V>(pair: Array<[T, V]>): { [key: string]: V, ... };
+
+  declare function init<T, V: Array<T> | string>(xs: V): V;
+
+  declare function length<T>(
+    xs: Array<T> | string | { length: number, ... }
+  ): number;
+
+  declare function reverse<T, V: Array<T> | string>(xs: V): V;
+
+  declare type Reduce = (<A, B>(
+    fn: (acc: A, elm: B) => $npm$ramda$Reduced<A> | A
+  ) => ((init: A) => (xs: Array<B> | $ReadOnlyArray<B>) => A) &
+    ((init: A, xs: Array<B> | $ReadOnlyArray<B>) => A)) &
+    (<A, B>(
+      fn: (acc: A, elm: B) => $npm$ramda$Reduced<A> | A,
+      init: A
+    ) => (xs: Array<B> | $ReadOnlyArray<B>) => A) &
+    (<A, B>(
+      fn: (acc: A, elm: B) => $npm$ramda$Reduced<A> | A,
+      init: A,
+      xs: Array<B> | $ReadOnlyArray<B>
+    ) => A);
+
+  declare var reduce: Reduce;
+
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B
+  ): ((
+    acc: B
+  ) => ((
+    keyFn: (elem: A) => string
+  ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... })) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string
+    ) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((
+      acc: B,
+      keyFn: (elem: A) => string,
+      xs: Array<A>
+    ) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B
+  ): ((keyFn: (elem: A) => string) => (xs: Array<A>) => { [key: string]: B, ... }) &
+    ((keyFn: (elem: A) => string, xs: Array<A>) => { [key: string]: B, ... });
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string
+  ): (xs: Array<A>) => { [key: string]: B, ... };
+  declare function reduceBy<A, B>(
+    fn: (acc: B, elem: A) => B,
+    acc: B,
+    keyFn: (elem: A) => string,
+    xs: Array<A>
+  ): { [key: string]: B, ... };
+
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A
+  ): ((init: A, xs: Array<B>) => A) & ((init: A) => (xs: Array<B>) => A);
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A
+  ): (xs: Array<B>) => A;
+  declare function reduceRight<A, B>(
+    fn: (elem: B, acc: A) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function reduceWhile<A, B>(
+    pred: (acc: A, curr: B) => boolean
+  ): ((
+    fn: (a: A, b: B) => A
+  ) => (
+    init: A
+  ) => (
+    xs: Array<B>
+  ) => A & ((fn: (a: A, b: B) => A) => (init: A, xs: Array<B>) => A)) &
+    ((fn: (a: A, b: B) => A, init: A) => (xs: Array<B>) => A) &
+    ((fn: (a: A, b: B) => A, init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    pred: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A
+  ): ((init: A) => (xs: Array<B>) => A) & ((init: A, xs: Array<B>) => A);
+
+  declare function reduceWhile<A, B>(
+    fn: (acc: A, curr: B) => boolean,
+    fn: (a: A, b: B) => A,
+    init: A,
+    xs: Array<B>
+  ): A;
+
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A
+  ): ((init: A, xs: Array<B>) => Array<A>) &
+    ((init: A) => (xs: Array<B>) => Array<A>);
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A
+  ): (xs: Array<B>) => Array<A>;
+  declare function scan<A, B>(
+    fn: (acc: A, elem: B) => A,
+    init: A,
+    xs: Array<B>
+  ): Array<A>;
+
+  declare function splitAt<V, T: Array<V> | string>(i: number, xs: T): [T, T];
+  declare function splitAt<V, T: Array<V> | string>(
+    i: number
+  ): (xs: T) => [T, T];
+  declare function splitEvery<V, T: Array<V> | string>(
+    i: number,
+    xs: T
+  ): Array<T>;
+  declare function splitEvery<V, T: Array<V> | string>(
+    i: number
+  ): (xs: T) => Array<T>;
+  declare function splitWhen<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>,
+    xs: T
+  ): [T, T];
+  declare function splitWhen<V, T: Array<V>>(
+    fn: UnaryPredicateFn<V>
+  ): (xs: T) => [T, T];
+
+  declare function tail<T, V: Array<T> | string>(xs: V): V;
+
+  declare function transpose<T>(xs: Array<Array<T>>): Array<Array<T>>;
+
+  declare function uniq<T>(xs: Array<T>): Array<T>;
+
+  declare function unnest<T>(xs: NestedArray<T>): NestedArray<T>;
+
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R
+  ): ((xs: Array<T>, ys: Array<S>) => Array<R>) &
+    ((xs: Array<T>) => (ys: Array<S>) => Array<R>);
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: Array<T>
+  ): (ys: Array<S>) => Array<R>;
+  declare function zipWith<T, S, R>(
+    fn: (a: T, b: S) => R,
+    xs: Array<T>,
+    ys: Array<S>
+  ): Array<R>;
+
+  // *Relation
+  declare function equals<T>(x: T): (y: T) => boolean;
+  declare function equals<T>(x: T, y: T): boolean;
+
+  declare function eqBy<A, B>(
+    fn: (x: A) => B
+  ): ((x: A, y: A) => boolean) & ((x: A) => (y: A) => boolean);
+  declare function eqBy<A, B>(fn: (x: A) => B, x: A): (y: A) => boolean;
+  declare function eqBy<A, B>(fn: (x: A) => B, x: A, y: A): boolean;
+
+  // Flow cares about the order in which these appear. Generally function
+  // siguatures should go from smallest arity to largest arity.
+  declare type PropEq = (<T>(
+    prop: $Keys<T>
+  ) => ((val: mixed) => (obj: T) => boolean) &
+    ((val: mixed, obj: T) => boolean)) &
+    (<T>(prop: $Keys<T>, val: mixed) => (obj: T) => boolean) &
+    (<T>(prop: $Keys<T>, val: mixed, obj: T) => boolean) &
+    // Array variants.
+    (<T>(
+      prop: number
+    ) => ((val: mixed) => (obj: Array<any>) => boolean) &
+      ((val: mixed, obj: Array<any>) => boolean)) &
+    (<T>(prop: number, val: mixed) => (obj: Array<any>) => boolean) &
+    (<T>(prop: number, val: mixed, obj: Array<any>) => boolean);
+  declare var propEq: PropEq;
+
+  declare function pathEq(
+    path: Array<string>
+  ): ((val: any) => (o: Object) => boolean) &
+    ((val: any, o: Object) => boolean);
+  declare function pathEq(
+    path: Array<string>,
+    val: any
+  ): (o: Object) => boolean;
+  declare function pathEq(path: Array<string>, val: any, o: Object): boolean;
+
+  declare function clamp<T: number | string | Date>(
+    min: T
+  ): ((max: T) => (v: T) => T) & ((max: T, v: T) => T);
+  declare function clamp<T: number | string | Date>(
+    min: T,
+    max: T
+  ): (v: T) => T;
+  declare function clamp<T: number | string | Date>(min: T, max: T, v: T): T;
+
+  declare function countBy<T>(
+    fn: (x: T) => string
+  ): (list: Array<T>) => { [key: string]: number, ... };
+  declare function countBy<T>(
+    fn: (x: T) => string,
+    list: Array<T>
+  ): { [key: string]: number, ... };
+
+  declare function difference<T>(xs1: Array<T>): (xs2: Array<T>) => Array<T>;
+  declare function difference<T>(xs1: Array<T>, xs2: Array<T>): Array<T>;
+
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>
+  ): ((xs1: Array<T>) => (xs2: Array<T>) => Array<T>) &
+    ((xs1: Array<T>, xs2: Array<T>) => Array<T>);
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: Array<T>
+  ): (xs2: Array<T>) => Array<T>;
+  declare function differenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    xs1: Array<T>,
+    xs2: Array<T>
+  ): Array<T>;
+
+  declare function eqBy<T>(fn: (x: T) => T, x: T, y: T): boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T, y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T, x: T): (y: T) => boolean;
+  declare function eqBy<T>(fn: (x: T) => T): (x: T) => (y: T) => boolean;
+
+  declare function gt<T>(x: T): (y: T) => boolean;
+  declare function gt<T>(x: T, y: T): boolean;
+
+  declare function gte<T>(x: T): (y: T) => boolean;
+  declare function gte<T>(x: T, y: T): boolean;
+
+  declare function identical<T>(x: T): (y: T) => boolean;
+  declare function identical<T>(x: T, y: T): boolean;
+      
+  declare function includes<V, T: Array<V> | string>(x?: V, y: T): boolean;
+  declare function includes<V, T: Array<V> | string>(x?: V) : (y: T) => boolean;
+
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean
+  ): (
+    a: Array<A>
+  ) => (b: Array<B>) => Array<A> & ((a: Array<A>, b: Array<B>) => Array<A>);
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: Array<A>
+  ): (b: Array<B>) => Array<A>;
+  declare function innerJoin<A, B>(
+    pred: (a: A, b: B) => boolean,
+    a: Array<A>,
+    b: Array<B>
+  ): Array<A>;
+
+  declare function intersection<T>(x: Array<T>, y: Array<T>): Array<T>;
+  declare function intersection<T>(x: Array<T>): (y: Array<T>) => Array<T>;
+
+  declare function intersectionWith<T>(
+    fn: BinaryPredicateFn<T>
+  ): ((x: Array<T>, y: Array<T>) => Array<T>) &
+    ((x: Array<T>) => (y: Array<T>) => Array<T>);
+  declare function intersectionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>
+  ): (y: Array<T>) => Array<T>;
+  declare function intersectionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>,
+    y: Array<T>
+  ): Array<T>;
+
+  declare function lt<T>(x: T): (y: T) => boolean;
+  declare function lt<T>(x: T, y: T): boolean;
+
+  declare function lte<T>(x: T): (y: T) => boolean;
+  declare function lte<T>(x: T, y: T): boolean;
+
+  declare function max<T>(x: T): (y: T) => T;
+  declare function max<T>(x: T, y: T): T;
+
+  declare function maxBy<T, V>(
+    fn: (x: T) => V
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function maxBy<T, V>(fn: (x: T) => V, x: T): (y: T) => T;
+  declare function maxBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function min<T>(x: T): (y: T) => T;
+  declare function min<T>(x: T, y: T): T;
+
+  declare function minBy<T, V>(
+    fn: (x: T) => V
+  ): ((x: T, y: T) => T) & ((x: T) => (y: T) => T);
+  declare function minBy<T, V>(fn: (x: T) => V, x: T): (y: T) => T;
+  declare function minBy<T, V>(fn: (x: T) => V, x: T, y: T): T;
+
+  declare function sortBy<T, V>(fn: (x: T) => V): (x: Array<T>) => Array<T>;
+  declare function sortBy<T, V>(fn: (x: T) => V, x: Array<T>): Array<T>;
+
+  declare function symmetricDifference<T>(
+    x: Array<T>
+  ): (y: Array<T>) => Array<T>;
+  declare function symmetricDifference<T>(x: Array<T>, y: Array<T>): Array<T>;
+
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>
+  ): ((x: Array<T>) => (y: Array<T>) => Array<T>) &
+    ((x: Array<T>, y: Array<T>) => Array<T>);
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>
+  ): (y: Array<T>) => Array<T>;
+  declare function symmetricDifferenceWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>,
+    y: Array<T>
+  ): Array<T>;
+
+  declare function union<T>(x: Array<T>): (y: Array<T>) => Array<T>;
+  declare function union<T>(x: Array<T>, y: Array<T>): Array<T>;
+
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>
+  ): ((x: Array<T>) => (y: Array<T>) => Array<T>) &
+    ((x: Array<T>, y: Array<T>) => Array<T>);
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>
+  ): (y: Array<T>) => Array<T>;
+  declare function unionWith<T>(
+    fn: BinaryPredicateFn<T>,
+    x: Array<T>,
+    y: Array<T>
+  ): Array<T>;
+
+  // *Object
+  declare var assoc: {
+    <T, S>(
+      key: string,
+      ...args: Array<void>
+    ): ((val: T) => (src: S) => { [k: string]: T, ... }) &
+      ((val: T, src: S) => { [k: string]: T, ... } & S),
+    <T, S>(
+      key: string,
+      val: T,
+      ...args: Array<void>
+    ): (src: S) => { [k: string]: T, ... } & S,
+    <T, S: Object, K: $Keys<S>>(
+      key: K,
+      val: T,
+      src: S
+    ): { [k: string]: T, ... } & S,
+    <T, S: Object>(
+      key: string,
+      val: T,
+      src: S
+    ): {
+      [k: string]: T,
+      ...$Exact<S>,
+      ...
+    },
+    ...
+  };
+
+  declare function assocPath<T, S>(
+    key: Array<string>,
+    ...args: Array<void>
+  ): ((val: T) => (src: S) => { [k: string]: T, ... }) &
+    ((val: T) => (src: S) => { [k: string]: T, ... } & S);
+  declare function assocPath<T, S>(
+    key: Array<string>,
+    val: T,
+    ...args: Array<void>
+  ): (src: S) => { [k: string]: T, ... } & S;
+  declare function assocPath<T, S>(
+    key: Array<string>,
+    val: T,
+    src: S
+  ): { [k: string]: T, ... } & S;
+
+  declare function clone<T>(src: T): $Shape<T>;
+
+  declare function dissoc<T>(
+    key: string,
+    ...args: Array<void>
+  ): (src: { [k: string]: T, ... }) => { [k: string]: T, ... };
+  declare function dissoc<T>(
+    key: string,
+    src: { [k: string]: T, ... }
+  ): { [k: string]: T, ... };
+
+  declare function dissocPath<T>(
+    key: Array<string>,
+    ...args: Array<void>
+  ): (src: { [k: string]: T, ... }) => { [k: string]: T, ... };
+  declare function dissocPath<T>(
+    key: Array<string>,
+    src: { [k: string]: T, ... }
+  ): { [k: string]: T, ... };
+
+  declare function evolve<A: Object>(NestedObject<Function>): A => A;
+  declare function evolve<A: Object>(NestedObject<Function>, A): A;
+
+  declare function eqProps(
+    key: string,
+    ...args: Array<void>
+  ): ((o1: Object) => (o2: Object) => boolean) &
+    ((o1: Object, o2: Object) => boolean);
+  declare function eqProps(
+    key: string,
+    o1: Object,
+    ...args: Array<void>
+  ): (o2: Object) => boolean;
+  declare function eqProps(key: string, o1: Object, o2: Object): boolean;
+
+  declare function has(key: string): (o: Object) => boolean;
+  declare function has(key: string, o: Object): boolean;
+
+  declare function hasIn(key: string, o: Object): boolean;
+  declare function hasIn(key: string): (o: Object) => boolean;
+
+  declare function invert(o: Object): { [k: string]: Array<string>, ... };
+  declare function invertObj(o: Object): { [k: string]: string, ... };
+
+  declare function keys(o: ?Object): Array<string>;
+
+  declare type Lens = <T, V>(x: T) => V;
+
+  declare function lens<T, U, V>(
+    getter: (s: T) => U,
+    setter: (a: U, s: T) => V
+  ): Lens;
+  declare function lens<T, U, V>(
+    getter: (s: T) => U
+  ): (setter: (a: U, s: T) => V) => Lens;
+
+  declare function lensIndex(n: number): Lens;
+
+  declare function lensPath(a: $ReadOnlyArray<string | number>): Lens;
+
+  declare function lensProp(str: string): Lens;
+
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: Object) => B,
+    o: { [key: string]: A, ... }
+  ): { [key: string]: B, ... };
+  declare function mapObjIndexed<A, B>(
+    fn: (val: A, key: string, o: Object) => B,
+    ...args: Array<void>
+  ): (o: { [key: string]: A, ... }) => { [key: string]: B, ... };
+
+  declare type Merge = (<A, B>(a: A, b: B) => A & B) &
+    (<A, B>(a: A) => (b: B) => A & B);
+
+  declare var merge: Merge;
+
+  declare function mergeAll<T>(
+    os: Array<{ [k: string]: T, ... }>
+  ): { [k: string]: T, ... };
+
+  declare var mergeDeepLeft: Merge;
+
+  declare var mergeDeepRight: (<A, B>(a: A, b: B) => B & A) &
+    (<A, B>(a: A) => (b: B) => B & A);
+
+  declare type MergeWith = (<A, B, T: $Values<A> & $Values<B>>(
+    fn: (a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<A, B, T>(fn: (a: T, b: T) => T) => (a: A) => (b: B) => A & B) &
+    (<A, B, T>(fn: (a: T, b: T) => T) => (a: A, b: B) => A & B) &
+    (<A, B, T>(fn: (a: T, b: T) => T, a: A) => (b: B) => A & B);
+
+  declare type MergeWithKey = (<
+    A,
+    B,
+    S: $Keys<A> & $Keys<B>,
+    T: $ElementType<A, $Keys<A>> & $ElementType<B, $Keys<B>>
+  >(
+    fn: (s: S, a: T, b: T) => T,
+    a: A,
+    b: B
+  ) => A & B) &
+    (<S, T, A, B>(fn: (s: S, a: T, b: T) => T) => (a: A, b: B) => A & B) &
+    (<S, T, A, B>(fn: (s: S, a: T, b: T) => T) => (a: A) => (b: B) => A & B) &
+    (<S, T, A, B>(fn: (s: S, a: T, b: T) => T, a: A) => (b: B) => A & B);
+
+  declare var mergeDeepWith: MergeWith;
+
+  declare var mergeDeepWithKey: MergeWithKey;
+
+  declare var mergeWith: MergeWith;
+
+  declare var mergeWithKey: MergeWithKey;
+
+  declare function objOf<T>(key: string): (val: T) => { [key: string]: T, ... };
+  declare function objOf<T>(key: string, val: T): { [key: string]: T, ... };
+
+  declare function omit<T: Object>(keys: Array<string>): (val: T) => Object;
+  declare function omit<T: Object>(keys: Array<string>, val: T): Object;
+
+  declare function over<T, V, U>(lens: Lens, x: (any) => mixed, val: V): U;
+  declare function over<T, V, U>(
+    lens: Lens
+  ): ((x: (any) => mixed) => (val: V) => U) &
+    ((x: (any) => mixed, val: V) => U);
+
+  declare function path<V>(p: Array<mixed>): (o: NestedObject<V>) => V;
+  declare function path<V>(p: Array<mixed>): (o: null | void) => void;
+  declare function path<V>(p: Array<mixed>): (o: mixed) => ?V;
+  declare function path<V, A: NestedObject<V>>(p: Array<mixed>, o: A): V;
+  declare function path<V, A: null | void>(p: Array<mixed>, o: A): void;
+  declare function path<V, A: mixed>(p: Array<mixed>, o: A): ?V;
+
+  declare function path<V>(p: Array<string>): (o: NestedObject<V>) => V;
+  declare function path<V>(p: Array<string>): (o: null | void) => void;
+  declare function path<V>(p: Array<string>): (o: mixed) => ?V;
+  declare function path<V, A: NestedObject<V>>(p: Array<string>, o: A): V;
+  declare function path<V, A: null | void>(p: Array<string>, o: A): void;
+  declare function path<V, A: mixed>(p: Array<string>, o: A): ?V;
+
+  declare function pathOr<T, V, A: NestedObject<V>>(
+    or: T
+  ): ((p: Array<string>) => (o: ?A) => V | T) &
+    ((p: Array<string>, o: ?A) => V | T);
+  declare function pathOr<T, V, A: NestedObject<V>>(
+    or: T,
+    p: Array<string>
+  ): (o: ?A) => V | T;
+  declare function pathOr<T, V, A: NestedObject<V>>(
+    or: T,
+    p: Array<string>,
+    o: ?A
+  ): V | T;
+
+  declare function pick<A>(
+    keys: Array<string>
+  ): (val: { [key: string]: A, ... }) => { [key: string]: A, ... };
+  declare function pick<A>(
+    keys: Array<string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: A, ... };
+
+  declare function pickAll<A>(
+    keys: Array<string>
+  ): (val: { [key: string]: A, ... }) => { [key: string]: ?A, ... };
+  declare function pickAll<A>(
+    keys: Array<string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: ?A, ... };
+
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>
+  ): (val: { [key: string]: A, ... }) => { [key: string]: A, ... };
+  declare function pickBy<A>(
+    fn: BinaryPredicateFn2<A, string>,
+    val: { [key: string]: A, ... }
+  ): { [key: string]: A, ... };
+
+  declare function project<T>(
+    keys: Array<string>
+  ): (val: Array<{ [key: string]: T, ... }>) => Array<{ [key: string]: T, ... }>;
+  declare function project<T>(
+    keys: Array<string>,
+    val: Array<{ [key: string]: T, ... }>
+  ): Array<{ [key: string]: T, ... }>;
+
+  declare function prop<T: string, O>(key: T): (o: O) => $ElementType<O, T>;
+  declare function prop<T: string, O>(
+    __: $npm$ramda$Placeholder,
+    o: O
+  ): (key: T) => $ElementType<O, T>;
+  declare function prop<T: string, O>(key: T, o: O): $ElementType<O, T>;
+
+  // propOr 1 argument => (function (2 arguments) or (function (1 argument) => function (1 argument)))
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue
+  ): ((
+    property: Property
+  ) => ((object: Primitives) => DefaultValue) &
+    ((
+      object: Obj
+    ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>)) &
+    (((property: Property, object: Primitives) => DefaultValue) &
+      ((
+        property: Property,
+        object: Obj
+      ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>));
+
+  // propOr 2 arguments => function (1 argument)
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue,
+    property: $npm$ramda$Placeholder
+  ): (
+    property: Property
+  ) => ((object: Primitives) => DefaultValue) &
+    ((
+      object: Obj
+    ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>);
+
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: $npm$ramda$Placeholder,
+    property: Property
+  ): (
+    defaultValue: DefaultValue
+  ) => ((object: Primitives) => DefaultValue) &
+    ((
+      object: Obj
+    ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>);
+
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue,
+    property: Property
+  ): ((object: Primitives) => DefaultValue) &
+    ((
+      object: Obj
+    ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>);
+
+  // propOr 3 arguments
+  //propOr(defaultValue, __, object)
+  declare function propOr<DefaultValue, Property: string>(
+    defaultValue: DefaultValue,
+    property: $npm$ramda$Placeholder,
+    object: Primitives
+  ): (p: Property) => DefaultValue;
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue,
+    property: $npm$ramda$Placeholder,
+    object: Obj
+  ): (
+    property: Property
+  ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>;
+  //propOr(defaultValue, property, __)
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue,
+    property: Property,
+    object: $npm$ramda$Placeholder
+  ): ((property: Primitives) => DefaultValue) &
+    ((
+      property: Obj
+    ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>);
+  //propOr(__, property, object)
+  declare function propOr<DefaultValue, Property: string>(
+    defaultValue: $npm$ramda$Placeholder,
+    property: Property,
+    object: Primitives
+  ): (defaultValue: DefaultValue) => DefaultValue;
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: $npm$ramda$Placeholder,
+    property: Property,
+    object: Obj
+  ): (
+    defaultValue: DefaultValue
+  ) => $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>;
+  //propOr(defaultValue, property, object)
+  declare function propOr<DefaultValue, Property: string>(
+    defaultValue: DefaultValue,
+    property: Property,
+    object: Primitives
+  ): DefaultValue;
+  declare function propOr<DefaultValue, Property: string, Obj: Object>(
+    defaultValue: DefaultValue,
+    property: Property,
+    object: Obj
+  ): $ElementType<{
+    [Property]: DefaultValue,
+    ...Obj,
+    ...
+  }, Property>;
+
+  declare function keysIn(o: Object): Array<string>;
+
+  declare function props<T: string, O>(
+    keys: Array<T>
+  ): (o: O) => Array<$ElementType<O, T>>;
+  declare function props<T: string, O>(
+    keys: Array<T>,
+    o: O
+  ): Array<$ElementType<O, T>>;
+
+  declare function set<T, V, U>(lens: Lens, x: T, val: V): U;
+  declare function set<T, V, U>(
+    lens: Lens
+  ): ((x: (any) => mixed) => (val: V) => U) &
+    ((x: (any) => mixed, val: V) => U);
+
+  declare function toPairs<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[$Keys<O>, T]>;
+
+  declare function toPairsIn<T, O: { [k: string]: T, ... }>(
+    o: O
+  ): Array<[string, T]>;
+
+  declare function values<T>(o: T): Array<$Values<T>>;
+
+  declare function valuesIn<T, O: { [k: string]: T, ... }>(o: O): Array<T | any>;
+
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>,
+    o: O
+  ): boolean;
+  declare function where<O>(
+    predObj: $ObjMap<O, MapUnaryPredicateFn>
+  ): O => boolean;
+
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O
+  ): (o: $Shape<O & Q>) => boolean;
+  declare function whereEq<T, S, O: { [k: string]: T, ... }, Q: { [k: string]: S, ... }>(
+    predObj: O,
+    o: $Shape<O & Q>
+  ): boolean;
+
+  declare function view<T, V>(lens: Lens, val: T): V;
+  declare function view<T, V>(lens: Lens): (val: T) => V;
+
+  // *Function
+  declare var __: $npm$ramda$Placeholder;
+
+  declare var T: (_: any) => true;
+  declare var F: (_: any) => false;
+
+  declare function addIndex<A, B>(
+    iterFn: (fn: (x: A) => B, xs: Array<A>) => Array<B>
+  ): (fn: (x: A, idx: number, xs: Array<A>) => B, xs: Array<A>) => Array<B>;
+
+  declare function always<T>(x: T): (x: any) => T;
+
+  declare function ap<T, V>(
+    fns: Array<(x: T) => V>
+  ): (xs: Array<T>) => Array<V>;
+  declare function ap<T, V>(fns: Array<(x: T) => V>, xs: Array<T>): Array<V>;
+
+  declare function apply<T, V>(
+    fn: (...args: Array<T>) => V
+  ): (xs: Array<T>) => V;
+  declare function apply<T, V>(fn: (...args: Array<T>) => V, xs: Array<T>): V;
+
+  declare function applySpec<
+    V,
+    S,
+    A: Array<V>,
+    T: NestedObject<(...args: A) => S>
+  >(
+    spec: T
+  ): (...args: A) => NestedObject<S>;
+
+  declare function applyTo<A, B>(a: A): (fn: (x: A) => B) => B;
+  declare function applyTo<A, B>(a: A, fn: (x: A) => B): B;
+
+  declare function binary<T>(
+    fn: (...args: Array<any>) => T
+  ): (x: any, y: any) => T;
+
+  declare function bind<T>(
+    fn: (...args: Array<any>) => any,
+    thisObj: T
+  ): (...args: Array<any>) => any;
+
+  declare function call<T, V>(
+    fn: (...args: Array<V>) => T,
+    ...args: Array<V>
+  ): T;
+
+  declare function comparator<T>(
+    fn: BinaryPredicateFn<T>
+  ): (x: T, y: T) => number;
+
+  // TODO add tests
+  declare function construct<T>(
+    ctor: Class<GenericContructor<T>>
+  ): (x: T) => GenericContructor<T>;
+
+  // TODO add tests
+  declare function constructN<T>(
+    n: number,
+    ctor: Class<GenericContructorMulti<any>>
+  ): (...args: any) => GenericContructorMulti<any>;
+
+  // TODO make less generic
+  declare function converge(after: Function, fns: Array<Function>): Function;
+
+  declare function empty<T>(x: T): T;
+
+  declare function flip<A, B, TResult>(
+    fn: (arg0: A, arg1: B) => TResult
+  ): CurriedFunction2<B, A, TResult>;
+  declare function flip<A, B, C, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C) => TResult
+  ): ((arg0: B, arg1: A) => (arg2: C) => TResult) &
+    ((arg0: B, arg1: A, arg2: C) => TResult);
+  declare function flip<A, B, C, D, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D) => TResult
+  ): ((arg1: B, arg0: A) => (arg2: C, arg3: D) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D) => TResult);
+  declare function flip<A, B, C, D, E, TResult>(
+    fn: (arg0: A, arg1: B, arg2: C, arg3: D, arg4: E) => TResult
+  ): ((arg1: B, arg0: A) => (arg2: C, arg3: D, arg4: E) => TResult) &
+    ((arg1: B, arg0: A, arg2: C, arg3: D, arg4: E) => TResult);
+
+  declare function identity<T>(x: T): T;
+
+  declare function invoker<A, B, C, D, O: { [k: string]: Function, ... }>(
+    arity: number,
+    name: $Keys<O>
+  ): CurriedFunction2<A, O, D> &
+    CurriedFunction3<A, B, O, D> &
+    CurriedFunction4<A, B, C, O, D>;
+
+  declare function juxt<T, S>(
+    fns: Array<(...args: Array<S>) => T>
+  ): (...args: Array<S>) => Array<T>;
+
+  // TODO lift
+
+  // TODO liftN
+
+  declare function memoize<A, B, T: (...args: Array<A>) => B>(fn: T): T;
+
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: Array<A>) => C
+  ): (...args: Array<A>) => (...args: Array<A>) => B;
+  declare function memoizeWith<A, B, C>(
+    keyFn: (...args: Array<A>) => C,
+    fn: (...args: Array<A>) => B
+  ): (...args: Array<A>) => B;
+
+  declare function nAry<T>(
+    arity: number,
+    fn: (...args: Array<any>) => T
+  ): (...args: Array<any>) => T;
+
+  declare function nthArg<T>(n: number): (...args: Array<T>) => T;
+
+  declare var o: (<A, B, C>(
+    fn1: (b: B) => C,
+    ...rest: void[]
+  ) => ((fn2: (a: A) => B, ...rest: void[]) => (x: A) => C) &
+    ((fn2: (a: A) => B, x: A) => C)) &
+    (<A, B, C>(
+      fn1: (b: B) => C,
+      fn2: (a: A) => B,
+      ...rest: void[]
+    ) => (x: A) => C) &
+    (<A, B, C>(fn1: (b: B) => C, fn2: (a: A) => B, x: A) => C);
+
+  declare function of<T>(x: T): Array<T>;
+
+  declare function once<A, B, T: (...args: Array<A>) => B>(fn: T): T;
+
+  declare var partial: Partial;
+  // TODO partialRight
+
+  declare type UnaryMonadFn<A, R> = UnaryFn<A, Monad<R>>;
+  declare type PipeK = (<A, B, C, D, E, F, G, H, I, J, K, L: Monad<K>>(
+    ab: UnaryMonadFn<A, B>,
+    bc: UnaryMonadFn<B, C>,
+    cd: UnaryMonadFn<C, D>,
+    de: UnaryMonadFn<D, E>,
+    ef: UnaryMonadFn<E, F>,
+    fg: UnaryMonadFn<F, G>,
+    gh: UnaryMonadFn<G, H>,
+    hi: UnaryMonadFn<H, I>,
+    ij: UnaryMonadFn<I, J>,
+    jk: (J) => L
+  ) => A => L) &
+    (<A, B, C, D, E, F, G, H, I, J, K: Monad<J>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: UnaryMonadFn<D, E>,
+      ef: UnaryMonadFn<E, F>,
+      fg: UnaryMonadFn<F, G>,
+      gh: UnaryMonadFn<G, H>,
+      hi: UnaryMonadFn<H, I>,
+      ij: (I) => K
+    ) => A => K) &
+    (<A, B, C, D, E, F, G, H, I, J: Monad<I>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: UnaryMonadFn<D, E>,
+      ef: UnaryMonadFn<E, F>,
+      fg: UnaryMonadFn<F, G>,
+      gh: UnaryMonadFn<G, H>,
+      hi: (H) => J
+    ) => A => J) &
+    (<A, B, C, D, E, F, G, H, I: Monad<H>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: UnaryMonadFn<D, E>,
+      ef: UnaryMonadFn<E, F>,
+      fg: UnaryMonadFn<F, G>,
+      gh: (G) => I
+    ) => A => I) &
+    (<A, B, C, D, E, F, G, H: Monad<G>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: UnaryMonadFn<D, E>,
+      ef: UnaryMonadFn<E, F>,
+      fg: (F) => H
+    ) => A => H) &
+    (<A, B, C, D, E, F, G: Monad<F>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: UnaryMonadFn<D, E>,
+      ef: (E) => G
+    ) => A => G) &
+    (<A, B, C, D, E, F: Monad<E>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: UnaryMonadFn<C, D>,
+      de: (D) => F
+    ) => A => F) &
+    (<A, B, C, D, E: Monad<D>>(
+      ab: UnaryMonadFn<A, B>,
+      bc: UnaryMonadFn<B, C>,
+      cd: (C) => E
+    ) => A => E) &
+    (<A, B, C, D: Monad<C>>(ab: UnaryMonadFn<A, B>, bc: (B) => D) => A => D) &
+    (<A, B, C: Monad<B>>(ab: (A) => C) => A => C);
+
+  declare function tap<T>(fn: (x: T) => any): (x: T) => T;
+  declare function tap<T>(fn: (x: T) => any, x: T): T;
+
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B
+  ): ((catcher: (e: E, a: A) => B) => (a: A) => B) &
+    ((catcher: (e: E, a: A) => B, a: A) => B);
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B
+  ): (a: A) => B;
+  declare function tryCatch<A, B, E>(
+    tryer: (a: A) => B,
+    catcher: (e: E, a: A) => B,
+    a: A
+  ): B;
+
+  declare function unapply<T, V>(
+    fn: (xs: Array<T>) => V
+  ): (...args: Array<T>) => V;
+
+  declare function unary<T>(fn: (...args: Array<any>) => T): (x: any) => T;
+
+  declare var uncurryN: (<A, B, C>(2, (A) => B => C) => (A, B) => C) &
+    (<A, B, C, D>(3, (A) => B => C => D) => (A, B, C) => D) &
+    (<A, B, C, D, E>(4, (A) => B => C => D => E) => (A, B, C, D) => E) &
+    (<A, B, C, D, E, F>(
+      5,
+      (A) => B => C => D => E => F
+    ) => (A, B, C, D, E) => F) &
+    (<A, B, C, D, E, F, G>(
+      6,
+      (A) => B => C => D => E => F => G
+    ) => (A, B, C, D, E, F) => G) &
+    (<A, B, C, D, E, F, G, H>(
+      7,
+      (A) => B => C => D => E => F => G => H
+    ) => (A, B, C, D, E, F, G) => H) &
+    (<A, B, C, D, E, F, G, H, I>(
+      8,
+      (A) => B => C => D => E => F => G => H => I
+    ) => (A, B, C, D, E, F, G, H) => I);
+
+  //TODO useWith
+
+  declare function wrap<A, B, C, D, F: (...args: Array<A>) => B>(
+    fn: F,
+    fn2: (fn: F, ...args: Array<C>) => D
+  ): (...args: Array<A | C>) => D;
+
+  // *Logic
+
+  declare function allPass<T>(
+    fns: Array<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function and<X, Y>(x: X): (y: Y) => X | Y;
+  declare function and<X, Y>(x: X, y: Y): X | Y;
+
+  declare function anyPass<T>(
+    fns: Array<(...args: Array<T>) => boolean>
+  ): (...args: Array<T>) => boolean;
+
+  declare function both<T>(
+    x: (...args: Array<T>) => boolean
+  ): (y: (...args: Array<T>) => boolean) => (...args: Array<T>) => boolean;
+  declare function both<T>(
+    x: (...args: Array<T>) => boolean,
+    y: (...args: Array<T>) => boolean
+  ): (...args: Array<T>) => boolean;
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement declaration.
+
+  declare function complement< Fn: () => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, Fn: (A) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, Fn: (A, B) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, Fn: (A, B, C) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, Fn: (A, B, C, D) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, Fn: (A, B, C, D, E) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, Fn: (A, B, C, D, E, F) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, Fn: (A, B, C, D, E, F, G) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, Fn: (A, B, C, D, E, F, G, H) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, Fn: (A, B, C, D, E, F, G, H, I) => boolean>(
+    f: Fn
+  ): Fn;
+
+  declare function complement<A, B, C, D, E, F, G, H, I, J, Fn: (A, B, C, D, E, F, G, H, I, J) => boolean>(
+    f: Fn
+  ): Fn;
+  // End generated complement declaration.
+
+  declare function cond<A, B>(
+    fns: Array<[(...args: Array<A>) => boolean, (...args: Array<A>) => B]>
+  ): (...args: Array<A>) => B;
+
+  declare function defaultTo<T, V>(d: T): (x: ?V) => V | T;
+  declare function defaultTo<T, V>(d: T, x: ?V): V | T;
+
+  declare function either(
+    x: (...args: Array<any>) => any
+  ): (y: (...args: Array<any>) => any) => : (...args: Array<any>) => any;
+  declare function either(
+    x: (...args: Array<any>) => any,
+    y: (...args: Array<any>) => any
+  ): : (...args: Array<any>) => any;
+
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean
+  ): ((
+    f1: (...args: Args) => B
+  ) => (f2: (...args: Args) => C) => (...args: Args) => B | C) &
+    ((
+      f1: (...args: Args) => B,
+      f2: (...args: Args) => C
+    ) => (...args: Args) => B | C);
+  declare function ifElse<Args, B, C>(
+    cond: (...args: Args) => boolean,
+    f1: (...args: Args) => B,
+    f2: (...args: Args) => C
+  ): (...args: Args) => B | C;
+
+  declare function isEmpty(x: ?Array<any> | Object | string): boolean;
+
+  declare function not(x: boolean): boolean;
+
+  declare function or<X, Y>(x: X): (y: Y) => X | Y;
+  declare function or<X, Y>(x: X, y: Y): X | Y;
+
+  declare var pathSatisfies: CurriedFunction3<
+    UnaryPredicateFn<any>,
+    string[],
+    Object,
+    boolean
+  >;
+
+  declare function propSatisfies<T>(
+    cond: (x: T) => boolean,
+    prop: string,
+    o: NestedObject<T>
+  ): boolean;
+  declare function propSatisfies<T>(
+    cond: (x: T) => boolean,
+    prop: string
+  ): (o: NestedObject<T>) => boolean;
+  declare function propSatisfies<T>(
+    cond: (x: T) => boolean
+  ): ((prop: string) => (o: NestedObject<T>) => boolean) &
+    ((prop: string, o: NestedObject<T>) => boolean);
+
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V
+  ): (x: T | S) => V | T;
+  declare function unless<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>
+  ): ((fn: (x: T) => T) => (x: T) => T) & ((fn: (x: T) => T, x: T) => T);
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T
+  ): (x: T) => T;
+  declare function until<T>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: T) => T,
+    x: T
+  ): T;
+
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>
+  ): ((fn: (x: S) => V) => (x: T | S) => T | V) &
+    ((fn: (x: S) => V, x: T | S) => T | V);
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V
+  ): (x: T | S) => V | T;
+  declare function when<T, V, S>(
+    pred: UnaryPredicateFn<T>,
+    fn: (x: S) => V,
+    x: T | S
+  ): T | V;
+}
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0..x.x_partial.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0..x.x_partial.js
new file mode 100644
index 0000000000..531bf883f4
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0..x.x_partial.js
@@ -0,0 +1,17 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { partial } from "ramda";
+
+// --- Partial ---
+const method1 = (foo: string, bah: number, baz: boolean) => baz;
+
+const partial1: (number, boolean) => boolean = partial(method1, ["foo"]);
+const partial2: boolean = partial(method1, ["foo"])(4, true);
+// $FlowExpectedError
+const partial3 = partial(method1, [4]);
+const partial4: boolean = partial(method1, ["foo", 4])(true);
+const partial5: boolean = partial(method1, ["foo", 4, true])();
+
+// Functions produced from partial are not curried.
+// $FlowExpectedError
+const partial6 = partial(method1, ["foo"])(4);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_cjs_modules.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_cjs_modules.js
new file mode 100644
index 0000000000..0978170a45
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_cjs_modules.js
@@ -0,0 +1,41 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+const _ = require("ramda");
+const { compose, match, toLower, trim, zipWith } = _;
+
+// $FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const zipped: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3],
+  ["1", "2", "3"]
+);
+const zipped2: Array<{
+  s: number,
+  y: string,
+  ...
+}> = zipWith(
+  (a, b) => ({ s: a, y: b }),
+  [1, 2, 3]
+)(["1", "2", "3"]);
+const zipped3: Array<{
+  s: number,
+  y: string,
+  ...
+}> = _.zipWith((a, b) => ({
+  s: a,
+  y: b
+}))([1, 2, 3])(["1", "2", "3"]);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_es_modules.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_es_modules.js
new file mode 100644
index 0000000000..bd79f5724c
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_es_modules.js
@@ -0,0 +1,14 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, match, toLower, trim } from "ramda";
+
+//$FlowExpectedError
+inc();
+
+const str: Array<string | void> = compose(match(/2/), toLower, trim)(" 1,2,3 ");
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_filter.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_filter.js
new file mode 100644
index 0000000000..ddd0ef0d00
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_filter.js
@@ -0,0 +1,94 @@
+// @flow
+import R, { filter, type RefineFilter } from "ramda";
+import { it, describe } from "flow-typed-test";
+
+describe("filter", () => {
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<number> = filter(x => x > 1, [1, 2]);
+  });
+
+  it("perserves the element type in the predicate and result array (number)", () => {
+    const s: Array<string> = R.filter(x => x === "2", ["2", "3"]);
+  });
+
+  it("filters objects by passing the value to the predicate", () => {
+    const s: { [key: string]: string, ... } = R.filter(x => x === "2", {
+      a: "2",
+      b: "3"
+    });
+  });
+
+  it("refines the element type using the predicate", () => {
+    const notNull = (x): boolean %checks => x != null;
+    const ns: Array<number> = (filter: RefineFilter)(notNull, [1, 2, null]);
+  });
+
+  it("fails when type refinement is incorrect", () => {
+    const isString = (x): boolean %checks => typeof x === "string";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isString, ["1", 2]);
+  });
+
+  it("fails when attempting to refine from a non $Pred predicate", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = filter(isNumber, ["1", 2]);
+  });
+
+  it("does not accept predicates missing %checks when using RefineFilter", () => {
+    const isNumber = x => typeof x === "number";
+    // $FlowExpectedError
+    const ns: Array<number> = (filter: RefineFilter)(isNumber, ["1", 2]);
+  });
+
+  describe("read only", () => {
+    it("should return readonly Array<number>", () => {
+      const readOnlyArrNumbers: $ReadOnlyArray<number> = Object.freeze([1, 2, 3]);
+
+      const result1 = filter(x => x > 1, readOnlyArrNumbers);
+      (result1: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result1: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result1: Array<number>);
+
+      const result2 = filter(x => x > 1)(readOnlyArrNumbers);
+
+      (result2: $ReadOnlyArray<number>);
+
+      // $FlowExpectedError
+      (result2: { +[key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: { [key: string]: number, ... });
+      // $FlowExpectedError
+      (result2: Array<number>);
+    });
+
+    it("should return readonly Object", () => {
+      type O = {| key: number |};
+      const readOnlyObj: { +[k: string]: O, ... } = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        ),
+        readOnlyObj
+      ): $ReadOnly<{ [k: string]: O, ... }>);
+
+      (filter(
+        R.pipe(
+          R.prop("key"),
+          (v: number) => v === 0
+        )
+      )(readOnlyObj): { +[k: string]: O, ... });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_functions.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_functions.js
new file mode 100644
index 0000000000..4b12becb8a
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_functions.js
@@ -0,0 +1,589 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, pipe, uncurryN, curry, pipeP, pipeK, tryCatch, applyTo } from "ramda";
+// Function
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// TODO: "Gap" Functions: Started failing in v31...
+// const g = _.propIs
+// const __ = _.__
+// const g1: boolean = g(1, '2', {p: 3})
+// const g2: boolean = g(__, '2', {p: 3})(1)
+// const g3: boolean = g(__, __, {p: 3})(1)('2')
+// const g4: boolean = g(__, __, {p: 3})(1, '2')
+// const g5: boolean = g(__, '2', __)(1, {p: 3})
+// const g6: boolean = g(__, '2')(1)({p: 3})
+// const g7: boolean = g(__, '2')(1, {p: 3})
+// const g8: boolean = g(__, '2')(__, {p: 3})(1)
+
+type R = {
+  sum: number,
+  nested: { mul: number, ... },
+  ...
+};
+// TODO: "Gap" Functions: Started failing in v31...
+// const greet: string = _.replace('{name}', _.__, 'Hello, {name}!')('John')
+const truth: boolean = _.T("ddd");
+const lie: boolean = _.F("ddd");
+const mapIndexed = _.addIndex(_.map);
+
+const mi: Array<string> = mapIndexed((val, idx) => idx + "-" + val, [
+  "f",
+  "o",
+  "o",
+  "b",
+  "a",
+  "r"
+]);
+
+const t: string = _.always("Tee")();
+const app: Array<number> = _.ap([_.multiply(2), _.add(3)], [1, 2, 3]);
+const app1: Array<string | number> = _.ap([_.toString, _.add(3)], [1, 2, 3]);
+
+const nums = [1, 2, 3, -99, 42, 6, 7];
+const applied: number = _.apply(Math.max, nums);
+const spec = {
+  sum: _.add,
+  nested: { mul: _.multiply }
+};
+
+const applyToResult1 = applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult1: string);
+// $FlowExpectedError
+(applyToResult1: number);
+
+const applyToResult2 = applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult2: string);
+// $FlowExpectedError
+(applyToResult2: number);
+
+const getMetrics = _.applySpec(spec);
+const apspec: $Shape<R> = getMetrics(2, 2);
+
+const applyToResult3 = _.applyTo(5, value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult3: string);
+// $FlowExpectedError
+(applyToResult3: number);
+
+const applyToResult4 = _.applyTo(5)(value => {
+  (value: number);
+  // $FlowExpectedError
+  (value: string);
+  return String(value)
+});
+(applyToResult4: string);
+// $FlowExpectedError
+(applyToResult4: number);
+
+const cmp: (x: Object, y: Object) => number = _.comparator(
+  (a, b) => a.age < b.age
+);
+const compf: number = _.compose(_.inc, _.negate)(2);
+
+const fn = compose(_.add);
+const fn1: (n: number) => number = fn(2);
+const add2 = _.compose(_.add(2));
+const four: number = add2(2);
+const str0: Array<string | void> = _.compose(_.match(/2/), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str1: Array<string> = _.compose(_.split(","), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+const str2: string = _.compose(_.replace("3", "4"), _.toLower, _.trim)(
+  " 1,2,3 "
+);
+
+const fn2: (n: number) => (n: number) => number = pipe(_.add);
+const fn3: (n: number) => number = fn2(2);
+const add2p = _.pipe(_.add(2));
+const b: number = add2p(2);
+const fail: string = _.pipe(_.trim)("h");
+const str3: Array<string | void> = _.pipe(_.toLower, _.trim, _.match(/2/))(
+  " 1,2,3 "
+);
+const str4: Array<string> = _.pipe(_.toLower, _.trim, _.split(","))(" 1,2,3 ");
+const str5: string = _.pipe(_.replace("3", "4"), _.toLower, _.trim)(" 1,2,3 ");
+
+// --- Curry ---
+declare var bar1: string => "bar1";
+declare var bar2: (string, number) => "bar2";
+declare var bar6: (string, number, boolean, null, {...}, []) => "bar6";
+
+const foo1 = curry(bar1);
+const foo2 = curry(bar2);
+const foo6 = curry(bar6);
+
+const foo1_1: "bar1" = foo1("");
+const foo2_1: "bar2" = foo2("", 0);
+const foo2_2: "bar2" = foo2("")(0);
+
+const foo6_1: "bar6" = foo6("", 0, true, null, {}, []);
+const foo6_2: "bar6" = foo6("")(0, true, null, {}, []);
+const foo6_3: "bar6" = foo6("", 0)(true, null, {}, []);
+const foo6_4: "bar6" = foo6("", 0, true)(null, {}, []);
+const foo6_5: "bar6" = foo6("", 0, true, null)({}, []);
+const foo6_6: "bar6" = foo6("", 0, true, null, {})([]);
+const foo6_7: "bar6" = foo6("")(0)(true, null, {}, []);
+const foo6_8: "bar6" = foo6("", 0)(true)(null, {}, []);
+const foo6_9: "bar6" = foo6("", 0, true)(null)({}, []);
+const foo6_10: "bar6" = foo6("", 0, true, null)({})([]);
+const foo6_11: "bar6" = foo6("")(0, true)(null, {}, []);
+const foo6_12: "bar6" = foo6("", 0)(true, null)({}, []);
+const foo6_13: "bar6" = foo6("", 0, true)(null, {})([]);
+const foo6_14: "bar6" = foo6("")(0, true, null)({}, []);
+const foo6_15: "bar6" = foo6("", 0)(true, null, {})([]);
+const foo6_16: "bar6" = foo6("")(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error1: "bar6" = foo6(false, 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error1: "bar6" = foo6(false)(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error1: "bar6" = foo6(false, 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error1: "bar6" = foo6(false, 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error1: "bar6" = foo6(false, 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error1: "bar6" = foo6(false, 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error1: "bar6" = foo6(false)(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error1: "bar6" = foo6(false, 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error1: "bar6" = foo6(false, 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error1: "bar6" = foo6(false, 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error1: "bar6" = foo6(false)(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error1: "bar6" = foo6(false, 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error1: "bar6" = foo6(false, 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error1: "bar6" = foo6(false)(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error1: "bar6" = foo6(false, 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error1: "bar6" = foo6(false)(0, true, null, {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error2: "bar6" = foo6("", 0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_2_Error2: "bar6" = foo6("")(0, true, "", {}, []);
+// $FlowExpectedError
+const foo6_3_Error2: "bar6" = foo6("", 0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_4_Error2: "bar6" = foo6("", 0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_5_Error2: "bar6" = foo6("", 0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_6_Error2: "bar6" = foo6("", 0, true, "", {})([]);
+// $FlowExpectedError
+const foo6_7_Error2: "bar6" = foo6("")(0)(true, "", {}, []);
+// $FlowExpectedError
+const foo6_8_Error2: "bar6" = foo6("", 0)(true)("", {}, []);
+// $FlowExpectedError
+const foo6_9_Error2: "bar6" = foo6("", 0, true)("")({}, []);
+// $FlowExpectedError
+const foo6_10_Error2: "bar6" = foo6("", 0, true, "")({})([]);
+// $FlowExpectedError
+const foo6_11_Error2: "bar6" = foo6("")(0, true)("", {}, []);
+// $FlowExpectedError
+const foo6_12_Error2: "bar6" = foo6("", 0)(true, "")({}, []);
+// $FlowExpectedError
+const foo6_13_Error2: "bar6" = foo6("", 0, true)("", {})([]);
+// $FlowExpectedError
+const foo6_14_Error2: "bar6" = foo6("")(0, true, "")({}, []);
+// $FlowExpectedError
+const foo6_15_Error2: "bar6" = foo6("", 0)(true, "", {})([]);
+// $FlowExpectedError
+const foo6_16_Error2: "bar6" = foo6("")(0, true, "", {})([]);
+
+// $FlowExpectedError
+const foo6_1_Error3: "bar6" = foo6("", 0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_2_Error3: "bar6" = foo6("")(0, true, null, {}, "");
+// $FlowExpectedError
+const foo6_3_Error3: "bar6" = foo6("", 0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_4_Error3: "bar6" = foo6("", 0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_5_Error3: "bar6" = foo6("", 0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_6_Error3: "bar6" = foo6("", 0, true, null, {})("");
+// $FlowExpectedError
+const foo6_7_Error3: "bar6" = foo6("")(0)(true, null, {}, "");
+// $FlowExpectedError
+const foo6_8_Error3: "bar6" = foo6("", 0)(true)(null, {}, "");
+// $FlowExpectedError
+const foo6_9_Error3: "bar6" = foo6("", 0, true)(null)({}, "");
+// $FlowExpectedError
+const foo6_10_Error3: "bar6" = foo6("", 0, true, null)({})("");
+// $FlowExpectedError
+const foo6_11_Error3: "bar6" = foo6("")(0, true)(null, {}, "");
+// $FlowExpectedError
+const foo6_12_Error3: "bar6" = foo6("", 0)(true, null)({}, "");
+// $FlowExpectedError
+const foo6_13_Error3: "bar6" = foo6("", 0, true)(null, {})("");
+// $FlowExpectedError
+const foo6_14_Error3: "bar6" = foo6("")(0, true, null)({}, "");
+// $FlowExpectedError
+const foo6_15_Error3: "bar6" = foo6("", 0)(true, null, {})("");
+// $FlowExpectedError
+const foo6_16_Error3: "bar6" = foo6("")(0, true, null, {})("");
+
+// $FlowExpectedError
+const foo6_1_Error4: "error" = foo6("", 0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_2_Error4: "error" = foo6("")(0, true, null, {}, []);
+// $FlowExpectedError
+const foo6_3_Error4: "error" = foo6("", 0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_4_Error4: "error" = foo6("", 0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_5_Error4: "error" = foo6("", 0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_6_Error4: "error" = foo6("", 0, true, null, {})([]);
+// $FlowExpectedError
+const foo6_7_Error4: "error" = foo6("")(0)(true, null, {}, []);
+// $FlowExpectedError
+const foo6_8_Error4: "error" = foo6("", 0)(true)(null, {}, []);
+// $FlowExpectedError
+const foo6_9_Error4: "error" = foo6("", 0, true)(null)({}, []);
+// $FlowExpectedError
+const foo6_10_Error4: "error" = foo6("", 0, true, null)({})([]);
+// $FlowExpectedError
+const foo6_11_Error4: "error" = foo6("")(0, true)(null, {}, []);
+// $FlowExpectedError
+const foo6_12_Error4: "error" = foo6("", 0)(true, null)({}, []);
+// $FlowExpectedError
+const foo6_13_Error4: "error" = foo6("", 0, true)(null, {})([]);
+// $FlowExpectedError
+const foo6_14_Error4: "error" = foo6("")(0, true, null)({}, []);
+// $FlowExpectedError
+const foo6_15_Error4: "error" = foo6("", 0)(true, null, {})([]);
+// $FlowExpectedError
+const foo6_16_Error4: "error" = foo6("")(0, true, null, {})([]);
+
+// -------------
+
+const currfn1: (y: number) => number = _.curryN(
+  2,
+  (x: number, y: number): number => x + y
+)(2);
+
+const flipped: (x: number, y: boolean, z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const flipped2: (x: number, y: boolean) => (z: string) => number = _.flip(
+  (x: boolean, y: number, z: string) => 1
+);
+const obb = {
+  doStuff(x: string, y: number, z: boolean) {
+    return 1;
+  },
+  doLessStuff(x: string, y: number) {
+    return "hello";
+  },
+  doEvenLessStuff(x: string) {
+    return true;
+  }
+};
+const doStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doStuff");
+//$FlowExpectedError
+const doLessStuff: (
+  x: string,
+  y: number,
+  z: boolean,
+  obj: typeof obb
+) => number = _.invoker(3, "doLStuff");
+const stuffDone: number = doStuff("dd", 1, true, obb);
+
+const range = _.juxt([_.toString, Math.min, Math.max]);
+const ju: Array<number | string> = range(3, 4, 9, -3);
+
+let _memoize = 0;
+const _memoizeFactorial = _.memoize(n => {
+  _memoize += 1;
+  return _.product(_.range(1, n + 1));
+});
+const mem: number = _memoizeFactorial(5);
+
+let _memoizeWith = 0;
+const _memoizeWithFactorial = _.memoizeWith(_.identity, n => {
+  _memoizeWith += 1;
+  return _.product(_.range(1, n + 1));
+});
+const memWith: number = _memoizeWithFactorial(5);
+
+const narg: string | number = _.nthArg(1)(1, "b", "c");
+
+const nameIs = ({ first, last }) => `The name's ${last}, ${first} ${last}`;
+const o1: string = _.o(_.toUpper, nameIs)({ first: "James", last: "Bond" });
+const oNum: number = _.o(_.multiply(10), _.add(10))(-4);
+
+const oof: Array<Array<number>> = _.of([42]);
+
+const unap: string = _.unapply(JSON.stringify)(1, 2, 3);
+
+const greetName = name => "Hello " + name;
+
+const shoutedGreet: boolean = _.wrap(
+  greetName,
+  (gr, name) => gr(name) === "Hello Anna"
+)("Anna");
+const shoutedGreet2: string = _.wrap(
+  greetName,
+  (gr, name) => name && "Hello Anna"
+)(true);
+
+// Uncurry
+const needs3: string => string => string => string = a => b => c => a + b + c;
+
+//$FlowExpectedError
+const needs3_error1: number = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error2: string => string = uncurryN(3, needs3)("", "", "");
+
+//$FlowExpectedError
+const needs3_error3: string => string => string = uncurryN(3, needs3)(
+  "",
+  "",
+  ""
+);
+
+const needs3_no_error: string = uncurryN(3, needs3)("", "", "");
+
+// --- PipeP ---
+const pAdd: number => number => Promise<number> = a => b =>
+  Promise.resolve(a + b);
+const pAppend: string => string => Promise<string> = a => b =>
+  Promise.resolve(a + b);
+const pToString: number => Promise<string> = n => Promise.resolve(String(n));
+const pFn1: number => Promise<number> = pipeP(pAdd(2));
+const pFoo1: Promise<number> = pFn1(2);
+const pFn2: number => Promise<string> = pipeP(pAdd(2), pToString);
+const pFoo2: Promise<string> = pFn2(2);
+const pFn3: number => Promise<string> = pipeP(pAdd(2), pToString, pAppend("A"));
+const pFoo3: Promise<string> = pFn3(2);
+const pFn4: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B")
+);
+const pFoo4: Promise<string> = pFn4(2);
+const pFn5: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAppend("C")
+);
+const pFoo5: Promise<string> = pFn5(2);
+const pFn6: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAppend("C"),
+  pAppend("D")
+);
+const pFoo6: Promise<string> = pFn6(2);
+
+//$FlowExpectedError
+const pipeP_error1: number => Promise<number> = _.pipeP(_.add(2));
+//$FlowExpectedError
+const pipeP_error2: number => Promise<string> = _.pipeP(pAdd(2), String);
+//$FlowExpectedError
+const pipeP_error3: number => Promise<number> = pipeP(
+  pAdd(2),
+  pToString,
+  pAdd(2)
+);
+//$FlowExpectedError
+const pipeP_error4: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAdd(2)
+);
+//$FlowExpectedError
+const pipeP_error5: number => Promise<string> = pipeP(
+  pAdd(2),
+  pToString,
+  pAppend("A"),
+  pAppend("B"),
+  pAdd(2)
+);
+const pipeP_error6: number => Promise<string> = pipeP(
+//$FlowExpectedError
+  pAdd(2), pToString, pAppend("A"), pAppend("B"), pAppend("C"), pAdd(2)
+);
+
+// -------------
+
+// --- PipeK ---
+
+class Box<A>  {
+    value: A;
+
+    constructor(x) {
+        this.value = x;
+    }
+
+    chain(f: A => any) {
+        return f(this.value);
+    }
+
+    static of<T: any>(x: T): Box<T> {
+        return new Box(x);
+    }
+}
+
+const kAdd: number => number => Box<number> = a => b =>
+  Box.of(a + b);
+const kAppend: string => string => Box<string> = a => b =>
+  Box.of(a + b);
+const kToString: number => Box<string> = n => Box.of(String(n));
+const kFn1: number => Box<number> = pipeK(kAdd(2));
+const kFoo1: Box<number> = kFn1(2);
+const kFn2: number => Box<string> = pipeK(kAdd(2), kToString);
+const kFoo2: Box<string> = kFn2(2);
+const kFn3: number => Box<string> = pipeK(kAdd(2), kToString, kAppend("A"));
+const kFoo3: Box<string> = kFn3(2);
+const kFn4: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B")
+);
+const kFoo4: Box<string> = kFn4(2);
+const kFn5: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAppend("C")
+);
+const kFoo5: Box<string> = kFn5(2);
+const kFn6: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAppend("C"),
+  kAppend("D")
+);
+const kFoo6: Box<string> = kFn6(2);
+
+//$FlowExpectedError
+const pipeK_error1: number => Box<number> = _.pipeK(_.add(2));
+//$FlowExpectedError
+const pipeK_error2: number => Box<string> = _.pipeK(kAdd(2), String);
+//$FlowExpectedError
+const pipeK_error3: number => Box<number> = pipeK(
+  kToString,
+  kAdd(2),
+  kAdd(2)
+);
+//$FlowExpectedError
+const pipeK_error4: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAdd(2)
+);
+//$FlowExpectedError
+const pipeK_error5: number => Box<string> = pipeK(
+  kAdd(2),
+  kToString,
+  kAppend("A"),
+  kAppend("B"),
+  kAdd(2)
+);
+const pipeK_error6: number => Box<number> = pipeK(
+//$FlowExpectedError
+  kAdd(2), kToString, kAppend("A"), kAppend("B"), kAppend("C"), kAdd(2)
+);
+
+// -------------
+
+// --- TyrCatch ---
+const tryFn: boolean => string = a => String(a);
+
+const tryFn_2: boolean => boolean = a => a;
+
+const catchFn: (Error, boolean) => string = (e, a) => e.message;
+
+const catchFn_2: (Error, boolean) => boolean = (e, a) => a;
+
+const tc1: string = tryCatch(tryFn, catchFn, true);
+const tc2: boolean => string = tryCatch(tryFn, catchFn);
+const tc3: string = tc2(true);
+//const tc7: string = tryCatch(tryFn)(catchFn)(true);
+const tc4: string = tryCatch(tryFn)(catchFn, true);
+const tc5: string = tryCatch(tryFn)(catchFn)(true);
+
+//$FlowExpectedError
+const tc_error1: boolean = tryCatch(tryFn, catchFn, true);
+//$FlowExpectedError
+const tc_error2: boolean = tryCatch(tryFn, catchFn)(true);
+//$FlowExpectedError
+const tc_error3: boolean = tryCatch(tryFn)(catchFn, true);
+//$FlowExpectedError
+const tc_error4: boolean = tryCatch(tryFn)(catchFn)(true);
+//$FlowExpectedError
+const tc_error5: string = tryCatch(tryFn_2, catchFn, "string");
+//$FlowExpectedError
+const tc_error6: string = tryCatch(tryFn_2, catchFn)("string");
+//$FlowExpectedError
+const tc_error7: string = tryCatch(tryFn_2)(catchFn, "string");
+//$FlowExpectedError
+const tc_error8: string = tryCatch(tryFn_2)(catchFn)("string");
+//$FlowExpectedError
+const tc_error9: string = tryCatch(tryFn_2, catchFn, true);
+//$FlowExpectedError
+const tc_error10: string = tryCatch(tryFn_2, catchFn)(true);
+//$FlowExpectedError
+const tc_error11: string = tryCatch(tryFn_2)(catchFn, true);
+//$FlowExpectedError
+const tc_error12: string = tryCatch(tryFn_2)(catchFn)(true);
+//$FlowExpectedError
+const tc_error13: string = tryCatch(tryFn, catchFn_2, true);
+//$FlowExpectedError
+const tc_error14: string = tryCatch(tryFn, catchFn_2)(true);
+//$FlowExpectedError
+const tc_error15: string = tryCatch(tryFn)(catchFn_2, true);
+//$FlowExpectedError
+const tc_error16: string = tryCatch(tryFn)(catchFn_2)(true);
+
+// -------------
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_lensPath.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_lensPath.js
new file mode 100644
index 0000000000..435288e972
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_lensPath.js
@@ -0,0 +1,41 @@
+// @flow
+import R, {type Lens} from "ramda";
+import { it, describe } from "flow-typed-test";
+
+describe("R.lensPath()", () => {
+  it("should except implicit input type strings only", () => {
+    const path = ["a", "b"];
+
+    (R.lensPath(path): Lens);
+  });
+
+  it("should except implicit input type numbers only", () => {
+    const path = [1, 2];
+
+    (R.lensPath(path): Lens);
+  });
+
+  it("should except implicit input type mixed", () => {
+    const path = ["a", 1];
+
+    (R.lensPath(path): Lens);
+  });
+
+  it("should except explicit number array", () => {
+    const path: number[] = [1, 2];
+
+    (R.lensPath(path): Lens);
+  });
+
+  it("should except explicit string array", () => {
+    const path: string[] = ["a", "b"];
+
+    (R.lensPath(path): Lens);
+  });
+
+  it("should except explicit mixed array", () => {
+    const path: (string | number)[] = ["a", 1];
+
+    (R.lensPath(path): Lens);
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_list.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_list.js
new file mode 100644
index 0000000000..9ff08ff917
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_list.js
@@ -0,0 +1,578 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  type RefineFilter,
+  compose,
+  contains,
+  pipe,
+  curry,
+  filter,
+  find,
+  length,
+  reduce,
+  repeat,
+  subtract,
+  zipWith
+} from "ramda";
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: number | string, ... }> = [
+  { a: 1, c: "d" },
+  { b: 2 }
+];
+const str: string = "hello world";
+
+// List
+{
+  const xs: Array<number> = _.adjust(x => x + 1, 2, ns);
+  const xs1: Array<number> = _.adjust(x => x + 1, 2)(ns);
+  //$FlowExpectedError
+  const xs3: Array<string> = _.adjust(x => x + 1)(2)(ns);
+
+  const as: boolean = _.all(x => x > 1, ns);
+  const asf: (s: Array<string>) => boolean = _.any(x => x.length > 1);
+  const as1: boolean = asf(ss);
+
+  const aps: Array<Array<number>> = _.aperture(2, ns);
+  const aps2: Array<Array<string>> = _.aperture(2)(ss);
+
+  const newXs: Array<string> = _.append("one", ss);
+  const newXs1: Array<number> = _.prepend(1)(ns);
+
+  const concatxs1: Array<number> = _.concat([4, 5, 6], [1, 2, 3]);
+  const concatxs2: string = _.concat("ABC", "DEF");
+
+  const dropxs: Array<string> = _.drop(4, ss);
+  const dropxs1: string = _.drop(3)(str);
+  const dropxs2: Array<string> = _.dropLast(4, ss);
+  const dropxs3: string = _.dropLast(3)(str);
+  const dropxs4: Array<number> = _.dropLastWhile(x => x <= 3, ns);
+  const dropxs5: Array<string> = _.dropRepeats(ss);
+  const dropxs6: Array<number> = _.dropRepeatsWith(_.eqBy(Math.abs), ns);
+  const dropxs7: Array<number> = _.dropWhile(x => x === 1, ns);
+
+  describe('contains', () => {
+    describe('uncurried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = contains(2, xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = contains(2, xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = contains('foo', xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<string> = ['bar']
+        // It is not understood why this fails to be flagged as an error when
+        // the 0.26.x libdef passes with the same declaration. The curried form
+        // works reliably though.
+        //
+        // $ShouldExpectErrorButInsteadWorksPleaseFix
+        const result: boolean = contains(1, xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = contains('foo', 'bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = contains(1, 'bar')
+      })
+    })
+
+    describe('1 arg curried form', () => {
+      it('returns a boolean for an Array and its element type', () => {
+        const xs: Array<number> = [1]
+        const result: boolean = contains(2)(xs)
+      })
+
+      it('returns a boolean for a $ReadOnlyArray and its element type', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        const result: boolean = contains(2)(xs)
+      })
+
+      it('does not allow a mismatched element type to the Array', () => {
+        const xs: Array<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = contains('foo')(xs)
+      })
+
+      it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
+        const xs: $ReadOnlyArray<number> = [1]
+        // $FlowExpectedError
+        const result: boolean = contains('foo')(xs)
+      })
+
+      it('returns a boolean for two strings', () => {
+        const result: boolean = contains('foo')('bar')
+      })
+
+      it('disallows a mismatched string and anything else', () => {
+        // $FlowExpectedError
+        const result: boolean = contains(1)('bar')
+      })
+    })
+  })
+
+  describe('startsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.startsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is starting in another array', () => {
+      const result: boolean = _.startsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.startsWith%28%5B1%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the starting of an array', () => {
+      const result: boolean = _.startsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.startsWith%28%5B1%2C%202%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.startsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.startsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.startsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  describe('endsWith', () => {
+    it('checks to see if one string is inside of another', () => {
+      const result: boolean = _.endsWith("a")("abc");
+    })
+
+    it('checks to see if one element of an array is ending in another array', () => {
+      const result: boolean = _.endsWith(["a"], ["a", "b", "c"]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20more%20than%20just%20strings%3A%0AR.endsWith%28%5B3%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('can check any type (not just strings) for the ending of an array', () => {
+      const result: boolean = _.endsWith([1], [1, 2, 3]);
+    })
+
+    // See https://ramdajs.com/repl/?v=0.25.0#?%2F%2F%20Works%20with%20multiple%20elements%20in%20the%20comparator%3A%0AR.endsWith%28%5B2%2C%203%5D%2C%20%5B1%2C%202%2C%203%5D%29%20%20%20%20%2F%2F%3D%3E%20true
+    // for a working example.
+    it('allows any number of elements to be used as the comparator', () => {
+      const result: boolean = _.endsWith([1, 2, 3], [1, 2, 3]);
+    })
+
+    it('catches mismatches between the first set and the second', () => {
+      // $FlowExpectedError
+      _.endsWith("1", [1, 2, 3])
+    })
+
+    it('catches mismatches between the inner array elements', () => {
+      // It is not understood why this isn't flagged as an error.
+      // $ShouldExpectErrorButInsteadWorksPleaseFix
+      _.endsWith(["1"], [1, 2, 3])
+    })
+  })
+
+  const chainxs: number[] = _.chain((n) => [n, n], [1, 2])
+  const chainxs1: number[] = _.chain((n) => [n, n])([1, 2])
+
+  const findxs: ?{ [k: string]: number | string, ... } = _.find(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs1: ?{ [k: string]: number | string, ... } = _.find(_.propEq("a", 4))(
+    os
+  );
+  // Ramda doesn't strictly break if you pass it an object, but it always
+  // returns undefined.
+  // $FlowExpectedError
+  const findObj = find(o => o == "bar", { foo: "bar" });
+
+  const findxs2: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 2),
+    os
+  );
+  const findxs3: ?{ [k: string]: number | string, ... } = _.findLast(
+    _.propEq("a", 4)
+  )(os);
+  const findxs4: number = _.findIndex(_.propEq("a", 2), os);
+  const findxs5: number = _.findIndex(_.propEq("a", 4))(os);
+  const findxs6: number = _.findLastIndex(_.propEq("a", 2), os);
+  const findxs7: number = _.findLastIndex(_.propEq("a", 4))(os);
+
+
+  describe('length', () => {
+    describe('works on', () => {
+      it('empty array', () => {
+        length([])
+      })
+      it('simple array of strings', () => {
+        length(ss)
+      })
+      it('heterogeneous arrays', () => {
+        length([1, '', ss, true, ns])
+      })
+      it('strings', () => {
+        length(str)
+      })
+      it('objects defining numeric .length property', () => {
+        length({length: 12})
+      })
+    })
+    describe('fails on', () => {
+      it('null and undefined', () => {
+        // $FlowExpectedError
+        length(null)
+        // $FlowExpectedError
+        length()
+      })
+      it('types that has no length', () => {
+        // $FlowExpectedError
+        length(123)
+      })
+      it('non-numeric .length property', () => {
+        // $FlowExpectedError
+        length({length: 'size'})
+      })
+    })
+  })
+
+  const s4 = _.find(x => x === "2", ["1", "2"]);
+  //$FlowExpectedError
+  const s5: ?{ [key: string]: string, ... } = _.find(x => x === "2", { a: 1, b: 2 });
+  const s6: number = _.findIndex(x => x === "2", ["1", "2"]);
+  const s7: number = _.findIndex(x => x === "2", { a: "1", b: "2" });
+  const forEachxs = _.forEach(x => console.log(x), ns);
+
+  const forEachObj = _.forEachObjIndexed((value, key) => {}, { x: 1, y: 2 });
+
+  const groupedBy: { [k: string]: Array<number>, ... } = _.groupBy(
+    x => (x > 1 ? "more" : "less"),
+    ns
+  );
+  //$FlowExpectedError
+  const groupedBy1: { [k: string]: Array<string>, ... } = _.groupBy(
+    x => (x > 1 ? "more" : "less")
+  )(ns);
+
+  const groupedWith: Array<Array<number>> = _.groupWith(x => x > 1, ns);
+  const groupedWith1: Array<Array<string>> = _.groupWith(x => x === "one")(ss);
+
+  const xOfXs: ?number = _.head(ns);
+  const xOfXs2: ?number = _.head(ns);
+  const xOfStr: string = _.head(str);
+
+  const transducer = _.compose(_.map(_.add(1)), _.take(2));
+
+  const txs: Array<number> = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs1: string = _.into([], transducer, ns);
+  //$FlowExpectedError
+  const txs2: string = _.into([], transducer, ss);
+
+  const ind: number = _.indexOf(1, ns);
+  const ind1: number = _.indexOf(str)(ss);
+  const ind2: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s",
+    os
+  );
+  const ind3: { [key: string]: { [k: string]: number | string, ... }, ... } = _.indexBy(
+    x => "s"
+  )(os);
+  const ind4: number = _.indexOf(null)(ss);
+
+  const insxs: Array<number> = _.insert(1, 2, ns);
+  const insxs2: Array<string> = _.insert(1, "2", ss);
+
+  const insxs3: Array<number> = _.insertAll(1, [2, 3], ns);
+  // this is disgusting — don't do this :)
+  // Technically it's a tuple with arbitrary size
+  const insxs4: Array<number | boolean | string> = _.insertAll(
+    1,
+    ["2", false],
+    ns
+  );
+  const insxs5: Array<string | number> = _.insertAll(1, [2], ss);
+
+  const joinxs: string = _.join("|", ns);
+
+  const lastxs: ?number = _.last(ns);
+  const laststr: string = _.last(str);
+
+  const lasti: number = _.lastIndexOf(3, [-1, 3, 3, 0, 1, 2, 3, 4]);
+
+  const mapxs: Array<number> = _.map(x => x + 1, ns);
+
+  const someObj: {
+    a: string,
+    b: number,
+    ...
+  } = { a: 'a', b: 2 }
+  const someMap: { [string]: {
+    a: string,
+    b: number,
+    ...
+  }, ... } = { so: someObj }
+  const mapObj: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a)(someMap)
+  const mapObj2: { [string]: string, ... } = _.map((x: {
+    a: string,
+    b: number,
+    ...
+  }): string => x.a, someMap)
+
+  const functor = {
+    x: 1,
+    map(f) {
+      return f(this.x);
+    }
+  };
+
+  // Doesn't typecheck (yet) but at least doesn't break
+  const mapFxs = _.map(_.toString, functor);
+
+  const double = x => x * 2;
+  const dxs: Array<number> = _.map(double, [1, 2, 3]);
+  const dos: $Shape<typeof obj> = _.map(double, obj);
+
+  const appender = (a, b) => [a + b, a + b];
+  const mapacc: [number, Array<number>] = _.mapAccum(appender, 0, ns);
+  const mapacc1: [number, Array<number>] = _.mapAccumRight(appender, 0, ns);
+
+  const nxs: boolean = _.none(x => x > 1, ns);
+
+  const nthxs: ?string = _.nth(2, ["curry"]);
+  const nthxs1: ?string = _.nth(2)(["curry"]);
+  //$FlowExpectedError
+  const nthxs2: string = _.nth(2, [1, 2, 3]);
+
+  const xxs: Array<number> = _.append(1, [1, 2, 3]);
+  const xxxs: Array<number> = _.intersperse(1, [1, 2, 3]);
+
+  const pairxs: [number, string] = _.pair(2, "str");
+
+  const pl: Array<number | string> = _.pluck("a")([{ a: "1" }, { a: 2 }]);
+  const pl1: Array<number> = _.pluck(0)([[1, 2], [3, 4]]);
+
+  const rxs: Array<number> = _.range(1, 10);
+
+  const remxs: Array<string> = _.remove(0, 2, ss);
+  const remxs1: Array<string> = _.remove(0, 2)(ss);
+  const remxs2: Array<string> = _.remove(0)(2)(ss);
+  const remxs3: Array<string> = _.remove(0)(2, ss);
+
+  const ys4: Array<string> = _.repeat("1", 10);
+  const ys5: Array<number> = _.repeat(1, 10);
+
+  // reduce
+  const redxs: number = reduce(_.add, 10, ns);
+  const redxs1: string = reduce(_.concat, "", ss);
+  const redxs2: Array<string> = reduce(_.concat, [])(_.map(x => [x], ss));
+  // Example used in docs: http://ramdajs.com/docs/#reduce
+  const redxs4: number = reduce(subtract, 0, [1, 2, 3, 4]);
+  // Using accumulator type that differs from the element type (A and B).
+  const redxs5: number = reduce((acc, s) => acc + parseInt(s), 0, [
+    "1",
+    "2",
+    "3"
+  ]);
+
+  const redux6a: number = reduce((acc, s) => _.reduced(acc), 0, ns)
+  const redux6b: number = reduce((acc: number, s: number) => _.reduced(acc), 0, ns)
+  const redxs7: number = reduce(
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(acc),
+    0,
+    ["1", "2", "3"]
+  );
+  // $FlowExpectedError
+  const redxs8: number = reduce(
+    // $FlowExpectedError
+    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(s),
+    0,
+    ["1", "2", "3"]
+  );
+
+  // Ramda works with $ReadOnlyArray as it is immutable.
+  const readOnlyArray: $ReadOnlyArray<number> = [1, 2, 3, 4];
+  // $ReadOnlyArray with curried permutations:
+  const redxsReadOnly3: number = reduce(subtract, 0, readOnlyArray);
+  const redxsReadOnly2_1: number = reduce(subtract, 0)(readOnlyArray);
+  const redxsReadOnly1_2: number = reduce(subtract)(0, readOnlyArray);
+  const redxsReadOnly1_1_1: number = reduce(subtract)(0)(readOnlyArray);
+
+  // $FlowExpectedError reduce will not work with an object.
+  reduce(subtract, 0, { foo: 1, bar: 2 });
+
+  // reduceRight
+  const redrxs1: number = _.reduceRight(_.add, 10, ns);
+  const redrxs2: string = _.reduceRight(_.concat, "", ss);
+  const redrxs3: Array<string> = _.reduceRight(_.concat, [])(
+    _.map(x => [x], ss)
+  );
+  const redrxs3a: string = _.reduceRight(
+    //$FlowExpectedError
+    (acc: string, value: number): string => acc,
+    "",
+    ns
+  );
+  const redrxs3b: string = _.reduceRight(
+    (value: number, acc: string): string => acc,
+    "",
+    ns
+  );
+
+  // $FlowExpectedError reduceRight does not support reduced.
+  const redrxs4: number = _.reduceRight(
+    // $FlowExpectedError reduceRight does not support reduced.
+    (acc, n) => acc < 4 ? acc + n : _.reduced(acc),
+    0,
+    ns
+  );
+
+  const scanxs6: Array<number> = _.scan(_.add)(10)(ns);
+  const scanxs7: Array<number> = _.scan(_.add, 10)(ns);
+  const scanxs8: Array<number> = _.scan(_.add)(10, ns);
+  const scanxs9: Array<number> = _.scan(_.add, 10, ns);
+  const scanxs10: Array<string> = _.scan(_.concat)("")(ss);
+  const scanxs11: Array<string> = _.scan(_.concat, "")(ss);
+  const scanxs12: Array<string> = _.scan(_.concat)("", ss);
+  const scanxs13: Array<string> = _.scan(_.concat, "", ss);
+
+  const reduceToNamesBy = _.reduceBy(
+    (acc, student) => acc.concat(student.name),
+    []
+  );
+  const namesByGrade = reduceToNamesBy(student => {
+    const score = student.score;
+    return score < 65
+      ? "F"
+      : score < 70 ? "D" : score < 80 ? "C" : score < 90 ? "B" : "A";
+  });
+  const students = [
+    { name: "Lucy", score: 92 },
+    { name: "Drew", score: 85 },
+    { name: "Bart", score: 62 }
+  ];
+  const names1: { [k: string]: Array<string>, ... } = namesByGrade(students);
+
+  const isOdd = (acc, x) => x % 2 === 1;
+  const reduceWhile1: number = _.reduceWhile(isOdd, _.add, 0, [1, 3, 5, 60, 777, 800]);
+  const reduceWhile2: number = _.reduceWhile(isOdd, _.add, 111, [2, 4, 6]);
+
+  const spl: Array<string> = _.split(/\./, "a.b.c.xyz.d");
+
+  const spl1: [Array<number>, Array<number>] = _.splitAt(1, [1, 2, 3]);
+  const spl2: [string, string] = _.splitAt(5, "hello world");
+  const spl3: [string, string] = _.splitAt(-1, "foobar");
+  const spl4: Array<Array<number>> = _.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]);
+  const spl5: Array<string> = _.splitEvery(3, "foobarbaz");
+  const spl6: [Array<number>, Array<number>] = _.splitWhen(_.equals(2))([
+    1,
+    2,
+    3,
+    1,
+    2,
+    3
+  ]);
+
+  const slixs: Array<string> = _.slice(0, 2, ss);
+  const slixs1: Array<string> = _.slice(0, 2)(ss);
+  const slixs2: Array<string> = _.slice(0)(2)(ss);
+  const slixs3: Array<string> = _.slice(0)(2, ss);
+
+  const diff = function(a, b) {
+    return a - b;
+  };
+  const sortxs: Array<number> = _.sort(diff, [4, 2, 7, 5]);
+
+  const timesxs: Array<number> = _.times(_.identity, 5);
+
+  const unf: (x: string) => Array<string> = _.unfold(
+    (x: string) => x.length > 10 || [x, x + "0"]
+  );
+  const unf1: Array<number> = _.unfold(x => x > 10 || [x, x + 1], 0);
+  const f = n => (n > 50 ? false : [-n, n + 10]);
+  const unf11: Array<number> = _.unfold(f, 10);
+
+  //$FlowExpectedError
+  const unf2 = _.unfold(x => x.length > 10 || [x, x + "0"], 2);
+
+  const unby: Array<number> = _.uniqBy(Math.abs)([-1, -5, 2, 10, 1, 2]);
+
+  const strEq = _.eqBy(String);
+  const strEq2 = _.eqBy(String, 1, 2);
+  const unw = _.uniqWith(strEq)([1, "1", 2, 1]);
+  const unw1 = _.uniqWith(strEq)([{}, {}]);
+  const unw2 = _.uniqWith(strEq)([1, "1", 1]);
+  const unw3 = _.uniqWith(strEq)(["1", 1, 1]);
+
+  //$FlowExpectedError
+  const ys6: { [key: string]: string, ... } = _.fromPairs([["h", 2]]);
+
+  const withoutxs: Array<number> = _.without([1, 2], ns);
+  const withoutxs1: Array<string> = _.without(["a"], ss);
+
+  const xprodxs: Array<[number, string]> = _.xprod([1, 2], ["a", "b", "c"]);
+  const xprodxs1: Array<[boolean, string]> = _.xprod([true, false])(["a", "b"]);
+
+  const zipxs: Array<[number, string]> = _.zip([1, 2, 3], ["a", "b", "c"]);
+
+  //$FlowExpectedError
+  const zipxs1: Array<[number, string]> = _.zip([true, false])(["a", "b"]);
+
+  const zipos: { [k: string]: number, ... } = _.zipObj(["a", "b", "c"], [1, 2, 3]);
+
+  const ys9: { [k: string]: number, ... } = _.zipObj(["me", "you"], [1, 2]);
+  const zipped: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3],
+    ["1", "2", "3"]
+  );
+  const zipped2: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith(
+    (a, b) => ({ s: a, y: b }),
+    [1, 2, 3]
+  )(["1", "2", "3"]);
+  const zipped3: Array<{
+    s: number,
+    y: string,
+    ...
+  }> = _.zipWith((a, b) => ({
+    s: a,
+    y: b
+  }))([1, 2, 3])(["1", "2", "3"]);
+}
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_logic.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_logic.js
new file mode 100644
index 0000000000..fec2dc8e7e
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_logic.js
@@ -0,0 +1,281 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  complement,
+  compose,
+  curry,
+  filter,
+  find,
+  ifElse,
+  pipe,
+  repeat,
+  zipWith,
+} from 'ramda';
+import { describe, it } from 'flow-typed-test';
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ['one', 'two', 'three', 'four'];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: 'd' };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: 'd' }, { b: 2 }];
+const str: string = 'hello world';
+
+//Logic
+// TODO: Fix flow issues
+// const isQueen = _.propEq("rank", "Q");
+// const isSpade = _.propEq("suit", "♠︎");
+// const isQueenOfSpades = _.allPass([isQueen, isSpade]);
+
+//$FlowExpectedError
+const allp: boolean = isQueenOfSpades(1);
+const allp1: boolean = isQueenOfSpades({ rank: 'Q', suit: '♣︎' });
+
+const a: boolean = _.and(true, true);
+const a_: (a: boolean) => boolean = _.and(true);
+
+const nonBooleanAnd: number = _.and(69, 42);
+const nonBooleanAnd_: (nonBooleanAnd: number) => any = _.and(69);
+
+const gte = _.anyPass([_.gt, _.equals]);
+const ge: boolean = gte(3, 2);
+
+//$FlowExpectedError
+const gt10 = x => x > 10;
+//$FlowExpectedError
+const even = x => x % 2 === 0;
+const f = _.both(gt10, even);
+
+const b: boolean = f('');
+const b_: boolean = f(100);
+
+describe('complement', () => {
+  it('accepts a function that returns a boolean', () => {
+    complement(() => true)
+    complement(() => false)
+    // $FlowExpectedError
+    complement(() => 'foo')
+    // $FlowExpectedError
+    complement(() => 5)
+    // $FlowExpectedError
+    complement(() => [])
+    // $FlowExpectedError
+    complement(() => ({}))
+    // $FlowExpectedError
+    complement(() => null)
+    // $FlowExpectedError
+    complement(() => undefined)
+  })
+
+  it('returns a function that returns a boolean', () => {
+    const fn = complement(() => true)
+    const b: boolean = fn()
+    // $FlowExpectedError
+    const s: string = fn()
+    // $FlowExpectedError
+    const n: number = fn()
+    // $FlowExpectedError
+    const xs: Array<mixed> = fn()
+    // $FlowExpectedError
+    const obj: {[string]: mixed} = fn()
+    // $FlowExpectedError
+    const v: void = fn()
+    // $FlowExpectedError
+    const nil: null = fn()
+  })
+
+  // The following code is generated from
+  // https://github.com/LoganBarnett/typedef-gen due to Flow not being able to
+  // preserve the input function's form as a return type.
+  //
+  // Begin generated complement test cases.
+  it('returns a function whose parameters match the input function (0)', () => {
+    const fn = complement(() => true)
+    fn()
+    // Extra arguments are discarded, so there is no negative case here.
+  })
+
+  it('returns a function whose parameters match the input function (1)', () => {
+    const fn = complement((a: 'a',) => true)
+    fn('a',)
+    // $FlowExpectedError
+    fn(0)
+  })
+
+  it('returns a function whose parameters match the input function (2)', () => {
+    const fn = complement((a: 'a', b: 'b',) => true)
+    fn('a', 'b',)
+    // $FlowExpectedError
+    fn(0, 1)
+  })
+
+  it('returns a function whose parameters match the input function (3)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c',) => true)
+    fn('a', 'b', 'c',)
+    // $FlowExpectedError
+    fn(0, 1, 2)
+  })
+
+  it('returns a function whose parameters match the input function (4)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd',) => true)
+    fn('a', 'b', 'c', 'd',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3)
+  })
+
+  it('returns a function whose parameters match the input function (5)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e',) => true)
+    fn('a', 'b', 'c', 'd', 'e',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4)
+  })
+
+  it('returns a function whose parameters match the input function (6)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5)
+  })
+
+  it('returns a function whose parameters match the input function (7)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6)
+  })
+
+  it('returns a function whose parameters match the input function (8)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7)
+  })
+
+  it('returns a function whose parameters match the input function (9)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8)
+  })
+
+  it('returns a function whose parameters match the input function (10)', () => {
+    const fn = complement((a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f', g: 'g', h: 'h', i: 'i', j: 'j',) => true)
+    fn('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',)
+    // $FlowExpectedError
+    fn(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+  })
+
+  // End generated complement test cases.
+})
+
+const fn = _.cond([
+  [_.equals(0), _.always('water freezes at 0°C')],
+  [_.equals(100), _.always(1)],
+  [_.T, temp => 'nothing special happens at ' + temp + '°C'],
+]);
+const cond_: number | string = fn(0);
+
+// This is abit awkward — if a non-null value of type
+// differrent to number is passed flow will infer a union type
+// for all of them
+const defaultTo42 = _.defaultTo(42);
+const def: number = defaultTo42(null);
+const def1: number = defaultTo42(undefined);
+
+const feither = _.either(gt10, even);
+const feitherR: boolean = f(101);
+
+describe('ifElse', () => {
+  it('uses a union of both branches as the return type', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    const ie: number | string = incCount(1);
+  })
+
+  it('checks the condition input matches the branch inputs', () => {
+    const incCount = ifElse(x => x % 2 == 0, x => x + 1, x => x.toString());
+    // Because the object literal ({}) isn't a number it
+    // $FlowExpectedError
+    const ie: number | string = incCount({});
+  })
+
+  it('works with variadic arg inputs', () => {
+    const ifElseFn = ifElse(
+      // Without this test, variadic argument input functions will produce an
+      // error like this:
+      //
+      // Cannot call `ifElse` because rest array [1] has an unknown number of
+      // elements, so is incompatible with tuple type [2].
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    const result: void | string = ifElseFn('input')
+  })
+
+  it('preserves the types used with variadic argument condition functions', () => {
+    const ifElseFn = ifElse(
+      (...args: [string]): boolean => true,
+      (s: string) => s.toUpperCase(),
+      (s: string) => s.toLowerCase(),
+    );
+    // $FlowExpectedError
+    const result: void | string = ifElseFn(5)
+  })
+
+  // This was the original test for ifElse, which depends on the implementation
+  // of "is". "is" in its present form does not perform type refinement, so the
+  // stricter form of ifElse fails the check with this test. This test below
+  // captures the issue, and is left for reference and/or if some brave soul
+  // wishes to expand the definition of ifElse (and possibly also "is") to
+  // refine the predicate correctly. At time of writing, $Pred and $Refine are
+  // considered experimental/internal and abandoned:
+  // https://github.com/facebook/flow/issues/2464#issuecomment-471115953
+  //
+  // it('feeds a predicate-refined type to the branches', () => {
+  //   const incCount = ifElse(is(Number), x => x + 1, x => x.toString());
+  //   const ie: number | string = incCount(1);
+  // })
+})
+
+const n: boolean = _.not(true);
+//$FlowExpectedError
+const n1: boolean = _.not(1);
+
+const oor: boolean = _.or(true, true);
+
+const nonBooleanOr: ?string = _.or('watskeburt', undefined);
+const nonBooleanOr_: (arg: { key: string, ... }) => string | { key: string, ... } = _.or(
+  'watskeburt'
+);
+
+// type refinement is important here
+// which might be awkward for some
+// but can actually catch some bugs statically
+
+const psatE: boolean = _.pathSatisfies(y => y > 0, ['x', 'y'], { x: { y: 2 } });
+const psat: boolean = _.pathSatisfies(
+  y => typeof y === 'number' && y > 0,
+  ['x', 'y'],
+  { x: { y: 2 } }
+);
+const psatPart = _.pathSatisfies(y => typeof y === 'number' && y > 0);
+const psat2: boolean = psatPart(['x', 'y'])({ x: { y: 2 }, z: true });
+const psatPart2 = _.pathSatisfies(y => typeof y === 'number' && y > 0, [
+  'x',
+  'y',
+]);
+const psat3: boolean = psatPart2({ x: { y: 2 }, z: true });
+
+const propSat: boolean = _.propSatisfies(x => x > 0, 'x', { x: 1, y: 2 });
+const coerceArray = _.unless(_.isArrayLike, _.of);
+const coer: Array<number | Array<number>> | number = coerceArray([1, 2, 3]);
+const coer1: Array<number | Array<number>> | number = coerceArray(1);
+
+const coerceString = _.unless(_.is(String), _.toString);
+const coer2: string | Array<number> = coerceString([1, 2, 3]);
+const coer3: string | Array<number> = coerceString('s');
+
+const unlPrt = _.unless(_.is(Number), _.T);
+const unl: number | boolean | Array<number> = unlPrt([1, 2, 3]);
+const unl2: number | boolean | Array<number> = unlPrt(1);
+
+const un: number = _.until(_.gt(100), _.multiply(2))(1);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_map.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_map.js
new file mode 100644
index 0000000000..0134d30784
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_map.js
@@ -0,0 +1,97 @@
+// @flow
+import * as R from "ramda";
+import { it, describe } from "flow-typed-test";
+
+const NumberToString = (v: number): string => `${v}`;
+
+describe("R.map()", () => {
+  describe("Not read only", () => {
+    it("should return Array<string>", () => {
+      const ArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, ArrNumbers): Array<string>);
+
+      (R.map(NumberToString)(ArrNumbers): Array<string>);
+    });
+
+    it("should return Object {key: number}", () => {
+      const Obj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), Obj): { [key: string]: number, ... });
+
+      (R.map(R.prop("key"))(Obj): { [key: string]: number, ... });
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: Array<number>;
+
+        map<T>(fn: (e: number) => T): Array<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return array string", () => {
+        (R.map(NumberToString, new Index()): Array<string>);
+
+        (R.map(NumberToString)(new Index()): Array<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): Array<string>);
+      });
+    });
+  });
+
+  describe("Read Only", () => {
+    it("should return readonly Array", () => {
+      const readOnlyArrNumbers = Object.freeze([1, 2, 3]);
+
+      (R.map(NumberToString, readOnlyArrNumbers): $ReadOnlyArray<string>);
+
+      (R.map(NumberToString)(readOnlyArrNumbers): $ReadOnlyArray<string>);
+    });
+
+    it("should return readonly Object", () => {
+      const readOnlyObj = Object.freeze({
+        a: { key: 1 },
+        c: { key: 2 },
+        d: { key: 3 }
+      });
+
+      (R.map(R.prop("key"), readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+
+      (R.map(R.prop("key"))(readOnlyObj): $ReadOnly<{ [key: string]: number, ... }>);
+    });
+
+    describe("{}::map(fn)", () => {
+      class Index {
+        ids: $ReadOnlyArray<number>;
+
+        map<T>(fn: (e: number) => T): $ReadOnlyArray<T> {
+          return this.ids.map(e => fn(e));
+        }
+      }
+
+      it("should return read only Array<string>", () => {
+        (R.map(NumberToString, new Index()): $ReadOnlyArray<string>);
+
+        (R.map(NumberToString)(new Index()): $ReadOnlyArray<string>);
+      });
+
+      it("raises an error when passed fn incompatible with Index map function", () => {
+        const fn = (s: string): string => "";
+
+        // $FlowExpectedError
+        (R.map(fn, new Index()): $ReadOnlyArray<string>);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_math.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_math.js
new file mode 100644
index 0000000000..4e47ef7d1f
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_math.js
@@ -0,0 +1,32 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+
+import { describe, it } from 'flow-typed-test';
+import {
+  subtract,
+} from 'ramda'
+
+describe('subtract', () => {
+  it('works with two numbers', () => {
+    const result: number = subtract(1, 2)
+  })
+
+  // To see Ramda working with various date combinations, see:
+
+  it('works with dates to produce a number', () => {
+    const result: number = subtract(new Date(), new Date())
+  })
+
+  it('works with a date and a number to produce a number', () => {
+    const result: number = subtract(new Date(), 1000)
+  })
+
+  it('works with a number and a date to produce a number', () => {
+    const result: number = subtract(1000, new Date())
+  })
+
+  it('does not accept strings as inputs', () => {
+    // $FlowExpectedError
+    const result: number = subtract('foo', 'o')
+  })
+})
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_misc.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_misc.js
new file mode 100644
index 0000000000..3040d77404
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_misc.js
@@ -0,0 +1,59 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, {
+  compose,
+  pipe,
+  curry,
+  filter,
+  find,
+  isNil,
+  repeat,
+  zipWith
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+// Math
+{
+  const partDiv: (a: number) => number = _.divide(6);
+  const div: number = _.divide(6, 2);
+  //$FlowExpectedError
+  const div2: number = _.divide(6, true);
+}
+
+// String
+{
+  const ss: Array<string | void> = _.match(/h/, "b");
+  const ss3: string = _.replace(",", "|", "b,d,d");
+  const ss2: Array<string> = _.split(",", "b,d,d");
+  const ss1: boolean = _.test(/h/, "b");
+  const s: string = _.trim("s");
+  const x: string = _.head("one");
+  const sss: string = _.concat("H", "E");
+  const sss1: string = _.concat("H")("E");
+  const ssss: string = _.drop(1, "EF");
+  const ssss1: string = _.drop(1)("E");
+  const ssss2: string = _.dropLast(1, "EF");
+  const ys: string = _.nth(2, "curry");
+  const ys1: string = _.nth(2)("curry");
+}
+//Type
+{
+  const x: boolean = _.is(Number, 1);
+  const x1: boolean = isNil(1);
+
+  // should refine type
+  const x1a: ?{ a: number, ... } = { a: 1 };
+  //$FlowExpectedError
+  x1a.a;
+  if (!isNil(x1a)) {
+    x1a.a;
+  }
+
+  const x2: boolean = _.propIs(1, "num", { num: 1 });
+}
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_object.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_object.js
new file mode 100644
index 0000000000..1326cc983d
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_object.js
@@ -0,0 +1,484 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import { describe, it } from 'flow-typed-test';
+import _, {
+  compose,
+  curry,
+  filter,
+  find,
+  pipe,
+  repeat,
+  values,
+  zipWith,
+  propOr,
+  __
+} from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+describe("Object", () => {
+  describe("assoc", () => {
+    it("should return more exact type when passed key hasn't in passed object", () => {
+      (_.assoc("c", "s", { a: 1, b: 2 }): {
+        a: number,
+        b: number,
+        c: string,
+        ...
+      });
+
+      (_.assoc("x", { x1: 11 }, { y: ["y1"] }): {
+        x: { [string]: number, ... },
+        y: Array<string>,
+        ...
+      });
+    });
+
+    it("should return sum types when passed key already has in passed object", () => {
+      (_.assoc("a", "s", { a: 1, b: 2 }): {
+        a: number | string,
+        b: number | string,
+        ...
+      });
+    });
+  });
+
+  describe('propOr', () => {
+    const testObj = {
+      name: 'Wilson'
+    };
+
+    describe('should return default', () => {
+      it('with __', () => {
+        const def1_1: number = propOr(__, 'age', testObj)(32);
+        const def1_2: number = propOr(__, 'age', null)(32);
+        const def1_3: number = propOr(__, 'age', undefined)(32);
+        const def1_4: number = propOr(__, 'age', 'string')(32);
+        const def1_5: number = propOr(__, 'age', 50)(32);
+
+        const def2_1: number = propOr(32, __, testObj)('age');
+        const def2_2: number = propOr(32, __, null)('age');
+        const def2_3: number = propOr(32, __, undefined)('age');
+        const def2_4: number = propOr(32, __, 'string')('age');
+        const def2_5: number = propOr(32, __, 50)('age');
+
+        const def3_1: number = propOr(32, 'age', __)(testObj);
+        const def3_2: number = propOr(32, 'age', __)(null);
+        const def3_3: number = propOr(32, 'age', __)(undefined);
+        const def3_4: number = propOr(32, 'age', __)('string');
+        const def3_5: number = propOr(32, 'age', __)(50);
+
+        const def4_1: number = propOr(__, 'age')(32)(testObj);
+        const def4_2: number = propOr(__, 'age')(32)(null);
+        const def4_3: number = propOr(__, 'age')(32)(undefined);
+        const def4_4: number = propOr(__, 'age')(32)('string');
+        const def4_5: number = propOr(__, 'age')(32)(50);
+
+        const def5_1: number = propOr(32, __)('age')(testObj);
+        const def5_2: number = propOr(32, __)('age')(null);
+        const def5_3: number = propOr(32, __)('age')(undefined);
+        const def5_4: number = propOr(32, __)('age')('string');
+        const def5_5: number = propOr(32, __)('age')(50);
+      });
+
+      it('without __', () => {
+        const def1_1: number = propOr(32, 'age', testObj);
+        const def1_2: number = propOr(32, 'age', null);
+        const def1_3: number = propOr(32, 'age', undefined);
+        const def1_4: number = propOr(32, 'age', 'string');
+        const def1_5: number = propOr(32, 'age', 50);
+
+        const def2_1: number = propOr(32, 'age')(testObj);
+        const def2_2: number = propOr(32, 'age')(null);
+        const def2_3: number = propOr(32, 'age')(undefined);
+        const def2_4: number = propOr(32, 'age')('string');
+        const def2_5: number = propOr(32, 'age')(50);
+
+        const def3_1: number = propOr(32)('age', testObj);
+        const def3_2: number = propOr(32)('age', null);
+        const def3_3: number = propOr(32)('age', undefined);
+        const def3_4: number = propOr(32)('age', 'string');
+        const def3_5: number = propOr(32)('age', 50);
+
+        const def4_1: number = propOr(32)('age')(testObj);
+        const def4_2: number = propOr(32)('age')(null);
+        const def4_3: number = propOr(32)('age')(undefined);
+        const def4_4: number = propOr(32)('age')('string');
+        const def4_5: number = propOr(32)('age')(50);
+      });
+    });
+
+    describe('should return type from testObj', () => {
+      it('without __', () => {
+        const objType1: string = propOr(32, 'name', testObj);
+        const objType2: string = propOr(32, 'name')(testObj);
+        const objType3: string = propOr(32)('name', testObj);
+        const objType4: string = propOr(32)('name')(testObj);
+      });
+
+      it('with __', () => {
+        const objType1: string = propOr(__, 'name', testObj)(32);
+        const objType2: string = propOr(32, __, testObj)('name');
+        const objType3: string = propOr(32, 'name', __)(testObj);
+        const objType4: string = propOr(__, 'name')(32)(testObj);
+        const objType5: string = propOr(32, __)('name')(testObj);
+      });
+    });
+  });
+});
+
+const apath: { [k: string]: number | string | Object, ... } = _.assocPath(
+  ["a", "b", "c"],
+  "s",
+  { a: { b: { c: 0 } } }
+);
+
+const tomato = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 },
+  id: 123
+};
+const tomato1 = {
+  firstName: "  Tomato ",
+  data: { elapsed: 100, remaining: 1400 }
+};
+
+// TODO: Started failing in v31...
+// const transformations = {
+//   firstName: _.trim,
+//   lastName: _.trim,
+//   data: {
+//     elapsed: _.add(1),
+//     remaining: _.add(-1),
+//   },
+// }
+// const evolved:{firstName: string, data: {elapsed: number, remaining: number}, id: number} = _.evolve(transformations, tomato)
+
+const objects = [{}, {}, {}];
+const objectsClone: Array<Object> = _.clone(objects);
+const objectsClone1: number = _.clone(1);
+const objectsClone2: typeof tomato = _.clone(tomato);
+//$FlowExpectedError
+const objectsClone3: $Shape<typeof tomato1> = _.clone(tomato);
+const objectsClone4: $Shape<typeof tomato1> = _.clone(tomato1);
+
+const id = objectsClone2.id;
+//$FlowExpectedError
+const idE = objectsClone4.id;
+
+const dissocd: { a: number, ... } = _.dissoc("b", { a: 1, b: 2 });
+const dissocd2: { a: number, ... } = _.dissoc("b")({ a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd3: { a: string, ... } = _.dissoc("b", { a: 1, b: 2 });
+//$FlowExpectedError
+const dissocd4: { a: string, ... } = _.dissoc("b")({ a: 1, b: 2 });
+
+const dissocPathd: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+const dissocPathd2: { a: { b: number, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+//$FlowExpectedError
+const dissocPathd3: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"], {
+  a: { b: 1, c: 2 }
+});
+//$FlowExpectedError
+const dissocPathd4: { a: { b: string, ... }, ... } = _.dissocPath(["a", "c"])({
+  a: { b: 1, c: 2 }
+});
+
+
+const o1 = { a: 1, b: 2, c: 3, d: 4 };
+const o2 = { a: 10, b: 20, c: 3, d: 40 };
+
+const ep: boolean = _.eqProps("a", o1, o2);
+
+// curried versions
+const epCurr: boolean = _.eqProps("a")(o1, o2);
+const ep2: boolean = _.eqProps("c", o1)(o2);
+
+const evolved1 = _.evolve(
+  {
+    foo: x => x + 1,
+    bar: x => x + 2
+  },
+  {
+    foo: 1,
+    bar: 2
+  }
+);
+const evolved2 = _.evolve({
+  foo: x => x + 1,
+  bar: x => x + 2
+})({
+  foo: 1,
+  bar: 2
+});
+const evolved3 = _.evolve(
+  {
+    foo: x => x + 1
+  },
+  {
+    bar: 1
+  }
+);
+const evolved4 = _.evolve({
+  foo: x => x + 1
+})({
+  bar: 1
+});
+//$FlowExpectedError
+const evolved5: number = evolved4.foo;
+//$FlowExpectedError
+const evolved6 = _.evolve(["foo"]);
+
+const hasid = _.has("id");
+const has: boolean = hasid(tomato);
+
+function Rectangle(width, height) {
+  this.width = width;
+  this.height = height;
+}
+Rectangle.prototype.area = function() {
+  return this.width * this.height;
+};
+
+const square = new Rectangle(2, 2);
+const hasIn: boolean = _.hasIn("width", square);
+const hasIn1: boolean = _.hasIn("area", square);
+
+const raceResultsByFirstName = {
+  first: "alice",
+  second: "jake",
+  third: "alice"
+};
+const inverted: { [k: string]: Array<string>, ... } = _.invert(
+  raceResultsByFirstName
+);
+const inverted1: { [k: string]: string, ... } = _.invertObj(raceResultsByFirstName);
+
+const ks: Array<string> = _.keys(raceResultsByFirstName);
+const ksMaybe: Array<string> = _.keys(null)
+const ksi: Array<string> = _.keysIn(square);
+
+const xs = { x: 1, y: 2, z: 3 };
+const prependKeyAndDouble = (num, key, obj) => key + num * 2;
+
+const obI: { [k: string]: string, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+//$FlowExpectedError
+const obI2: { [k: string]: number, ... } = _.mapObjIndexed(
+  prependKeyAndDouble,
+  xs
+);
+
+const ob1 = { a: 1 };
+const ob2 = { b: 3 };
+const ob3 = _.merge(ob1, ob2);
+//$FlowExpectedError
+const propX = ob3.x;
+const propA = ob3.a;
+
+const mwith = _.mergeWith(
+  (a, b) => Array.isArray(a) && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB: boolean = mwith.b;
+
+const mwithK = _.mergeWithKey(
+  (k, a, b) => Array.isArray(a) && k === "d" && _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB1: boolean = mwithK.b;
+
+const mDwith = _.mergeDeepWith(
+  _.concat,
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propmDwithB: boolean = mDwith.b;
+
+const concatValues = (k, l, r) => k == 'values' ? _.concat(l, r) : r
+const mDwithKey = _.mergeDeepWithKey(
+  concatValues,
+  { a: true, c: { thing: 'foo', values: [10, 20] }},
+  { b: true, c: { thing: 'bar', values: [15, 35] }}
+);
+const propmDwithKeyB: boolean = mDwithKey.b;
+
+const mDLeft = _.mergeDeepLeft(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB2: boolean = mDLeft.a;
+const propB3: boolean = mDLeft.b;
+const propB4: 10 = mDLeft.values[0];
+
+const mDRight = _.mergeDeepRight(
+  { a: true, values: [10, 20] },
+  { b: true, values: [15, 35] }
+);
+const propB5: boolean = mDRight.a;
+const propB6: boolean = mDRight.b;
+const propB7: 15 = mDRight.values[0];
+
+const objA = _.objOf("a", false);
+//$FlowExpectedError
+const propAA: number = objA.a;
+
+const om: Object = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4 });
+const omap1 = _.omit(["a", "d", "h"], { a: 1, b: 2, c: 3, d: 4, h: 7 });
+const omap2 = _.omit(["a", "d", "h"])({ a: 1, b: 2, c: 3, d: 4 });
+
+const path1: Object | number = _.path(["a", "b"], { a: { b: 2 } });
+const path2: Object | number = _.path(["a", 1], { a: { "1": 2 } });
+const path3: ?Object = _.path(["a", "b"], { c: { b: 2 } });
+const path4: void = _.path(["a"], null);
+
+const pathOr: string | Object | number = _.pathOr("N/A", ["a", "b"], {
+  a: { b: 2 }
+});
+
+const pck: Object = _.pick(["a", "d"], { a: 1, b: 2, c: 3, d: 4 });
+
+const ooo = { a: 1, b: 2, A: 3, B: 4 };
+const isUpperCase = (val, key) => key.toUpperCase() === key;
+const pb: Object = _.pickBy(isUpperCase, ooo);
+
+const ppp: number = _.prop("x", { x: 100 });
+//$FlowExpectedError
+const ppp1: number = _.prop("y", { x: 100 });
+const ppp2: number = _.prop("x")({ x: 100 });
+//$FlowExpectedError
+const ppp3: string = _.prop("x", { x: 100 });
+const ppp4: number = _.prop(_.__, { x: 100 })("x");
+//$FlowExpectedError
+const ppp5: number = _.prop(_.__, { x: 100 })("y");
+const ppp6: number = _.prop("x", ({ x: 1, y: "a" }: {
+  x: number,
+  y: string,
+  ...
+}));
+const ppp7: number = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+//$FlowExpectedError
+const ppp8: string = _.prop("x", ({ x: 1 }: { [string]: number, ... }));
+
+const alice = {
+  name: "ALICE",
+  age: 101
+};
+
+const favoriteWithDefault = _.propOr("Ramda", "favoriteLibrary");
+const fav = favoriteWithDefault(alice);
+
+const nameWithDefault = _.propOr("Ramda", "name");
+const nm: number | string = nameWithDefault(alice);
+
+const pss1: Array<number | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+const pss2: Array<number | boolean> = _.props(
+  ["x", "y"],
+  ({ x: true, y: 2, z: "foo" }: {
+  x: boolean,
+  y: number,
+  ...
+})
+);
+const pss3: Array<number> = _.props(["y"], { x: true, y: 2, z: "foo" });
+const pss4: Array<number> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+//$FlowExpectedError -- wrong key
+const pssE1: Array<number | boolean> = _.props(["d", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type
+const pssE2: Array<string | boolean> = _.props(["x", "y"], {
+  x: true,
+  y: 2,
+  z: "foo"
+});
+//$FlowExpectedError -- wrong type on indexer value
+const pssE3: Array<string> = _.props(["y"], ({ y: 2 }: { [string]: number, ... }));
+
+const top: Array<["a" | "b" | "c", number]> = _.toPairs({ a: 1, b: 2, c: 3 });
+
+//$FlowExpectedError
+const topE: Array<["a" | "b" | "c" | "z", number]> = _.toPairs({
+  a: 1,
+  b: 2,
+  c: 3
+});
+
+const F = function() {
+  this.x = "X";
+};
+F.prototype.y = "Y";
+const f = new F();
+const topin = _.toPairsIn(f);
+
+describe('values', () => {
+  it('provides a union per element when the types of all values vary', () => {
+    const val = values({ a: 1, b: 2, c: true });
+    const val1: number | boolean = val[0];
+  })
+
+  it('works with the example in the docs http://ramdajs.com/docs/#values', () => {
+    const vs: Array<number> = values({a: 1, b: 2, c: 3})
+  })
+})
+
+const pred = _.where({
+  a: (a: string) => a === "foo",
+  b: _.complement(_.equals("bar")),
+  c: (c: Object) => !!c,
+  x: _.gt(10),
+  y: _.lt(20),
+});
+
+const w: boolean = pred({ a: "foo", b: "xxx", c: {}, x: 11, y: 19 });
+
+const pred1 = _.whereEq({ a: 1, b: 2 });
+
+const win: boolean = pred1({ a: 1, d: 1 });
+
+const xLens = _.lens(_.prop('x'), _.assoc('x'));
+const xLensPath = _.lensPath(['y', 0, 'y']);
+const xLensIndex = _.lensIndex(0);
+const xLensProp = _.lensProp('x');
+
+const dataObj = {x: 5, y: [{y: 2, z: 3}, {y: 4, z: 5}]};
+const dataArr = ['a', 'b', 'c'];
+
+const xLensView: number = _.view(xLens, dataObj);
+const xLensSet: Array<{ [k: string]: any, ... }> = _.set(xLens, 4, dataObj);
+const xLensOver: Array<{ [k: string]: any, ... }> = _.over(xLens, _.negate, dataObj);
+
+const xLensPathView: number = _.view(xLensPath, dataObj);
+const xLensPathSet: Array<{ [k: string]: any, ... }> = _.set(xLensPath, 4, dataObj);
+const xLensPathSetCurr: Array<{ [k: string]: any, ... }> = _.set(xLensPath, 4)(dataObj);
+const xLensPathOver: Array<{ [k: string]: any, ... }> = _.over(xLensPath, _.negate, dataObj);
+const xLensPathOverCurr: Array<{ [k: string]: any, ... }> = _.over(xLensPath)(_.negate)(dataObj);
+
+const xLensIndexView: number = _.view(xLensIndex, dataArr);
+const xLensIndexSet: Array<string> = _.set(xLensIndex, "test", dataArr);
+const xLensIndexSetCurr: Array<string> = _.set(xLensIndex)("test", dataArr);
+const xLensIndexOver: Array<string> = _.over(xLensIndex, _.concat("test"), dataArr);
+const xLensIndexOverCurr: Array<string> = _.over(xLensIndex, _.concat("test"))(dataArr);
+
+const xLensPropView: number = _.view(xLensProp, dataObj);
+const xLensPropSet: Array<{ [k: string]: any, ... }> = _.set(xLensProp, 4, dataObj);
+const xLensPropOver: Array<{ [k: string]: any, ... }> = _.over(xLensProp, _.negate, dataObj);
+const xLensPropOverCurr: Array<{ [k: string]: any, ... }> = _.over(xLensProp)(_.negate, dataObj);
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_pipe.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_pipe.js
new file mode 100644
index 0000000000..10c2f28299
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_pipe.js
@@ -0,0 +1,228 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { pipe } from "ramda";
+
+// f - function
+// a - argument
+// unf - unary function
+function f1(a1: number): number {
+  return 69;
+}
+
+function f2(a1: number, a2: string): number {
+  return 69;
+}
+
+function f3(a1: number, a2: string, a3: boolean): number {
+  return 69;
+}
+
+function f4(a1: number, a2: string, a3: boolean, a4: number): number {
+  return 69;
+}
+
+function f5(a1: number, a2: string, a3: boolean, a4: number, a5: string): number {
+  return 69;
+}
+
+function unf1(a1: number): string {
+  return "69";
+}
+
+function unf2(a1: string): boolean {
+  return false;
+}
+
+function unf3(a1: boolean): number {
+  return 69;
+}
+
+function unf4(a1: number): string {
+  return "69";
+}
+
+function unf5(a1: string): boolean {
+  return true;
+}
+
+describe("pipe(...fn)", () => {
+  describe('call "pipe" with unary function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f1, unf1, unf3, unf4, unf5)(1);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f1, unf1, unf2, unf3, unf4, unf5)(1): boolean);
+      (pipe(f1, unf1, unf2, unf3, unf4)(1): string);
+      (pipe(f1, unf1, unf2, unf3)(1): number);
+      (pipe(f1, unf1, unf2)(1): boolean);
+      (pipe(f1, unf1)(1): string);
+      (pipe(f1)(1): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f1)(1, "1", true);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f1)();
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with number
+      pipe(f1, unf1)(true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f1, unf1)(1): boolean);
+    });
+  });
+
+  describe('call "pipe" with double function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f2, unf1, unf3, unf4, unf5)(1, "2");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f2, unf1, unf2, unf3, unf4, unf5)(1, "2"): boolean);
+      (pipe(f2, unf1, unf2, unf3, unf4)(1, "2"): string);
+      (pipe(f2, unf1, unf2, unf3)(1, "2"): number);
+      (pipe(f2, unf1, unf2)(1, "2"): boolean);
+      (pipe(f2, unf1)(1, "2"): string);
+      (pipe(f2)(1, "2"): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f2)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f2)(1);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      pipe(f2, unf1)(1, true);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f2, unf1)(1, "2"): boolean);
+    });
+  });
+
+  describe('call "pipe" with triple function', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f3, unf1, unf3, unf4, unf5)(1, "2", true);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f3, unf1, unf2, unf3, unf4, unf5)(1, "2", true): boolean);
+      (pipe(f3, unf1, unf2, unf3, unf4)(1, "2", true): string);
+      (pipe(f3, unf1, unf2, unf3)(1, "2", true): number);
+      (pipe(f3, unf1, unf2)(1, "2", true): boolean);
+      (pipe(f3, unf1)(1, "2", true): string);
+      (pipe(f3)(1, "2", true): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f3)(1, "2", true, 4, "5");
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f3)(1, "2");
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - number is incompatible with boolean
+      pipe(f3, unf1)(1, "2", 999);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f3, unf1)(1, "2", true): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 4 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f4, unf1, unf3, unf4, unf5)(1, "2", true, 4);
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f4, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1, unf2, unf3, unf4)(1, "2", true, 4): string);
+      (pipe(f4, unf1, unf2, unf3)(1, "2", true, 4): number);
+      (pipe(f4, unf1, unf2)(1, "2", true, 4): boolean);
+      (pipe(f4, unf1)(1, "2", true, 4): string);
+      (pipe(f4)(1, "2", true, 4): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f4)(1, "2", true, 4, "5", 6, false);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f4)(1, "2", true);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - string is incompatible with number
+      pipe(f4, unf1)(1, "2", true, "new number");
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f4, unf1)(1, "2", true, 4): boolean);
+    });
+  });
+
+  describe('call "pipe" with function that takes 5 arguments', () => {
+    it("rises an error when function chain broken", () => {
+      // $FlowExpectedError - unf1 return string but unf3 first argument boolean
+      pipe(f5, unf1, unf3, unf4, unf5)(1, "2", true, 4, "5");
+    });
+
+    it("passes when used properly", () => {
+      (pipe(f5, unf1, unf2, unf3, unf4, unf5)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1, unf2, unf3, unf4)(1, "2", true, 4, "5"): string);
+      (pipe(f5, unf1, unf2, unf3)(1, "2", true, 4, "5"): number);
+      (pipe(f5, unf1, unf2)(1, "2", true, 4, "5"): boolean);
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): string);
+      (pipe(f5)(1, "2", true, 4, "5"): number);
+    });
+
+    it("raises an error when passed more arguments than it need", () => {
+      // $FlowExpectedError - too many arguments
+      pipe(f5)(1, "2", true, 4, "5", 6, 7, 8);
+    });
+
+    it("raises an error when passed too few arguments", () => {
+      // $FlowExpectedError - too few arguments
+      pipe(f5)(1, "2", true, 4);
+    });
+
+    it("raises an error when passed an invalid argument", () => {
+      //$FlowExpectedError - boolean is incompatible with string
+      pipe(f5, unf1)(1, "2", true, 4, false);
+    });
+
+    it("raises an error when trying to recognize an unexpected type", () => {
+      //$FlowExpectedError - boolean  is incompatible with string
+      (pipe(f5, unf1)(1, "2", true, 4, "5"): boolean);
+    });
+  });
+});
diff --git a/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_relation.js b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_relation.js
new file mode 100644
index 0000000000..78a0a65613
--- /dev/null
+++ b/definitions/npm/ramda_v0.x.x/flow_v0.201.x-/test_ramda_v0.x.x_relation.js
@@ -0,0 +1,142 @@
+/* @flow */
+/*eslint-disable no-undef, no-unused-vars, no-console*/
+import _, { compose, pipe, curry, filter, find, repeat, zipWith } from "ramda";
+
+const ns: Array<number> = [1, 2, 3, 4, 5];
+const ss: Array<string> = ["one", "two", "three", "four"];
+const obj: { [k: string]: number, ... } = { a: 1, c: 2 };
+const objMixed: { [k: string]: mixed, ... } = { a: 1, c: "d" };
+const os: Array<{ [k: string]: any, ... }> = [{ a: 1, c: "d" }, { b: 2 }];
+const str: string = "hello world";
+
+const cl: number = _.clamp(1, 10, -1);
+const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
+const letters = _.split("", "abcABCaaaBBc");
+// In ramda docs example it's just `Math.floor`
+// but we don't want the implicit number -> string
+const countB = _.countBy(_.compose(_.toString, Math.floor))(numbers);
+const countB1: { [k: string]: number, ... } = _.countBy(_.toLower)(letters);
+const diff: Array<number> = _.difference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+//$FlowExpectedError
+const diff1: Array<string> = _.difference(
+  ["1", "2", "3", "4"],
+  [7, 6, 5, 4, 3]
+);
+
+const cmp = (x, y) => x.a === y.a;
+const l1 = [{ a: 1 }, { a: 2 }, { a: 3 }];
+const l2 = [{ a: 3 }, { a: 4 }];
+const diff2 = _.differenceWith(cmp, l1, l2);
+
+const eqb: boolean = _.eqBy(Math.abs, 5, -5);
+
+const es: boolean = _.equals([1, 2, 3], [1, 2, 3]);
+
+const _gt: boolean = _.gt(2, 1);
+const _lt: boolean = _.lt(2, 1);
+
+const _gte: boolean = _.gte(2, 1);
+const _lte: boolean = _.lte(2, 1);
+
+const _max: number = _.max(2, 1);
+const _min: number = _.min(2, 1);
+
+const _maxBy: number = _.maxBy(Math.abs)(2, 1);
+const _minBy: number = _.minBy(Math.abs, 2, 1);
+
+const _identical: boolean = _.identical(2, 1);
+
+const _innerJoin: Array<{ [k: string]: mixed, ... }> = _.innerJoin(
+  (record, id) => record.id === id,
+  [{id: 824, name: 'Richie Furay'},
+   {id: 956, name: 'Dewey Martin'},
+   {id: 313, name: 'Bruce Palmer'},
+   {id: 456, name: 'Stephen Stills'},
+   {id: 177, name: 'Neil Young'}],
+  [177, 456, 999]
+);
+
+const inters: Array<number> = _.intersection(ns, ns);
+
+const interBy: Array<number> = _.intersectionWith(_.eqBy(Math.abs), ns, ns);
+
+const pathEqObj: boolean = _.pathEq(["hello"], 1, obj);
+const pathEqObj2: boolean = _.pathEq(["hello"])(1)(obj);
+
+// It's good to test this with multiple params since $Keys<T> is a union.
+type PropEqObj = {
+  bar: number,
+  baz: string,
+  ...
+};
+const propEqObj: PropEqObj = { bar: 2, baz: "qux" };
+
+const isQueen = _.propEq("rank", "Q");
+
+const propEqResult1a: boolean = _.propEq("bar", 1, propEqObj);
+// Test curried versions.
+const propEqResult1b: boolean = _.propEq("bar")(1)(propEqObj);
+const propEqResult1c: boolean = _.propEq("bar")(1, propEqObj);
+const propEqResult1d: boolean = _.propEq("bar", 1)(propEqObj);
+
+// The type compared can be any type just like any other === comparison.
+// Also test the various arities.
+const propEqResult2a: boolean = _.propEq("bar", "always false", propEqObj);
+const propEqResult2b: boolean = _.propEq("bar")("always false")(propEqObj);
+const propEqResult2c: boolean = _.propEq("bar")("always false", propEqObj);
+const propEqResult2d: boolean = _.propEq("bar", "always false")(propEqObj);
+
+// The property name must be a property on the object supplied.
+// $FlowExpectedError
+const propEqResultError: boolean = _.propEq("missing", 1, propEqObj);
+
+// propEq must work with key value pairs.
+const propEqKvp: { [string]: mixed, ... } = { foo: 1, bar: "2", baz: 3 };
+const propEqResult3a: boolean = _.propEq("qux", "value", propEqKvp);
+const propEqResult3b: boolean = _.propEq("qux")("value")(propEqKvp);
+const propEqResult3c: boolean = _.propEq("qux")("value", propEqKvp);
+const propEqResult3d: boolean = _.propEq("qux", "value")(propEqKvp);
+
+// propEq must work with arrays.
+const propEqArray = [1, 2, 3];
+const propEqResult4a: boolean = _.propEq(1, 2, propEqArray);
+const propEqResult4b: boolean = _.propEq(1)(2)(propEqArray);
+const propEqResult4c: boolean = _.propEq(1)(2, propEqArray);
+const propEqResult4d: boolean = _.propEq(1, 2)(propEqArray);
+
+const sortByFirstItem = _.sortBy(([first]) => first);
+const pairs = [[-1, 1], [-2, 2], [-3, 3]];
+const sorted: Array<[number, number]> = sortByFirstItem(pairs);
+
+const sortWithData = [
+  {name: 'alice', age: 40},
+  {name: 'bob', age: 30},
+  {name: 'clara', age: 40}
+];
+const descAge = (l, r) => l.age < r.age ? -1 : 1;
+const ascName = (l, r) => l.name < r.name ? -1 : 1;
+_.sortWith([descAge, ascName], sortWithData);
+_.sortWith([descAge, ascName])(sortWithData);
+
+const eqA = _.eqBy(_.prop("a"));
+const ls1: Array<{ [k: string]: number, ... }> = [
+  { a: 1 },
+  { a: 2 },
+  { a: 3 },
+  { a: 4 }
+];
+const ls2: Array<{ [k: string]: number, ... }> = [
+  { a: 3 },
+  { b: 4 },
+  { a: 5 },
+  { a: 6 }
+];
+const symW: Array<{ [k: string]: number, ... }> = _.symmetricDifferenceWith(
+  eqA,
+  ls1,
+  ls2
+);
+const sym: Array<number> = _.symmetricDifference([1, 2, 3, 4], [7, 6, 5, 4, 3]);
+
+const un: Array<number> = _.union([1, 2, 3])([2, 3, 4]);
+const un1: Array<{ [k: string]: number, ... }> = _.unionWith(eqA, ls1, ls2);
diff --git a/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-/react-a11y-dialog_v4.1.x.js b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-v.200.x/react-a11y-dialog_v4.1.x.js
similarity index 100%
rename from definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-/react-a11y-dialog_v4.1.x.js
rename to definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-v.200.x/react-a11y-dialog_v4.1.x.js
diff --git a/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-/test_react-a11y-dialog_v4.1.x.js b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-v.200.x/test_react-a11y-dialog_v4.1.x.js
similarity index 100%
rename from definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-/test_react-a11y-dialog_v4.1.x.js
rename to definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.104.x-v.200.x/test_react-a11y-dialog_v4.1.x.js
diff --git a/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/react-a11y-dialog_v4.1.x.js b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/react-a11y-dialog_v4.1.x.js
new file mode 100644
index 0000000000..7be7e77cc4
--- /dev/null
+++ b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/react-a11y-dialog_v4.1.x.js
@@ -0,0 +1,60 @@
+declare module "react-a11y-dialog" {
+  declare type Props = {
+    // The `role` attribute of the dialog element, either `dialog` (default) or
+    // `alertdialog` to make it a modal (preventing closing on click outside of
+    // ESC key).
+    role?: "dialog" | "alertdialog",
+    // The HTML `id` attribute of the dialog element, internally used by
+    // a11y-dialog to manipulate the dialog.
+    id: string,
+    // The title of the dialog, mandatory in the document to provide context to
+    // assistive technology. Could be hidden (while remaining accessible) with
+    // CSS though.
+    title: string | React$Element<any>,
+    // A function called when the component has mounted, receiving the instance
+    // of A11yDialog so that it can be programmatically accessed later on.
+    // E.g.: dialogRef={(dialog) => (this.dialog = dialog)}
+    dialogRef?: (node: HTMLDialogElement | HTMLElement) => void,
+    // The HTML `id` attribute of the dialog’s title element, used by assistive
+    // technologies to provide context and meaning to the dialog window. Falls
+    // back to the `${this.props.id}-title` if not provided.
+    titleId?: string,
+    // The HTML `aria-label` attribute of the close button, used by assistive
+    // technologies to provide extra meaning to the usual cross-mark. Defaults
+    // to a generic English explanation.
+    closeButtonLabel?: string,
+    // The string that is the innerHTML of the close button.
+    closeButtonContent?: string | React$Element<any>,
+    // a11y-dialog needs one or more “targets” to disable when the dialog is open.
+    // This prop can be one or more selector which will be passed to a11y-dialog
+    // constructor.
+    appRoot: string | Array<string>,
+    // React 16 requires a container for the portal’s content to be rendered
+    // into; this is required and needs to be an existing valid DOM node,
+    // adjacent to the React root container of the application.
+    dialogRoot: string,
+    // Object of classes for each HTML element of the dialog element. Keys are:
+    // - base
+    // - overlay
+    // - element
+    // - document
+    // - title
+    // - closeButton
+    // See for reference: http://edenspiekermann.github.io/a11y-dialog/#expected-dom-structure
+    classNames?: { [key:
+      | "base"
+      | "overlay"
+      | "element"
+      | "document"
+      | "title"
+      | "closeButton"]: string, ... },
+    // Whether to render a `<dialog>` element or a `<div>` element.
+    useDialog?: boolean,
+    children?: React$Node,
+    ...
+  };
+
+  declare class Dialog extends React$Component<Props> {}
+
+  declare module.exports: typeof Dialog;
+}
diff --git a/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/test_react-a11y-dialog_v4.1.x.js b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/test_react-a11y-dialog_v4.1.x.js
new file mode 100644
index 0000000000..71ad900c03
--- /dev/null
+++ b/definitions/npm/react-a11y-dialog_v4.1.x/flow_v0.201.x-/test_react-a11y-dialog_v4.1.x.js
@@ -0,0 +1,32 @@
+// @flow
+
+import { describe, it } from "flow-typed-test";
+import React from "react";
+import Dialog from "react-a11y-dialog";
+
+let defaultProps = {
+  id: "my-accessible-dialog",
+  appRoot: "#main",
+  dialogRoot: "#dialog-root",
+  title: "The dialog title",
+  children: <p>Some content for the dialog.</p>
+};
+
+describe("The `dialogRef` property", () => {
+  it("should accept a reference callback", () => {
+    <Dialog
+      {...defaultProps}
+      dialogRef={dialog => {
+        if (dialog instanceof HTMLDialogElement) {
+          (dialog: HTMLDialogElement);
+        }
+
+        if (dialog instanceof HTMLElement) {
+          (dialog: HTMLElement);
+        }
+      }}
+    />;
+    // $FlowExpectedError
+    <Dialog {...defaultProps} dialogRef="" />;
+  });
+});
diff --git a/definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-/react-apollo_v2.x.x.js b/definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-v.200.x/react-apollo_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-/react-apollo_v2.x.x.js
rename to definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-v.200.x/react-apollo_v2.x.x.js
diff --git a/definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-/test_react-apollo_v2.x.x.js b/definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-v.200.x/test_react-apollo_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-/test_react-apollo_v2.x.x.js
rename to definitions/npm/react-apollo_v2.x.x/flow_v0.104.x-v.200.x/test_react-apollo_v2.x.x.js
diff --git a/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/react-apollo_v2.x.x.js b/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/react-apollo_v2.x.x.js
new file mode 100644
index 0000000000..29b496ee1d
--- /dev/null
+++ b/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/react-apollo_v2.x.x.js
@@ -0,0 +1,1068 @@
+declare module "react-apollo" {
+  import type { ComponentType, Element, Node } from "react";
+
+  declare type MakeOptional = <V>(V) => ?V;
+  declare type MakeDataOptional<TData> = $ObjMap<TData, MakeOptional> | void;
+  /**
+   * Copied types from Apollo Client libdef
+   * Please update apollo-client libdef as well if updating these types
+   */
+  declare class ObservableQuery<T> extends Observable<ApolloQueryResult<T>> {
+    options: WatchQueryOptions;
+    queryId: string;
+    variables: { [key: string]: any, ... };
+    isCurrentlyPolling: boolean;
+    shouldSubscribe: boolean;
+    isTornDown: boolean;
+    scheduler: QueryScheduler<any>;
+    queryManager: QueryManager<any>;
+    observers: Observer<ApolloQueryResult<T>>[];
+    subscriptionHandles: SubscriptionLINK[];
+    lastResult: ApolloQueryResult<T>;
+    lastError: ApolloError;
+    lastVariables: { [key: string]: any, ... };
+
+    constructor(data: {
+      scheduler: QueryScheduler<any>,
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean,
+      ...
+    }): this;
+
+    result(): Promise<ApolloQueryResult<T>>;
+    currentResult(): ApolloCurrentResult<T>;
+    getLastResult(): ApolloQueryResult<T>;
+    getLastError(): ApolloError;
+    resetLastResults(): void;
+    refetch(variables?: any): Promise<ApolloQueryResult<T>>;
+    fetchMore(
+      fetchMoreOptions: FetchMoreQueryOptions<any> & FetchMoreOptions<any, any>
+    ): Promise<ApolloQueryResult<T>>;
+    subscribeToMore(options: SubscribeToMoreOptions<any, any>): () => void;
+    setOptions(
+      opts: ModifiableWatchQueryOptions
+    ): Promise<ApolloQueryResult<T>>;
+    setVariables(
+      variables: any,
+      tryFetch?: boolean,
+      fetchResults?: boolean
+    ): Promise<ApolloQueryResult<T>>;
+    updateQuery(
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ): void;
+    stopPolling(): void;
+    startPolling(pollInterval: number): void;
+  }
+
+  declare class QueryManager<TStore> {
+    scheduler: QueryScheduler<TStore>;
+    link: ApolloLink;
+    mutationStore: MutationStore;
+    queryStore: QueryStore;
+    dataStore: DataStore<TStore>;
+
+    constructor({
+      link: ApolloLink,
+      queryDeduplication?: boolean,
+      store: DataStore<TStore>,
+      onBroadcast?: () => mixed,
+      ssrMode?: boolean,
+      ...
+    }): this;
+
+    mutate<T>(options: MutationOptions<>): Promise<FetchResult<T>>;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType?: FetchType,
+      fetchMoreForQueryId?: string
+    ): Promise<FetchResult<T>>;
+    queryListenerForObserver<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      observer: Observer<ApolloQueryResult<T>>
+    ): QueryListener;
+    watchQuery<T>(
+      options: WatchQueryOptions,
+      shouldSubscribe?: boolean
+    ): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    generateQueryId(): string;
+    stopQueryInStore(queryId: string): void;
+    addQueryListener(queryId: string, listener: QueryListener): void;
+    updateQueryWatch(
+      queryId: string,
+      document: DocumentNode,
+      options: WatchQueryOptions
+    ): void;
+    addFetchQueryPromise<T>(
+      requestId: number,
+      promise: Promise<ApolloQueryResult<T>>,
+      resolve: (result: ApolloQueryResult<T>) => void,
+      reject: (error: Error) => void
+    ): void;
+    removeFetchQueryPromise(requestId: number): void;
+    addObservableQuery<T>(
+      queryId: string,
+      observableQuery: ObservableQuery<T>
+    ): void;
+    removeObservableQuery(queryId: string): void;
+    clearStore(): Promise<void>;
+    resetStore(): Promise<ApolloQueryResult<any>[]>;
+  }
+
+  declare class QueryStore {
+    getStore(): { [queryId: string]: QueryStoreValue, ... };
+    get(queryId: string): QueryStoreValue;
+    initQuery(query: {
+      queryId: string,
+      document: DocumentNode,
+      storePreviousVariables: boolean,
+      variables: Object,
+      isPoll: boolean,
+      isRefetch: boolean,
+      metadata: any,
+      fetchMoreForQueryId: string | void,
+      ...
+    }): void;
+    markQueryResult(
+      queryId: string,
+      result: ExecutionResult<>,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryError(
+      queryId: string,
+      error: Error,
+      fetchMoreForQueryId: string | void
+    ): void;
+    markQueryResultClient(queryId: string, complete: boolean): void;
+    stopQuery(queryId: string): void;
+    reset(observableQueryIds: string[]): void;
+  }
+
+  declare class QueryScheduler<TCacheShape> {
+    inFlightQueries: { [queryId: string]: WatchQueryOptions, ... };
+    registeredQueries: { [queryId: string]: WatchQueryOptions, ... };
+    intervalQueries: { [interval: number]: string[], ... };
+    queryManager: QueryManager<TCacheShape>;
+    constructor({
+      queryManager: QueryManager<TCacheShape>,
+      ssrMode?: boolean,
+      ...
+    }): this;
+    checkInFlight(queryId: string): ?boolean;
+    fetchQuery<T>(
+      queryId: string,
+      options: WatchQueryOptions,
+      fetchType: FetchType
+    ): Promise<FetchResult<T>>;
+    startPollingQuery<T>(
+      options: WatchQueryOptions,
+      queryId: string,
+      listener?: QueryListener
+    ): string;
+    stopPollingQuery(queryId: string): void;
+    fetchQueriesOnInterval<T>(interval: number): void;
+    addQueryOnInterval<T>(
+      queryId: string,
+      queryOptions: WatchQueryOptions
+    ): void;
+    registerPollingQuery<T>(
+      queryOptions: WatchQueryOptions
+    ): ObservableQuery<T>;
+    markMutationError(mutationId: string, error: Error): void;
+    reset(): void;
+  }
+
+  declare class DataStore<TSerialized> {
+    constructor(initialCache: ApolloCache<TSerialized>): this;
+    getCache(): ApolloCache<TSerialized>;
+    markQueryResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      fetchMoreForQueryId: string | void,
+      ignoreErrors?: boolean
+    ): void;
+    markSubscriptionResult(
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any
+    ): void;
+    markMutationInit(mutation: {
+      mutationId: string,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: Object) => mixed) | void,
+      optimisticResponse: Object | Function | void,
+      ...
+    }): void;
+    markMutationResult(mutation: {
+      mutationId: string,
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: { [queryId: string]: QueryWithUpdater, ... },
+      update: ((proxy: DataProxy, mutationResult: Object) => mixed) | void,
+      ...
+    }): void;
+    markMutationComplete({
+      mutationId: string,
+      optimisticResponse?: any,
+      ...
+    }): void;
+    markUpdateQueryResult(
+      document: DocumentNode,
+      variables: any,
+      newResult: any
+    ): void;
+    reset(): Promise<void>;
+  }
+
+  declare type QueryWithUpdater = {
+    updater: MutationQueryReducer<Object>,
+    query: QueryStoreValue,
+    ...
+  };
+
+  declare interface MutationStoreValue {
+    mutationString: string;
+    variables: Object;
+    loading: boolean;
+    error: Error | null;
+  }
+
+  declare class MutationStore {
+    getStore(): { [mutationId: string]: MutationStoreValue, ... };
+    get(mutationId: string): MutationStoreValue;
+    initMutation(
+      mutationId: string,
+      mutationString: string,
+      variables: Object | void
+    ): void;
+  }
+
+  declare export interface FetchMoreOptions<TData, TVariables> {
+    updateQuery: (
+      previousQueryResult: TData,
+      options: {
+        fetchMoreResult?: TData,
+        variables: TVariables,
+        ...
+      }
+    ) => TData;
+  }
+
+  declare export interface UpdateQueryOptions {
+    variables?: Object;
+  }
+
+  declare export type ApolloCurrentResult<T> = {
+    data: T | {...},
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    error?: ApolloError,
+    partial?: boolean,
+    ...
+  };
+
+  declare interface ModifiableWatchQueryOptions {
+    variables?: { [key: string]: any, ... };
+    pollInterval?: number;
+    fetchPolicy?: FetchPolicy;
+    errorPolicy?: ErrorPolicy;
+    fetchResults?: boolean;
+    notifyOnNetworkStatusChange?: boolean;
+  }
+
+  declare export interface WatchQueryOptions
+    extends ModifiableWatchQueryOptions {
+    query: DocumentNode;
+    metadata?: any;
+    context?: any;
+  }
+
+  declare export type RefetchQueryDescription = $ReadOnlyArray<
+    string | PureQueryOptions
+  >;
+
+  declare interface MutationBaseOptions<T = { [key: string]: any, ... }> {
+    optimisticResponse?: Object | Function;
+    updateQueries?: MutationQueryReducersMap<T>;
+    optimisticResponse?: Object;
+    refetchQueries?:
+      | ((result: ExecutionResult<>) => RefetchQueryDescription)
+      | RefetchQueryDescription;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: any;
+  }
+
+  declare export interface MutationOptions<T = { [key: string]: any, ... }>
+    extends MutationBaseOptions<T> {
+    mutation: DocumentNode;
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+  }
+
+  declare export interface SubscriptionOptions {
+    query: DocumentNode;
+    variables?: { [key: string]: any, ... };
+  }
+
+  declare export type FetchPolicy =
+    | "cache-first"
+    | "cache-and-network"
+    | "network-only"
+    | "cache-only"
+    | "no-cache"
+    | "standby";
+
+  declare export type ErrorPolicy = "none" | "ignore" | "all";
+
+  declare export interface FetchMoreQueryOptions<TVariables> {
+    variables: $Shape<TVariables>;
+  }
+
+  declare export type SubscribeToMoreOptions<
+    TData,
+    TSubscriptionData,
+    TSubscriptionVariables = void
+  > = {
+    document?: DocumentNode,
+    variables?: TSubscriptionVariables,
+    updateQuery?: (
+      previousResult: TData,
+      result: {
+        subscriptionData: { data?: TSubscriptionData, ... },
+        variables: TSubscriptionVariables,
+        ...
+      }
+    ) => TData,
+    onError?: (error: Error) => mixed,
+    ...
+  };
+
+  declare export type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => mixed;
+
+  declare export type NetworkStatus = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare export type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => mixed;
+
+  declare export type QueryStoreValue = {
+    document: DocumentNode,
+    variables: Object,
+    previousVariables: Object | null,
+    networkStatus: NetworkStatus,
+    networkError: Error | null,
+    graphQLErrors: GraphQLError[],
+    metadata: any,
+    ...
+  };
+
+  declare export type PureQueryOptions = {
+    query: DocumentNode,
+    variables?: { [key: string]: any, ... },
+    ...
+  };
+
+  declare export type ApolloQueryResult<T> = {
+    data: T,
+    errors?: Array<GraphQLError>,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    stale: boolean,
+    ...
+  };
+
+  declare export type FetchType = 1 | 2 | 3;
+
+  declare export type MutationQueryReducer<T> = (
+    previousResult: { [key: string]: any, ... },
+    options: {
+      mutationResult: FetchResult<T>,
+      queryName: string | void,
+      queryVariables: { [key: string]: any, ... },
+      ...
+    }
+  ) => { [key: string]: any, ... };
+
+  declare export type MutationQueryReducersMap<T = { [key: string]: any, ... }> = { [queryName: string]: MutationQueryReducer<T>, ... };
+
+  declare export class ApolloError extends Error {
+    message: string;
+    graphQLErrors: Array<GraphQLError>;
+    networkError: Error | null;
+    extraInfo: any;
+    constructor(info: ErrorConstructor): this;
+  }
+
+  declare interface ErrorConstructor {
+    graphQLErrors?: Array<GraphQLError>;
+    networkError?: Error | null;
+    errorMessage?: string;
+    extraInfo?: any;
+  }
+
+  declare interface DefaultOptions {
+    +watchQuery?: ModifiableWatchQueryOptions;
+    +query?: ModifiableWatchQueryOptions;
+    +mutate?: MutationBaseOptions<>;
+  }
+
+  declare export type ApolloClientOptions<TCacheShape> = {
+    link: ApolloLink,
+    cache: ApolloCache<TCacheShape>,
+    ssrMode?: boolean,
+    ssrForceFetchDelay?: number,
+    connectToDevTools?: boolean,
+    queryDeduplication?: boolean,
+    defaultOptions?: DefaultOptions,
+    ...
+  };
+
+  declare export class ApolloClient<TCacheShape> {
+    link: ApolloLink;
+    store: DataStore<TCacheShape>;
+    cache: ApolloCache<TCacheShape>;
+    queryManager: QueryManager<TCacheShape>;
+    disableNetworkFetches: boolean;
+    version: string;
+    queryDeduplication: boolean;
+    defaultOptions: DefaultOptions;
+    devToolsHookCb: Function;
+    proxy: ApolloCache<TCacheShape> | void;
+    ssrMode: boolean;
+    resetStoreCallbacks: Array<() => Promise<any>>;
+
+    constructor(options: ApolloClientOptions<TCacheShape>): this;
+    watchQuery<T>(options: WatchQueryOptions): ObservableQuery<T>;
+    query<T>(options: WatchQueryOptions): Promise<ApolloQueryResult<T>>;
+    mutate<T>(options: MutationOptions<T>): Promise<FetchResult<T>>;
+    subscribe(options: SubscriptionOptions): Observable<any>;
+    readQuery<T>(options: DataProxyReadQueryOptions): T | null;
+    readFragment<T>(options: DataProxyReadFragmentOptions): T | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+    __actionHookForDevTools(cb: () => mixed): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    clearStore(): Promise<void | null>;
+    resetStore(): Promise<Array<ApolloQueryResult<any>> | null>;
+    onResetStore(cb: () => Promise<any>): () => void;
+    reFetchObservableQueries(
+      includeStandby?: boolean
+    ): Promise<ApolloQueryResult<any>[]> | Promise<null>;
+    extract(optimistic?: boolean): TCacheShape;
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+  }
+
+  /* apollo-link types */
+  declare class ApolloLink {
+    constructor(request?: RequestHandler): this;
+
+    static empty(): ApolloLink;
+    static from(links: Array<ApolloLink>): ApolloLink;
+    static split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+    static execute(
+      link: ApolloLink,
+      operation: GraphQLRequest
+    ): Observable<FetchResult<>>;
+
+    split(
+      test: (op: Operation) => boolean,
+      left: ApolloLink | RequestHandler,
+      right: ApolloLink | RequestHandler
+    ): ApolloLink;
+
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+
+    request(
+      operation: Operation,
+      forward?: NextLink
+    ): Observable<FetchResult<>> | null;
+  }
+
+  declare interface GraphQLRequest {
+    query: DocumentNode;
+    variables?: { [key: string]: any, ... };
+    operationName?: string;
+    context?: { [key: string]: any, ... };
+    extensions?: { [key: string]: any, ... };
+  }
+
+  declare interface Operation {
+    query: DocumentNode;
+    variables: { [key: string]: any, ... };
+    operationName: string;
+    extensions: { [key: string]: any, ... };
+    setContext: (context: { [key: string]: any, ... }) => { [key: string]: any, ... };
+    getContext: () => { [key: string]: any, ... };
+    toKey: () => string;
+  }
+
+  declare export type FetchResult<
+    C = { [key: string]: any, ... },
+    E = { [key: string]: any, ... }
+  > = ExecutionResult<C> & {
+    extension?: E,
+    context?: C,
+    ...
+  };
+
+  declare type NextLink = (operation: Operation) => Observable<FetchResult<>>;
+
+  declare type RequestHandler = (
+    operation: Operation,
+    forward?: NextLink
+  ) => Observable<FetchResult<>> | null;
+
+  declare class Observable<T> {
+    subscribe(
+      observerOrNext: ((value: T) => mixed) | ZenObservableObserver<T>,
+      error?: (error: any) => mixed,
+      complete?: () => mixed
+    ): ZenObservableSubscription;
+
+    forEach(fn: (value: T) => mixed): Promise<void>;
+
+    map<R>(fn: (value: T) => R): Observable<R>;
+
+    filter(fn: (value: T) => boolean): Observable<T>;
+
+    reduce<R>(
+      fn: (previousValue: R | T, currentValue: T) => R | T,
+      initialValue?: R | T
+    ): Observable<R | T>;
+
+    flatMap<R>(fn: (value: T) => ZenObservableObservableLike<R>): Observable<R>;
+
+    from<R>(
+      observable: Observable<R> | ZenObservableObservableLike<R> | Array<R>
+    ): Observable<R>;
+
+    of<R>(...args: Array<R>): Observable<R>;
+  }
+
+  declare interface Observer<T> {
+    start?: (subscription: SubscriptionLINK) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare interface SubscriptionLINK {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare interface ZenObservableSubscriptionObserver<T> {
+    closed: boolean;
+    next(value: T): void;
+    error(errorValue: any): void;
+    complete(): void;
+  }
+
+  declare interface ZenObservableSubscription {
+    closed: boolean;
+    unsubscribe(): void;
+  }
+
+  declare interface ZenObservableObserver<T> {
+    start?: (subscription: ZenObservableSubscription) => mixed;
+    next?: (value: T) => mixed;
+    error?: (errorValue: any) => mixed;
+    complete?: () => mixed;
+  }
+
+  declare type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => mixed | (() => mixed) | SubscriptionLINK;
+
+  declare interface ZenObservableObservableLike<T> {
+    subscribe?: ZenObservableSubscriber<T>;
+  }
+  /* apollo-link types */
+
+  /* apollo-cache types */
+  declare class ApolloCache<TSerialized> {
+    read<T>(query: CacheReadOptions): T | null;
+    write(write: CacheWriteOptions): void;
+    diff<T>(query: CacheDiffOptions): CacheDiffResult<T>;
+    watch(watch: CacheWatchOptions): () => void;
+    evict(query: CacheEvictOptions): CacheEvictionResult;
+    reset(): Promise<void>;
+
+    restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    extract(optimistic?: boolean): TSerialized;
+
+    removeOptimistic(id: string): void;
+
+    performTransaction(transaction: Transaction<TSerialized>): void;
+    recordOptimisticTransaction(
+      transaction: Transaction<TSerialized>,
+      id: string
+    ): void;
+
+    transformDocument(document: DocumentNode): DocumentNode;
+    transformForLink(document: DocumentNode): DocumentNode;
+
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: CacheWriteQueryOptions): void;
+    writeFragment(options: CacheWriteFragmentOptions): void;
+    writeData(options: CacheWriteDataOptions): void;
+  }
+
+  declare type Transaction<T> = (c: ApolloCache<T>) => mixed;
+
+  declare type CacheWatchCallback = (newData: any) => mixed;
+
+  declare interface CacheEvictionResult {
+    success: boolean;
+  }
+
+  declare interface CacheReadOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+    previousResult?: any;
+    optimistic: boolean;
+  }
+
+  declare interface CacheWriteOptions extends DataProxyReadQueryOptions {
+    dataId: string;
+    result: any;
+  }
+
+  declare interface CacheDiffOptions extends CacheReadOptions {
+    returnPartialData?: boolean;
+  }
+
+  declare interface CacheWatchOptions extends CacheReadOptions {
+    callback: CacheWatchCallback;
+  }
+
+  declare interface CacheEvictOptions extends DataProxyReadQueryOptions {
+    rootId?: string;
+  }
+
+  declare type CacheDiffResult<T> = DataProxyDiffResult<T>;
+  declare type CacheWriteQueryOptions = DataProxyWriteQueryOptions;
+  declare type CacheWriteFragmentOptions = DataProxyWriteFragmentOptions;
+  declare type CacheWriteDataOptions = DataProxyWriteDataOptions;
+  declare type CacheReadFragmentOptions = DataProxyReadFragmentOptions;
+
+  declare interface DataProxyReadQueryOptions {
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare interface DataProxyReadFragmentOptions {
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteQueryOptions {
+    data: any;
+    query: DocumentNode;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteFragmentOptions {
+    data: any;
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: any;
+  }
+
+  declare interface DataProxyWriteDataOptions {
+    data: any;
+    id?: string;
+  }
+
+  declare type DataProxyDiffResult<T> = {
+    result?: T,
+    complete?: boolean,
+    ...
+  };
+
+  declare export interface DataProxy {
+    readQuery<QueryType>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType>(
+      options: DataProxyReadFragmentOptions,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery(options: DataProxyWriteQueryOptions): void;
+    writeFragment(options: DataProxyWriteFragmentOptions): void;
+    writeData(options: DataProxyWriteDataOptions): void;
+  }
+  /* End apollo-cache types */
+
+  /** End from Apollo Client */
+
+  /**
+   * Types From graphql
+   * graphql types are maintained in the graphql-js repo
+   */
+  declare type DocumentNode = any;
+  declare type ExecutionResult<T> = {
+    data?: T,
+    extensions?: { [string]: any, ... },
+    errors?: any[],
+    ...
+  };
+  declare type GraphQLError = any;
+  declare type VariableDefinitionNode = any;
+  /** End From graphql */
+
+  declare export interface ApolloProviderProps<TCache> {
+    client: any; // ApolloClient<TCache>;
+    children: Node;
+  }
+
+  declare export interface ApolloConsumerProps {
+    children: (client: ApolloClient<any>) => Node;
+  }
+
+  declare export class ApolloConsumer extends React$Component<
+    ApolloConsumerProps
+  > {}
+
+  declare export class ApolloProvider<TCache> extends React$Component<
+    ApolloProviderProps<TCache>
+  > {
+    childContextTypes: {
+      client: ApolloClient<TCache>,
+      operations: Map<string, {
+        query: DocumentNode,
+        variables: any,
+        ...
+      }>,
+      ...
+    };
+
+    getChildContext(): {
+      client: ApolloClient<TCache>,
+      operations: Map<string, {
+        query: DocumentNode,
+        variables: any,
+        ...
+      }>,
+      ...
+    };
+  }
+
+  declare export type MutationFunc<TResult, TVariables> = (
+    opts: MutationOpts<TVariables>
+  ) => Promise<ApolloQueryResult<TResult>>;
+
+  declare export type GraphqlData<TResult, TVariables> = TResult &
+    GraphqlQueryControls<TVariables> & {
+    variables: TVariables,
+    refetch: (variables?: TVariables) => Promise<ApolloQueryResult<any>>,
+    ...
+  };
+
+  declare export type ChildProps<
+    TOwnProps,
+    TResult,
+    TVariables: Object = { ... }
+  > = {
+    data: GraphqlData<TResult, TVariables>,
+    mutate: MutationFunc<TResult, TVariables>,
+    ...
+  } & TOwnProps;
+
+  // back compat
+  declare export type DefaultChildProps<P, R> = ChildProps<P, R, {...}>;
+
+  declare export type RefetchQueriesProviderFn = (
+    ...args: any[]
+  ) => RefetchQueryDescription;
+
+  declare export type MutationOpts<TVariables> = {|
+    variables?: TVariables,
+    optimisticResponse?: Object,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    update?: MutationUpdaterFn<any>,
+    errorPolicy?: ErrorPolicy
+  |};
+
+  declare export type QueryOpts<TVariables> = {|
+    ssr?: boolean,
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    pollInterval?: number,
+    skip?: boolean,
+    errorPolicy?: ErrorPolicy,
+    context?: { [key: string]: any, ... }
+  |};
+
+  declare export interface GraphqlQueryControls<
+    TGraphQLVariables = OperationVariables
+  > {
+    error?: ApolloError | any; // Added optional `any` to satisfy Flow < 0.62
+    networkStatus: NetworkStatus;
+    loading: boolean;
+    variables: TGraphQLVariables;
+    fetchMore: (
+      fetchMoreOptions: FetchMoreQueryOptions<TGraphQLVariables> &
+        FetchMoreOptions<any, TGraphQLVariables>
+    ) => Promise<ApolloQueryResult<any>>;
+    refetch: (variables?: TGraphQLVariables) => Promise<ApolloQueryResult<any>>;
+    startPolling: (pollInterval: number) => void;
+    stopPolling: () => void;
+    subscribeToMore: (options: SubscribeToMoreOptions<any, any>) => () => void;
+    updateQuery: (
+      mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => mixed
+    ) => void;
+  }
+
+  declare export interface OptionProps<TProps, TResult, TVariables> {
+    ownProps: TProps;
+    data?: GraphqlData<TResult, TVariables>;
+    mutate: MutationFunc<TResult, TVariables>;
+  }
+
+  declare export type OptionDescription<TProps, TVariables> =
+    | QueryOpts<TVariables>
+    | MutationOpts<TVariables>
+    | ((props: TProps) => QueryOpts<TVariables> | MutationOpts<TVariables>);
+
+  declare export type NamedProps<P, R> = P & { ownProps: R, ... };
+
+  declare export interface OperationOption<
+    TResult: {...},
+    TProps: {...},
+    TChildProps: {...},
+    TVariables: {...}
+  > {
+    +options?: OptionDescription<TProps, TVariables>;
+    props?: (
+      props: OptionProps<TProps, TResult, TVariables>
+    ) => TChildProps | ChildProps<TProps, TResult, TVariables>;
+    +skip?: boolean | ((props: any) => boolean);
+    name?: string;
+    withRef?: boolean;
+    shouldResubscribe?: (props: TProps, nextProps: TProps) => boolean;
+    alias?: string;
+  }
+
+  declare export interface OperationComponent<
+    TResult: Object = { ... },
+    TOwnProps: Object = { ... },
+    TVariables: Object = { ... },
+    TMergedProps: Object = ChildProps<TOwnProps, TResult, TVariables>
+  > {
+    (component: ComponentType<TMergedProps>): ComponentType<TOwnProps>;
+  }
+
+  declare export function graphql<TResult, TProps, TVariables, TChildProps>(
+    document: DocumentNode,
+    operationOptions?: OperationOption<TResult, TProps, TChildProps, TVariables>
+  ): OperationComponent<TResult, TProps, TVariables, TChildProps>;
+
+  declare type WithApolloOptions = { withRef?: boolean, ... };
+
+  declare export function withApollo<TProps>(
+    component: ComponentType<{ client: ApolloClient<any>, ... } & TProps>,
+    operationOptions?: WithApolloOptions
+  ): ComponentType<TProps>;
+
+  declare export interface IDocumentDefinition {
+    type: DocumentType;
+    name: string;
+    variables: VariableDefinitionNode[];
+  }
+
+  declare export function parser(document: DocumentNode): IDocumentDefinition;
+
+  declare export interface Context {
+    [key: string]: any;
+  }
+
+  declare export interface QueryResult {
+    query: Promise<ApolloQueryResult<mixed>>;
+    element: Element<any>;
+    context: Context;
+  }
+
+  declare export function walkTree(
+    element: Node,
+    context: Context,
+    visitor: (element: Node, instance: any, context: Context) => boolean | void
+  ): void;
+
+  declare export function getDataFromTree(
+    rootElement: Element<any>,
+    rootContext?: any,
+    fetchRoot?: boolean
+  ): Promise<void>;
+
+  declare export function renderToStringWithData(
+    component: Element<any>
+  ): Promise<string>;
+
+  declare export function cleanupApolloState(apolloState: any): void;
+
+  declare export type QueryRenderProps<
+    TData = any,
+    TVariables = OperationVariables
+  > = {
+    data: MakeDataOptional<TData>,
+    loading: boolean,
+    error?: ApolloError,
+    variables: TVariables,
+    networkStatus: NetworkStatus,
+    refetch: (variables?: TVariables) => Promise<ApolloQueryResult<TData>>,
+    fetchMore: ((
+      options: FetchMoreOptions<TData, TVariables> &
+        FetchMoreQueryOptions<TVariables>
+    ) => Promise<ApolloQueryResult<TData>>) &
+      (<TData2, TVariables2>(
+        options: { query: DocumentNode, ... } & FetchMoreQueryOptions<TVariables2> &
+          FetchMoreOptions<TData2, TVariables2>
+      ) => Promise<ApolloQueryResult<TData2>>),
+    load: () => void,
+    startPolling: (interval: number) => void,
+    stopPolling: () => void,
+    subscribeToMore: (
+      options: SubscribeToMoreOptions<TData, any, any>
+    ) => () => void,
+    updateQuery: (
+      mapFn: (
+        previousResult: TData,
+        options: { variables: TVariables, ... }
+      ) => TData
+    ) => mixed,
+    client: ApolloClient<any>,
+    ...
+  };
+
+  declare export type QueryRenderPropFunction<TData, TVariables> = (
+    QueryRenderProps<TData, TVariables>
+  ) => Node;
+
+  declare export class Query<TData, TVariables> extends React$Component<{
+    query: DocumentNode,
+    children: QueryRenderPropFunction<TData, TVariables>,
+    variables?: TVariables,
+    pollInterval?: number,
+    notifyOnNetworkStatusChange?: boolean,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    ssr?: boolean,
+    displayName?: string,
+    delay?: boolean,
+    context?: { [string]: any, ... },
+    ...
+  }> {}
+
+  declare export type SubscriptionResult<
+    TData,
+    TVariables = OperationVariables
+  > = {
+    loading: boolean,
+    data?: MakeDataOptional<TData>,
+    error?: ApolloError,
+    ...
+  };
+
+  declare export type SubscriptionRenderPropFunction<TData, TVariables> = (
+    result: SubscriptionResult<TData, TVariables>
+  ) => Node;
+
+  declare export type OnSubscriptionDataOptions<TData> = {
+    client: ApolloClient<any>,
+    subscriptionData: SubscriptionResult<TData>,
+    ...
+  };
+
+  declare type SubscriptionProps<TData, TVariables = OperationVariables> = {
+    subscription: DocumentNode,
+    variables?: TVariables,
+    shouldResubscribe?:
+      | boolean
+      | ((
+          SubscriptionProps<TData, TVariables>,
+          SubscriptionProps<TData, TVariables>
+        ) => boolean),
+    onSubscriptionData?: (OnSubscriptionDataOptions<TData>) => any,
+    children?: SubscriptionRenderPropFunction<TData, TVariables>,
+    ...
+  };
+
+  declare export class Subscription<TData, TVariables> extends React$Component<
+    SubscriptionProps<TData, TVariables>
+  > {}
+
+  declare type OperationVariables = { [key: string]: any, ... };
+
+  declare export type MutationFunction<
+    TData = any,
+    TVariables = OperationVariables
+  > = (options?: {
+    variables?: TVariables,
+    optimisticResponse?: Object,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    update?: MutationUpdaterFn<TData>,
+    ...
+  }) => Promise<void | FetchResult<TData>>;
+
+  declare export type MutationResult<TData = { [string]: any, ... }> = {
+    loading: boolean,
+    error?: ApolloError,
+    data?: TData,
+    called: boolean,
+    client: ApolloClient<any>,
+    ...
+  };
+
+  declare export type MutationRenderPropFunction<TData, TVariables> = (
+    mutate: MutationFunction<TData, TVariables>,
+    result: MutationResult<TData>
+  ) => Node;
+
+  declare export class Mutation<
+    TData,
+    TVariables = void
+  > extends React$Component<{
+    mutation: DocumentNode,
+    children: MutationRenderPropFunction<TData, TVariables>,
+    variables?: TVariables,
+    update?: MutationUpdaterFn<TData>,
+    ignoreResults?: boolean,
+    optimisticResponse?: Object,
+    refetchQueries?: RefetchQueryDescription | RefetchQueriesProviderFn,
+    onCompleted?: (data: TData) => mixed,
+    onError?: (error: ApolloError) => mixed,
+    context?: { [string]: any, ... },
+    ...
+  }> {}
+
+  declare export var compose: $Compose;
+}
diff --git a/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/test_react-apollo_v2.x.x.js b/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/test_react-apollo_v2.x.x.js
new file mode 100644
index 0000000000..f85cd6223c
--- /dev/null
+++ b/definitions/npm/react-apollo_v2.x.x/flow_v0.201.x-/test_react-apollo_v2.x.x.js
@@ -0,0 +1,849 @@
+// @flow
+import * as React from "react";
+import { it, describe } from "flow-typed-test";
+import {
+  ApolloProvider,
+  ApolloConsumer,
+  compose,
+  Query,
+  Mutation,
+  Subscription,
+  graphql,
+  withApollo,
+  type ApolloClient,
+  type MutationFunction,
+  type MutationResult,
+  type QueryRenderProps,
+  type OperationComponent,
+  type GraphqlQueryControls,
+  type ChildProps,
+  type GraphqlData,
+  type PureQueryOptions,
+  type SubscriptionResult,
+  type RefetchQueryDescription
+} from "react-apollo";
+
+const gql = (strings, ...args) => {}; // graphql-tag stub
+
+const query = gql`
+  {
+    foo
+  }
+`;
+const mutation = gql`
+  mutation {
+    foo
+  }
+`;
+
+type Hero = {
+  name: string,
+  id: string,
+  appearsIn: string[],
+  friends: Hero[],
+  ...
+};
+
+type IQuery = {
+  foo: string,
+  bar: string,
+  ...
+};
+
+const withData: OperationComponent<IQuery> = graphql(query);
+
+// Compose exists and passes type checking
+const noop = val => val;
+compose(
+  noop,
+  noop
+)(true);
+
+it("works with functional component", () => {
+  const FunctionalWithData = withData(({ data }) => {
+    // $FlowExpectedError string type being treated as numerical
+    if (data.foo > 1) return <span />;
+
+    return null;
+  });
+});
+
+it("works with class component, this requires a stricter definition", () => {
+  type BasicComponentProps = ChildProps<{...}, IQuery>;
+  class BasicComponent extends React.Component<BasicComponentProps> {
+    render() {
+      const { foo, bar } = this.props.data;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return <div>{foo.length} string length</div>;
+    }
+  }
+  const BasicClassWithData = withData(BasicComponent);
+});
+
+it("works with class component with it's own variable", () => {
+  type CmplxOwnProps = {| faz: string |};
+  type CmplxComponentProps = {
+    data: GraphqlQueryControls<> & IQuery,
+    // The mutation is actually required or we get a error at the withData
+    mutate: any,
+    ...
+  } & CmplxOwnProps;
+  class CmplxComponent extends React.Component<CmplxComponentProps> {
+    render() {
+      const {
+        data: { loading, error, bar, foo },
+        faz
+      } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return (
+        <div>
+          {foo.length} string length compared to faz {faz.length} length
+        </div>
+      );
+    }
+  }
+  const withFancyData: OperationComponent<IQuery, CmplxOwnProps> = graphql(
+    query
+  );
+  const CmplxWithData = withFancyData(CmplxComponent);
+});
+
+it("works with class component with it's own variable Props specified at the end", () => {
+  // Same as above but with the Props specified at the end
+  // since we don't rely on the ChildProps<P, R> we don't need the mutate: any
+  type Cmplx2OwnProps = { faz: string, ... }; // We can have exact own props as we don't rely on the TMergedProps
+  type Cmplx2ComponentProps = { data: IQuery & GraphqlQueryControls<>, ... } & Cmplx2OwnProps;
+  class Cmplx2Component extends React.Component<Cmplx2ComponentProps> {
+    render() {
+      const {
+        data: { loading, error, bar, foo },
+        faz
+      } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+
+      // $FlowExpectedError string type being treated as numerical
+      if (bar > 1) return null;
+
+      // The below works as expected
+      return (
+        <div>
+          {foo.length} string length compared to faz {faz.length} length
+        </div>
+      );
+    }
+  }
+  const withFancyData2: OperationComponent<IQuery, Cmplx2OwnProps, any, Cmplx2ComponentProps> = graphql(query);
+  const Cmplx2WithData = withFancyData2(Cmplx2Component);
+});
+
+const HERO_QUERY = gql`
+  query GetCharacter($episode: String!, $offset: Int) {
+    hero(episode: $episode, offset: $offset) {
+      name
+      id
+      friends {
+        name
+        id
+        appearsIn
+      }
+    }
+  }
+`;
+
+const OTHER_QUERY = gql`
+  query GetOther($other: String!) {
+    other(other: $other) {
+      name
+    }
+  }
+`;
+
+const HERO_MUTATION = gql`
+  mutation UpdateHero($input: HeroInput!) {
+    updateHero(input: $input) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+const HERO_SUBSCRIPTION = gql`
+  mutation onHeroUpdate($heroId: ID!) {
+    heroUpdated(heroId: $heroId) {
+      hero {
+        name
+        id
+      }
+    }
+  }
+`;
+
+it("works with Variables specified", () => {
+  type Response = { hero: Hero, ... };
+
+  type InputProps = { episode: string, ... };
+
+  type Variables = { episode: string, ... };
+
+  type Props = GraphqlData<Response, Variables> & { someProp: string, ... };
+
+  const withCharacter: OperationComponent<
+    Response,
+    InputProps,
+    Variables,
+    Props
+  > = graphql(HERO_QUERY, {
+    options: ({ episode }) => {
+      // $FlowExpectedError [string] The operand of an arithmetic operation must be a number
+      episode * 10;
+      return {
+        // $FlowExpectedError [number] This type is incompatible with string
+        variables: { episode: 10 }
+      };
+    },
+    props: ({ data, ownProps }) => ({
+      ...data,
+      // $FlowExpectedError [string] This type cannot be compared to number
+      episode: ownProps.episode > 1,
+      // $FlowExpectedError property `isHero`. Property not found on object type
+      isHero: data && data.hero && data.hero.isHero,
+      // $FlowExpectedError Property `someProp`. This type is incompatible with string
+      someProp: 1
+    })
+  });
+
+  withCharacter(({ loading, hero, error }) => {
+    if (loading) return <div>Loading</div>;
+    if (error) return <h1>ERROR</h1>;
+    return null;
+  });
+
+  class Character extends React.Component<Props> {
+    render() {
+      const { loading, hero, error } = this.props;
+      if (loading) return <div>Loading</div>;
+      if (error) return <h1>ERROR</h1>;
+      return null; // actual component with data;
+    }
+  }
+  const CharacterWithData = withCharacter(Character);
+});
+
+it("works with withApollo HOC", () => {
+  const Manual = withApollo(({ client }) => {
+    // XXX please don't ever actually do this
+    client.query({ query: HERO_QUERY });
+    return null;
+  });
+
+  // withApollo passes `client` property so that it is no longer required
+  (Manual: React.ComponentType<{...}>);
+});
+
+type HeroQueryVariables = {
+  episode: string,
+  offset?: ?number,
+  ...
+};
+class HeroQueryComp extends Query<
+  { hero: ?Hero, ... },
+  {
+    episode: string,
+    offset?: ?number,
+    ...
+  }
+> {}
+
+describe("<Query />", () => {
+  it("works", () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: "bar" };
+    const q = (
+      <Query variables={vars} query={HERO_QUERY}>
+        {({ data }: QueryRenderProps<Res, Vars>) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          // $FlowExpectedError Cannot get `data.res` because property `res` is missing in object type
+          const s: string = data.res;
+          if (data.res) {
+            const s: string = data.res;
+          }
+          return <div />;
+        }}
+      </Query>
+    );
+  });
+
+  it("works when extending Query with types", () => {
+    <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+      {({ data, loading, error }) => {
+        if (loading) return "Loading....";
+        if (error) return "Error!";
+        // $FlowExpectedError Cannot get `data.hero`. data may be undefined
+        data.hero;
+        if (!data || !data.hero) {
+          return <div />;
+        }
+        const hero = data.hero;
+
+        const nameAgain: string = hero.name;
+        // $FlowExpectedError unknown is not a property on Hero
+        const unknown = hero.unknown;
+
+        return <div>{nameAgain}</div>;
+      }}
+    </HeroQueryComp>;
+  });
+
+  it("raises an error if accessing a prop in children function that doesnt exist", () => {
+    <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+      {// $FlowExpectedError cannot render HeroQueryComp becuase errors is missing in children function (should be error instead of errors)
+      ({ data, loading, errors }) => {
+        if (loading) return "Loading....";
+        if (errors) return "Error!";
+        return String(data);
+      }}
+    </HeroQueryComp>;
+  });
+
+  describe("refetch", () => {
+    it("works if passed variablees that match the query", () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+        {({ data, refetch }) => {
+          const onClick = () => {
+            refetch();
+            refetch({ episode: "otherEpisode" });
+            // $FlowExpectedError refetch variables do not match variables for query
+            refetch({ notEpisode: "otherEpisode" });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+
+  describe("fetchMore", () => {
+    it("works when passed valid options", () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+        {({ data, fetchMore }) => {
+          const onClick = () => {
+            fetchMore({
+              variables: { episode: "episode2" },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero
+                };
+              }
+            });
+
+            const variables: $Shape<HeroQueryVariables> = { offset: 1 };
+            fetchMore({
+              variables: variables,
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero
+                };
+              }
+            });
+
+            const otherVariables = { other: "1234" };
+            fetchMore({
+              query: OTHER_QUERY,
+              variables: otherVariables,
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  other: options.fetchMoreResult.other
+                };
+              }
+            });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+
+    it("raises an error when passed invalid options", () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+        {({ data, fetchMore }) => {
+          const onClick = () => {
+            // $FlowExpectedError variables must match $Shape of query variables
+            fetchMore({
+              variables: { other: "hello" },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  hero: options.fetchMoreResult.hero
+                };
+              }
+            });
+
+            // $FlowExpectedError must pass query option if passing different variables than query
+            fetchMore({
+              variables: { other: "1234" },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                return {
+                  other: options.fetchMoreResult.other
+                };
+              }
+            });
+
+            fetchMore({
+              variables: { episode: "episode2" },
+              updateQuery: (prev, options) => {
+                if (!options.fetchMoreResult) return prev;
+                // $FlowExpectedError updateQuery return type must match query response type
+                return {
+                  other: options.fetchMoreResult.hero
+                };
+              }
+            });
+          };
+          return <button onClick={onClick}>Click!</button>;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+
+  describe("updateQuery", () => {
+    it("works", () => {
+      <HeroQueryComp query={HERO_QUERY} variables={{ episode: "episode" }}>
+        {({ updateQuery }) => {
+          // $FlowExpectedError updateQuery return type must match previous result type
+          updateQuery((previousResult, options) => ({ hello: "flow" }));
+          const renameHero = (newName: string) =>
+            updateQuery((previousResult, options) => {
+              // $FlowExpectedError Cannot get `options.unknownProperty` because property `unknownProperty` is missing in options
+              const a = options.unknownProperty;
+              const { variables } = options;
+              return { ...previousResult, name: newName };
+            });
+          return <div />;
+        }}
+      </HeroQueryComp>;
+    });
+  });
+});
+
+type HeroSubcriptionVariables = { heroId: string, ... };
+class HeroSubscriptionComp extends Subscription<
+  { hero: ?Hero, ... },
+  HeroSubcriptionVariables
+> {}
+
+describe("<Subscription />", () => {
+  it("works", () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: "1" };
+    const q = (
+      <Subscription variables={vars} subscription={HERO_SUBSCRIPTION}>
+        {({ data }: SubscriptionResult<Res, Vars>) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          // $FlowExpectedError Cannot get `data.res` because property `res` is missing in object type
+          const s: string = data.res;
+          const s: ?string = data.res;
+          return <div />;
+        }}
+      </Subscription>
+    );
+  });
+  it("works when extending Subscription with types", () => {
+    <HeroSubscriptionComp
+      subscription={HERO_SUBSCRIPTION}
+      variables={{ heroId: "123" }}
+    >
+      {({ data, loading, error }) => {
+        if (loading) return "Loading....";
+        if (error) return "Error!";
+        // $FlowExpectedError Cannot get `data.hero`. data may be undefined
+        data.hero;
+        if (!data || !data.hero) {
+          return <div />;
+        }
+        const hero = data.hero;
+
+        const nameAgain: string = hero.name;
+        // $FlowExpectedError unknown is not a property on Hero
+        const unknown = hero.unknown;
+
+        return <div>{nameAgain}</div>;
+      }}
+    </HeroSubscriptionComp>;
+  });
+  it("errors if wrong variables passed", () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const q = (
+      <Subscription variables={{ foo: 1 }} subscription={HERO_SUBSCRIPTION}>
+        {// $FlowExpectedError variables must match shape of query variables
+        ({ data }: SubscriptionResult<Res, Vars>) => {}}
+      </Subscription>
+    );
+  });
+  it("supports onSubscriptionData prop", function() {
+    const q = (
+      <Subscription
+        subscription={HERO_SUBSCRIPTION}
+        onSubscriptionData={({
+          client,
+          subscriptionData
+        }: {
+          client: ApolloClient<any>,
+          subscriptionData: SubscriptionResult<{ hero: ?Hero, ... }>,
+          ...
+        }) => {
+          const hero: ?Hero =
+            subscriptionData.data && subscriptionData.data.hero
+              ? subscriptionData.data.hero
+              : null;
+        }}
+      />
+    );
+  });
+});
+
+type UpdateHeroMutationVariables = { input: {
+  id: string,
+  name: string,
+  ...
+}, ... };
+class UpdateHeroMutationComp extends Mutation<
+  { updateHero?: ?{ hero: ?Hero, ... }, ... },
+  UpdateHeroMutationVariables
+> {}
+
+describe("<Mutation />", () => {
+  it("mutate() args are optional", () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: "bar" };
+    const q = (
+      <Mutation variables={vars} mutation={HERO_QUERY}>
+        {mutate => {
+          mutate();
+          return <div />;
+        }}
+      </Mutation>
+    );
+  });
+
+  it("works", () => {
+    type Vars = {| foo: string |};
+    type Res = {| res: string |};
+    const vars: Vars = { foo: "bar" };
+    const q = (
+      <Mutation variables={vars} mutation={HERO_QUERY}>
+        {(
+          update: MutationFunction<Res, Vars>,
+          { data, client }: MutationResult<Res>
+        ) => {
+          // $FlowExpectedError Cannot get `data.res`
+          data.res;
+          if (!data) {
+            return <div />;
+          }
+          const d1: Res = data;
+          const s: string = data.res;
+          client;
+          return <div />;
+        }}
+      </Mutation>
+    );
+  });
+
+  it("works when extending Mutation with types", () => {
+    <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+      {(updateHero, { loading, error, data, called }) => {
+        const onClick = () => {
+          updateHero({
+            variables: { input: { id: "1", name: "hero1" } }
+          });
+          // $FlowExpectedError variables must match Mutation variables
+          updateHero({
+            variables: { id: "1", name: "hero1" }
+          });
+        };
+        return (
+          <div>
+            <button disabled={loading} onClick={onClick}>
+              Click
+            </button>
+            {error && error.message}
+          </div>
+        );
+      }}
+    </UpdateHeroMutationComp>;
+  });
+
+  describe("optimisticResponse", () => {
+    it("works when passed an optimisticResponse object", () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const optimisticResponse = {
+            updateHero: {
+              __typename: "UpdateHeroPayload",
+              hero: {
+                __typename: "Hero",
+                name: "Hero1",
+                id: "1"
+              }
+            }
+          };
+          const onClick = () => {
+            updateHero({
+              optimisticResponse,
+              variables: { input: { id: "1", name: "hero1" } }
+            });
+
+            // $FlowExpectedError optimisticResponse must be an object
+            updateHero({
+              optimisticResponse: "optimisticResponse",
+              variables: { input: { id: "1", name: "hero1" } }
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+
+  describe("refetchQueries", () => {
+    it("works when passed refetchQueries to Mutation component", () => {
+      const queryOption = {
+        query: HERO_QUERY,
+        variables: { episode: "episode" }
+      };
+      const refetchQueries: RefetchQueryDescription = [queryOption, "foo"];
+
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        refetchQueries={refetchQueries}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } }
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+
+      // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        refetchQueries={queryOption}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } }
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+
+    it("works when passed refetchQueries to mutation function", () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const onClick = () => {
+            const queryOption = {
+              query: HERO_QUERY,
+              variables: { episode: "episode" }
+            };
+            const refetchQueries: PureQueryOptions[] = [queryOption];
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } },
+              refetchQueries
+            });
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } },
+              refetchQueries: () => refetchQueries
+            });
+
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } },
+              // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+              refetchQueries: () => queryOption
+            });
+            // $FlowExpectedError refetchQueries must be an array of queries or a function that returns an array of queries
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } },
+              refetchQueries: queryOption
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+
+  describe("update", () => {
+    it("can manually update the cache after a mutation by passing update prop to the Mutation component", () => {
+      <UpdateHeroMutationComp
+        mutation={HERO_MUTATION}
+        update={(cache, { data }) => {
+          // $FlowExpectedError data may be undefined
+          data.updateHero;
+          if (data && data.updateHero) {
+            const hero = cache.readQuery({
+              query: HERO_QUERY,
+              variables: { episoe: "episode" }
+            });
+            cache.writeQuery({
+              query: HERO_QUERY,
+              variables: { episode: "episode" },
+              data: { hero: data.updateHero }
+            });
+          }
+        }}
+      >
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } }
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+
+    it("can manually update the cache after a mutation using update on the mutation function", () => {
+      <UpdateHeroMutationComp mutation={HERO_MUTATION}>
+        {updateHero => {
+          const onClick = () => {
+            updateHero({
+              variables: { input: { id: "1", name: "hero1" } },
+              update: (cache, { data }) => {
+                // $FlowExpectedError data may be undefined
+                data.updateHero;
+
+                if (data && data.updateHero) {
+                  const hero = cache.readQuery({
+                    query: HERO_QUERY,
+                    variables: { episoe: "episode" }
+                  });
+                  cache.writeQuery({
+                    query: HERO_QUERY,
+                    variables: { episode: "episode" },
+                    data: { hero: data.updateHero }
+                  });
+                  if (data.updateHero && data.updateHero.hero) {
+                    cache.writeFragment({
+                      id: "1",
+                      fragment: gql`
+                        fragment myHero on Hero {
+                          name
+                        }
+                      `,
+                      data: {
+                        name: data.updateHero.hero.name
+                      }
+                    });
+                  }
+
+                  // $FlowExpectedError readQuery requires query
+                  cache.readQuery({
+                    variables: { episode: "episode" }
+                  });
+                  // $FlowExpectedError writeQuery requires data
+                  cache.writeQuery({
+                    query: HERO_QUERY,
+                    variables: { episode: "episode" }
+                  });
+                  // $FlowExpectedError writeFragment requires id
+                  cache.writeFragment({
+                    fragment: gql`
+                      fragment myHero on Hero {
+                        name
+                      }
+                    `,
+                    data: {
+                      name: "name"
+                    }
+                  });
+                  // $FlowExpectedError cannot call unknownFunction on cache
+                  cache.unknwonFunction();
+                }
+              }
+            });
+          };
+          return <button onClick={onClick}>Click</button>;
+        }}
+      </UpdateHeroMutationComp>;
+    });
+  });
+});
+
+describe("<ApolloProvider />", () => {
+  it("works when passed client", () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+    <ApolloProvider client={client}>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it("raises an error when not passed a client", () => {
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it("raises an error when not passed children", () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+
+    // $FlowExpectedError ApolloPrivder requires client prop
+    <ApolloProvider client={client} />;
+  });
+});
+
+describe("<ApolloConsumer />", () => {
+  it("passes ApolloClient to the consumer children", () => {
+    <ApolloConsumer>
+      {client => {
+        const onClick = () => {
+          client.resetStore();
+          client.query({ query: HERO_QUERY });
+          client.readQuery({
+            query: HERO_QUERY,
+            variables: { episode: "episode" }
+          });
+          // $FlowExpectedError doSomethingElse is not a method of ApolloClient
+          client.doSomethingElse();
+        };
+        return <button onClick={onClick}>Click</button>;
+      }}
+    </ApolloConsumer>;
+  });
+});
diff --git a/definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-/react-bootstrap_v0.32.x.js b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-v.200.x/react-bootstrap_v0.32.x.js
similarity index 100%
rename from definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-/react-bootstrap_v0.32.x.js
rename to definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-v.200.x/react-bootstrap_v0.32.x.js
diff --git a/definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-/test_react-bootstrap_v0.32.x.js b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-v.200.x/test_react-bootstrap_v0.32.x.js
similarity index 100%
rename from definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-/test_react-bootstrap_v0.32.x.js
rename to definitions/npm/react-bootstrap_v0.32.x/flow_v0.104.x-v.200.x/test_react-bootstrap_v0.32.x.js
diff --git a/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/react-bootstrap_v0.32.x.js b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/react-bootstrap_v0.32.x.js
new file mode 100644
index 0000000000..e68e9ad7c6
--- /dev/null
+++ b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/react-bootstrap_v0.32.x.js
@@ -0,0 +1,762 @@
+declare module "react-bootstrap" {
+  import type { Node, Element, Component, ComponentType, Ref } from 'react';
+  declare type BsSize = 'lg' | 'large' | 'sm' | 'small';
+  declare type BsStyle = 'lg' | 'large' | 'sm' | 'small' | 'xs' | 'xsmall';
+  declare type ElementType = string | ComponentType<any>;
+  declare type TriggerType = 'click' | 'hover' | 'focus';
+  declare export class Alert extends React$Component<{
+    onDismiss?: Function,
+    closeLabel?: string,
+    bsStyle?: 'success' | 'warning' | 'danger' | 'info',
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Badge extends React$Component<{
+    pullRight?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare class BreadcrumbItem extends React$Component<{
+    active?: boolean,
+    href: string,
+    title: Node,
+    target: string,
+    ...
+  }> {}
+
+  declare export class Breadcrumb extends React$Component<{...}> {
+    static Item: Class<BreadcrumbItem>;
+  }
+
+  declare export class Button extends React$Component<{
+    active?: boolean,
+    disabled?: boolean,
+    block?: boolean,
+    onClick?: Function,
+    componentClass?: ElementType,
+    href?: string,
+    type?: 'button' | 'reset' | 'submit',
+    bsStyle?: 'default' | 'primary' | 'success' | 'info' | 'warning' | 'danger' | 'link',
+    bsSize?: BsStyle,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class ButtonGroup extends React$Component<{
+    vertical?: boolean,
+    justified?: boolean,
+    block?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class ButtonToolbar extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare export class ButtonToolbar extends React$Component<{
+    name?: string,
+    value?: any,
+    onChange?: Function,
+    type: 'checkbox' | 'radio',
+    ...
+  }> {}
+
+  declare export class ToggleButton extends React$Component<{
+    type?: string,
+    name?: string,
+    checker?: boolean,
+    disabled?: boolean,
+    onChange?: Function,
+    value: any,
+    ...
+  }> {}
+
+  declare class CarouselItem extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare class CarouselCaption extends React$Component<{
+    direction?: 'prev' | 'next',
+    onAnimateOutEnd?: Function,
+    active?: boolean,
+    animateIn?: boolean,
+    animateOut?: boolean,
+    index: number,
+    ...
+  }> {}
+
+  declare export class Carousel extends React$Component<{
+    slide?: boolean,
+    indicators?: boolean,
+    interval?: number,
+    controls?: boolean,
+    pauseOnHover?: boolean,
+    wrap?: boolean,
+    onSelect?: Function,
+    onSelect?: Function,
+    onSlideEnd?: Function,
+    activeIndex?: number,
+    defaultActiveIndex?: number,
+    direction?: 'prev' | 'next',
+    prevIcon?: Node,
+    prevLabel?: string,
+    nextIcon?: Node,
+    nextLabel?: string,
+    bsClass?: string,
+    ...
+  }> {
+    static Item: Class<CarouselItem>;
+    static Caption: Class<CarouselCaption>;
+  }
+
+  declare export class DropdownButton extends React$Component<{
+    bsStyle?: string,
+    bsSize?: string,
+    title: Node,
+    noCaret?: boolean,
+    ...
+  }> {}
+
+  declare export class SplitButton extends React$Component<{
+    bsStyle?: string,
+    bsSize?: string,
+    href?: string,
+    onClick?: Function,
+    title: Node,
+    toggleLabel?: string,
+    ...
+  }> {}
+
+  declare class DropdownMenu extends React$Component<{...}> {}
+  declare class DropdownToggle extends React$Component<{...}> {}
+
+  declare export class Dropdown extends React$Component<{
+    dropup?: boolean,
+    id: string | number,
+    componentClass?: ElementType,
+    disabled?: boolean,
+    pullRight?: boolean,
+    pullRight?: boolean,
+    open?: boolean,
+    defaultOpen?: boolean,
+    onToggle?: Function,
+    onSelect?: Function,
+    role?: string,
+    rootCloseEvent?: 'click' | 'mousedown',
+    onMouseEnter?: Function,
+    onMouseLeave?: Function,
+    ...
+  }> {
+    static Menu: Class<DropdownMenu>;
+    static Toggle: Class<DropdownToggle>;
+  }
+
+  declare export class MenuItem extends React$Component<{
+    active?: boolean,
+    disabled?: boolean,
+    //TODO: figure out proper type
+    divider?: any,
+    eventKey?: any,
+    header?: boolean,
+    href?: string,
+    onClick?: Function,
+    onSelect?: Function,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class FormGroup extends React$Component<{
+    controlId?: string,
+    validationState?: 'success' | 'warning' | 'error' | null,
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare class FormControlStatic extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare class FormControlFeedback extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare export class FormControl extends React$Component<{
+    componentClass?: ElementType,
+    type?: string,
+    id?: string,
+    inputRef?: Ref<'input'>,
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {
+    static Static: Class<FormControlStatic>;
+    static Feedback: Class<FormControlFeedback>;
+  }
+
+  declare export class ControlLabel extends React$Component<{
+    htmlFor?: string,
+    srOnly?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Checkbox extends React$Component<{
+    inline?: boolean,
+    disabled?: boolean,
+    title?: string,
+    validateState?: 'success' | 'warning' | 'error' | null,
+    inputRef?: Ref<'input'>,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Radio extends React$Component<{
+    inline?: boolean,
+    disabled?: boolean,
+    title?: string,
+    validateState?: 'success' | 'warning' | 'error' | null,
+    inputRef?: Ref<'input'>,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class HelpBlock extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare export class Form extends React$Component<{
+    horizontal?: boolean,
+    inline?: boolean,
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare class InputGroupAddon extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare class InputGroupButton extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare export class InputGroup extends React$Component<{
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {
+    static Addon: Class<InputGroupAddon>;
+    static Button: Class<InputGroupButton>;
+  }
+
+  declare export class Image extends React$Component<{
+    responsive?: boolean,
+    rounded?: boolean,
+    circle?: boolean,
+    thumbnail?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Thumbnail extends React$Component<{
+    src?: string,
+    alt?: string,
+    href?: string,
+    onError?: Function,
+    onLoad?: Function,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Jumbotron extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Label extends React$Component<{
+    bsStyle?: 'success' | 'warning' | 'danger' | 'info' | 'default' | 'primary',
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class ListGroup extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class ListGroupItem extends React$Component<{
+    active?: any,
+    disabled?: any,
+    header?: Node,
+    listItem?: boolean,
+    onClick?: Function,
+    href?: string,
+    type?: string,
+    bsStyle?: 'success' | 'warning' | 'danger' | 'info',
+    bsClass?: string,
+    ...
+  }> {}
+
+
+  declare class MediaBody extends React$Component<{
+    align?: 'top' | 'middle' | 'bottom',
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class MediaLeft extends React$Component<{
+    align?: 'top' | 'middle' | 'bottom',
+    bsClass?: string,
+    ...
+  }> {}
+  declare export class Media extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {
+    static Body: Class<MediaBody>;
+    static Left: Class<MediaLeft>;
+  }
+
+  declare class Dialog extends React$Component<{
+    dialogClassName?: string,
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class Header extends React$Component<{
+    closeLabel?: string,
+    closeButton?: boolean,
+    onHide?: Function,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class Title extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class Body extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class Footer extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+  declare export class Modal extends React$Component<{
+    backdrop?: 'static' | boolean,
+    backdropClassName?: string,
+    keyboard?: boolean,
+    animation?: boolean,
+    dialogComponentClass?: ElementType,
+    autoFocus?: boolean,
+    enforceFocus?: boolean,
+    restoreFocus?: boolean,
+    show?: boolean,
+    onHide?: Function,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    container?: Node | Component<any> | (...args: Array<any>) => Node,
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {
+    static Dialog: Class<Dialog>;
+    static Header: Class<Header>;
+    static Title: Class<Title>;
+    static Body: Class<Body>;
+    static Footer: Class<Footer>;
+  }
+
+  declare export class Nav extends React$Component<{
+    activeKey?: any,
+    activeHref?: string,
+    // TODO: figure out proper type
+    justified?: any,
+    onSelect?: Function,
+    role?: string,
+    navbar?: boolean,
+    pullRight?: boolean,
+    pullLeft?: boolean,
+    bsStyle?: 'tabs' | 'pills',
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class NavDropdown extends React$Component<{...}> {}
+
+  declare export class NavItem extends React$Component<{
+    active?: boolean,
+    disabled?: boolean,
+    role?: string,
+    href?: string,
+    onClick?: Function,
+    onSelect?: Function,
+    eventKey?: any,
+    ...
+  }> {}
+
+  declare class NavbarHeader extends React$Component<{...}> {}
+  declare class NavbarBrand extends React$Component<{...}> {}
+  declare class NavbarToggle extends React$Component<{ onClick?: Function, ... }> {}
+  declare class NavbarCollapse extends React$Component<{...}> {}
+  declare class NavbarForm extends React$Component<{...}> {}
+  declare class NavbarLink extends React$Component<{...}> {}
+  declare class NavbarText extends React$Component<{...}> {}
+
+  declare export class Navbar extends React$Component<{
+    fixedTop?: boolean,
+    fixedBottom?: boolean,
+    staticTop?: boolean,
+    inverse?: boolean,
+    fluid?: boolean,
+    componentClass?: ElementType,
+    onToggle?: Function,
+    onSelect?: Function,
+    collapseOnSelect?: boolean,
+    expanded?: boolean,
+    role?: string,
+    bsStyle?: 'default' | 'inverse',
+    ...
+  }> {
+    static Header: Class<NavbarHeader>;
+    static Brand: Class<NavbarBrand>;
+    static Toggle: Class<NavbarToggle>;
+    static Collapse: Class<NavbarCollapse>;
+    static Form: Class<NavbarForm>;
+    static Link: Class<NavbarLink>;
+    static Text: Class<NavbarText>;
+  }
+
+  declare export class Overlay extends React$Component<{
+    show?: boolean,
+    rootClose?: boolean,
+    onHide?: Function,
+    animation?: boolean | ElementType,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    placement?: 'top' | 'right' | 'bottom' | 'left',
+    ...
+  }> {}
+
+  declare export class PageHeader extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare class PagerItem extends React$Component<{
+    disabled?: boolean,
+    previous?: boolean,
+    next?: boolean,
+    onClick?: Function,
+    onSelect?: Function,
+    eventKey?: any,
+    ...
+  }> {}
+
+  declare export class Pager extends React$Component<{
+    onSelect?: Function,
+    bsClass?: string,
+    ...
+  }> {
+    static Item: Class<PagerItem>;
+  }
+
+  declare class PaginationItem extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare class PaginationFirst extends React$Component<{ bsClass?: string, ... }> {}
+
+  
+  declare class PaginationLast extends React$Component<{ bsClass?: string, ... }> {}
+  
+  declare class PaginationPrev extends React$Component<{ bsClass?: string, ... }> {}
+  
+  declare class PaginationNext extends React$Component<{ bsClass?: string, ... }> {}
+  
+  declare class PaginationEllipsis extends React$Component<{ bsClass?: string, ... }> {}
+
+  declare export class Pagination extends React$Component<{ bsClass?: string, ... }> {
+    static Item: Class<PaginationItem>;
+    static First: Class<PaginationFirst>;
+    static Last: Class<PaginationLast>;
+    static Prev: Class<PaginationPrev>;
+    static Next: Class<PaginationNext>;
+    static Ellipsis: Class<PaginationEllipsis>;
+  }
+
+  declare class PanelHeading extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class PanelBody extends React$Component<{
+    collapsible: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class PanelTitle extends React$Component<{
+    componentClass?: ElementType,
+    toggle?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class PanelCollapse extends React$Component<{
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    bsClass?: string,
+    ...
+  }> {}
+  declare class PanelToggle extends React$Component<{
+    onClick?: Function,
+    componentClass?: ElementType,
+    ...
+  }> {}
+  declare class PanelFooter extends React$Component<{ bsClass?: string, ... }> {}
+  declare export class Panel extends React$Component<{
+    expanded?: boolean,
+    onToggle?: Function,
+    eventKey?: any,
+    id?: string,
+    ...
+  }> {
+    static Heading: Class<PanelHeading>;
+    static Body: Class<PanelBody>;
+    static Title: Class<PanelTitle>;
+    static Collapse: Class<PanelCollapse>;
+    static Toggle: Class<PanelToggle>;
+    static Footer: Class<PanelFooter>;
+  }
+
+  declare export class PanelGroup extends React$Component<{
+    accordion?: boolean,
+    activeKey?: any,
+    onSelect?: Function,
+    role?: string,
+    generateChildId?: (eventKey: string, type: string) => string,
+    id?: string,
+    ...
+  }> {}
+
+  declare export class Popover extends React$Component<{
+    id: string,
+    placement?: 'top' | 'right' | 'bottom' | 'left',
+    positionTop?: string | number,
+    positionLeft?: string | number,
+    arrowOffsetTop?: string | number,
+    arrowOffsetLeft?: string | number,
+    title?: Node,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class ProgressBar extends React$Component<{
+    min?: number,
+    now?: number,
+    max?: number,
+    label?: Node,
+    srOnly?: boolean,
+    striped?: boolean,
+    active?: boolean,
+    children?: Element<typeof ProgressBar>,
+    isChild?: boolean,
+    bsStyle?: 'success' | 'warning' | 'danger' | 'info',
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Table extends React$Component<{
+    striped?: boolean,
+    bordered?: boolean,
+    condensed?: boolean,
+    hover?: boolean,
+    responsive?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Tabs extends React$Component<{
+    activeKey?: any,
+    bsStyle?: 'tabs' | 'pills',
+    animation?: boolean,
+    id?: string,
+    onSelect?: Function,
+    mountOnEnter?: boolean,
+    unmountOnExit?: boolean,
+    ...
+  }> {}
+
+  declare export class Tab extends React$Component<{
+    disabled?: boolean,
+    title?: Node,
+    tabClassName?: string,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class TabContainer extends React$Component<{
+    id: string,
+    generateChildId?: (eventKey: string, type: string) => string,
+    onSelect?: Function,
+    activeKey?: any,
+    ...
+  }> {}
+
+  declare export class TabContent extends React$Component<{
+    componentClass?: ElementType,
+    animation?: boolean | ElementType,
+    mountOnEnter?: boolean,
+    unmountOnExit?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class TabPane extends React$Component<{
+    eventKey?: any,
+    animation?: boolean | string,
+    id?: string,
+    'aria-labelledby'?: string,
+    bsClass?: string,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    mountOnEnter?: boolean,
+    unmountOnExit?: boolean,
+    ...
+  }> {}
+
+  declare export class OverlayTrigger extends React$Component<{
+    trigger?: TriggerType | Array<TriggerType>,
+    delay?: number,
+    delayShow?: number,
+    delayHide?: number,
+    defaultOverlayShown?: boolean,
+    overlay: Node,
+    onBlur?: Function,
+    onClick?: Function,
+    onFocus?: Function,
+    onMouseOut?: Function,
+    onMouseOver?: Function,
+    target?: null,
+    onHide?: null,
+    show?: null,
+    ...
+  }> {}
+
+  declare export class Tooltip extends React$Component<{
+    id: string | number,
+    placement?: 'top' | 'right' | 'bottom' | 'left',
+    positionTop?: string | number,
+    positionLeft?: string | number,
+    arrowOffsetTop?: string | number,
+    arrowOffsetLeft?: string | number,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Well extends React$Component<{
+    bsSize?: BsSize,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Collapse extends React$Component<{
+    in?: boolean,
+    mountOnEnter?: boolean,
+    unmountOnExit?: boolean,
+    appear?: boolean,
+    timeout?: number,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    dimension?: 'height' | 'width' | Function,
+    getDimensionValue?: Function,
+    role?: string,
+    ...
+  }> {}
+
+  declare export class Fade extends React$Component<{
+    in?: boolean,
+    mountOnEnter?: boolean,
+    unmountOnExit?: boolean,
+    appear?: boolean,
+    timeout?: number,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    dimension?: 'height' | 'width' | Function,
+    getDimensionValue?: Function,
+    role?: string,
+    ...
+  }> {}
+
+  declare export class Grid extends React$Component<{
+    fluid?: boolean,
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Row extends React$Component<{
+    componentClass?: ElementType,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Col extends React$Component<{
+    componentClass?: ElementType,
+    xs?: number,
+    sm?: number,
+    md?: number,
+    lg?: number,
+    xsHidden?: boolean,
+    smHidden?: boolean,
+    mdHidden?: boolean,
+    lgHidden?: boolean,
+    xsOffset?: number,
+    smOffset?: number,
+    mdOffset?: number,
+    lgOffset?: number,
+    xsPush?: number,
+    smPush?: number,
+    mdPush?: number,
+    lgPush?: number,
+    xsPull?: number,
+    smPull?: number,
+    mdPull?: number,
+    lgPull?: number,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Row extends React$Component<{
+    componentClass?: ElementType,
+    visibleXsBlock?: boolean,
+    visibleSmBlock?: boolean,
+    visibleMdBlock?: boolean,
+    visibleLgBlock?: boolean,
+    bsClass?: string,
+    ...
+  }> {}
+
+  declare export class Glyphicon extends React$Component<{ glyph: string, ... }> {}
+}
diff --git a/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/test_react-bootstrap_v0.32.x.js b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/test_react-bootstrap_v0.32.x.js
new file mode 100644
index 0000000000..16ff72b426
--- /dev/null
+++ b/definitions/npm/react-bootstrap_v0.32.x/flow_v0.201.x-/test_react-bootstrap_v0.32.x.js
@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { Checkbox, Dropdown, FormControl, Glyphicon, Overlay, Radio } from 'react-bootstrap';
+
+
+// normal components works
+(<Dropdown id={123}></Dropdown>: React.Node);
+(<Overlay></Overlay>: React.Node);
+
+// nested components works too
+(<Dropdown.Toggle></Dropdown.Toggle>: React.Node);
+
+// inputRefs gives HTMLInputElements
+(<FormControl inputRef={(ref) => {(ref: ?HTMLInputElement)}}/>: React.Node);
+(<Checkbox inputRef={(ref) => {(ref: ?HTMLInputElement)}} />: React.Node);
+(<Radio inputRef={(ref) => {(ref: ?HTMLInputElement)}} />: React.Node);
+
+(<Glyphicon glyph="string" />: React.Node);
diff --git a/definitions/npm/react-collapsible_v2.x.x/flow_v0.104.x-/react-collapsible_v2.x.x.js b/definitions/npm/react-collapsible_v2.x.x/flow_v0.104.x-v.200.x/react-collapsible_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-collapsible_v2.x.x/flow_v0.104.x-/react-collapsible_v2.x.x.js
rename to definitions/npm/react-collapsible_v2.x.x/flow_v0.104.x-v.200.x/react-collapsible_v2.x.x.js
diff --git a/definitions/npm/react-collapsible_v2.x.x/flow_v0.201.x-/react-collapsible_v2.x.x.js b/definitions/npm/react-collapsible_v2.x.x/flow_v0.201.x-/react-collapsible_v2.x.x.js
new file mode 100644
index 0000000000..99c01a27ec
--- /dev/null
+++ b/definitions/npm/react-collapsible_v2.x.x/flow_v0.201.x-/react-collapsible_v2.x.x.js
@@ -0,0 +1,40 @@
+declare module "react-collapsible" {
+  declare type Props = {
+    transitionTime?: number,
+    transitionCloseTime?: number,
+    triggerTagName?: string,
+    easing?: string,
+    open?: boolean,
+    classParentString?: string,
+    openedClassName?: string,
+    triggerStyle?: Object,
+    triggerClassName?: string,
+    triggerOpenedClassName?: string,
+    contentOuterClassName?: string,
+    contentInnerClassName?: string,
+    accordionPosition?: string | number,
+    handleTriggerClick?: (accordionPosition?: string | number) => void,
+    onOpen?: () => void,
+    onClose?: () => void,
+    onOpening?: () => void,
+    onClosing?: () => void,
+    trigger: string | React$Element<any>,
+    triggerWhenOpen?: string | React$Element<any>,
+    triggerDisabled?: boolean,
+    lazyRender?: boolean,
+    overflowWhenOpen?:
+      | "hidden"
+      | "visible"
+      | "auto"
+      | "scroll"
+      | "inherit"
+      | "initial"
+      | "unset",
+    triggerSibling?: string | React$Element<any> | (() => React$Node),
+    tabIndex?: number,
+    ...
+  };
+
+  declare class Collapsible extends React$Component<Props> {}
+  declare module.exports: typeof Collapsible;
+}
diff --git a/definitions/npm/react-color_v2.x.x/flow_v0.104.x-/react-color_v2.x.x.js b/definitions/npm/react-color_v2.x.x/flow_v0.104.x-v.200.x/react-color_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-color_v2.x.x/flow_v0.104.x-/react-color_v2.x.x.js
rename to definitions/npm/react-color_v2.x.x/flow_v0.104.x-v.200.x/react-color_v2.x.x.js
diff --git a/definitions/npm/react-color_v2.x.x/flow_v0.104.x-/test_react-color_v2.x.x.js b/definitions/npm/react-color_v2.x.x/flow_v0.104.x-v.200.x/test_react-color_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-color_v2.x.x/flow_v0.104.x-/test_react-color_v2.x.x.js
rename to definitions/npm/react-color_v2.x.x/flow_v0.104.x-v.200.x/test_react-color_v2.x.x.js
diff --git a/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/react-color_v2.x.x.js b/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/react-color_v2.x.x.js
new file mode 100644
index 0000000000..efc9e176e4
--- /dev/null
+++ b/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/react-color_v2.x.x.js
@@ -0,0 +1,239 @@
+declare module "react-color" {
+  import type { ComponentType, Component } from 'react';
+  declare export type HexColor = string;
+
+  declare export type HSLColor = {|
+    h: number,
+    s: number,
+    l: number,
+    a?: number
+  |};
+
+  declare export type HSVColor = {|
+    h: number,
+    s: number,
+    v: number,
+    a?: number
+  |};
+
+  declare export type RGBColor = {|
+    r: number,
+    g: number,
+    b: number,
+    a?: number
+  |};
+
+  declare export type Color = HexColor | HSLColor | HSVColor | RGBColor;
+
+  declare export type ColorResult = {|
+    hex: HexColor,
+    hsl: HSLColor,
+    hsv: HSVColor,
+    rgb: RGBColor
+  |};
+
+  declare export type ColorChangeHandler = (color: ColorResult) => void;
+
+  declare export type ColorPickerProps = {|
+    color?: Color,
+    onChange?: ColorChangeHandler,
+    onChangeComplete?: ColorChangeHandler
+  |};
+
+  declare export type AlphaPickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    height?: string,
+    direction?: "horizontal" | "vertical",
+    renderers?: Object,
+    pointer?: ComponentType<any>
+  |};
+
+  declare export type BlockPickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    colors?: Array<string>,
+    triangle?: "hide" | "top",
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type ChromePickerProps = {|
+    ...ColorPickerProps,
+    className?: string,
+    defaultView?: "hex" | "hsl" | "rgb",
+    disableAlpha?: boolean,
+    renderers?: Object,
+    width?: number | string,
+    styles?: {
+      ...
+    },
+  |};
+
+  declare export type CirclePickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    colors?: Array<string>,
+    circleSize?: number,
+    circleSpacing?: number,
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type CompactPickerProps = {|
+    ...ColorPickerProps,
+    colors?: Array<string>,
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type GithubPickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    colors?: Array<string>,
+    triangle?: "hide" | "top-left" | "top-right",
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type HuePickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    height?: string,
+    direction?: "horizontal" | "vertical",
+    pointer?: ComponentType<any>
+  |};
+
+  declare export type MaterialPickerProps = {|
+    ...ColorPickerProps
+  |};
+
+  declare export type PhotoshopPickerProps = {|
+    ...ColorPickerProps,
+    header?: string,
+    onAccept?: () => void,
+    onCancel?: () => void
+  |};
+
+  declare export type SketchPickerProps = {|
+    ...ColorPickerProps,
+    disableAlpha?: boolean,
+    presetColors?: Array<string | {| color: string, title: string |}>,
+    width?: number,
+    renderers?: Object,
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type SliderPickerProps = {|
+    ...ColorPickerProps,
+    pointer?: ComponentType<any>
+  |};
+
+  declare export type SwatchesPickerProps = {|
+    ...ColorPickerProps,
+    width?: number,
+    height?: number,
+    colors?: Array<Array<string>>,
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type TwitterPickerProps = {|
+    ...ColorPickerProps,
+    width?: string,
+    colors?: Array<string>,
+    triangle?: "hide" | "top-left" | "top-right",
+    onSwatchHover?: (color: Color, event: SyntheticMouseEvent<any>) => void
+  |};
+
+  declare export type ColorWrapChangeHandler = (
+    color: Color | ColorResult
+  ) => void;
+
+  declare export type InjectedColorProps = {
+    hex: string,
+    hsl: HSLColor,
+    hsv: HSVColor,
+    rgb: RGBColor,
+    oldHue: number,
+    onChange?: ColorWrapChangeHandler,
+    source: string,
+    ...
+  };
+
+  declare export var AlphaPicker: Class<Component<AlphaPickerProps>>;
+  declare export var BlockPicker: Class<Component<BlockPickerProps>>;
+  declare export var ChromePicker: Class<Component<ChromePickerProps>>;
+  declare export var CirclePicker: Class<Component<CirclePickerProps>>;
+  declare export var CompactPicker: Class<Component<CompactPickerProps>>;
+  declare export var GithubPicker: Class<Component<GithubPickerProps>>;
+  declare export var HuePicker: Class<Component<HuePickerProps>>;
+  declare export var MaterialPicker: Class<Component<MaterialPickerProps>>;
+  declare export var PhotoshopPicker: Class<Component<PhotoshopPickerProps>>;
+  declare export var SketchPicker: Class<Component<SketchPickerProps>>;
+  declare export var SliderPicker: Class<Component<SliderPickerProps>>;
+  declare export var SwatchesPicker: Class<Component<SwatchesPickerProps>>;
+  declare export var TwitterPicker: Class<Component<TwitterPickerProps>>;
+
+  declare export function CustomPicker<
+    Props: InjectedColorProps,
+    Comp: ComponentType<Props>,
+  >(
+    Component: Comp
+  ): ComponentType<$Diff<React$ElementConfig<Comp>, InjectedColorProps>>;
+}
+
+declare module "react-color/lib/components/common" {
+  import type { ComponentType, Component } from 'react';
+  import type {
+    HexColor,
+    RGBColor,
+    HSLColor,
+    HSVColor,
+    ColorChangeHandler
+  } from "react-color";
+
+  declare type PartialColorResult = {|
+    hex?: HexColor,
+    hsl?: HSLColor,
+    hsv?: HSVColor,
+    rgb?: RGBColor
+  |};
+
+  declare export type AlphaProps = {|
+    ...PartialColorResult,
+    pointer?: ComponentType<any>,
+    onChange?: ColorChangeHandler
+  |};
+
+  declare export type EditableInputProps = {|
+    label?: string,
+    value?: any,
+    onChange?: ColorChangeHandler,
+    style?: {|
+      input?: Object,
+      label?: Object,
+      wrap?: Object
+    |}
+  |};
+
+  declare export type HueProps = {|
+    ...PartialColorResult,
+    pointer?: ComponentType<any>,
+    onChange?: ColorChangeHandler,
+    direction?: "horizontal" | "vertical"
+  |};
+
+  declare export type SaturationProps = {|
+    ...PartialColorResult,
+    pointer?: ComponentType<any>,
+    onChange?: ColorChangeHandler
+  |};
+
+  declare export type CheckboardProps = {|
+    size?: number,
+    white?: string,
+    grey?: string
+  |};
+
+  declare export var Alpha: Class<Component<AlphaProps>>;
+  declare export var EditableInput: Class<Component<EditableInputProps>>;
+  declare export var Hue: Class<Component<HueProps>>;
+  declare export var Saturation: Class<Component<SaturationProps>>;
+  declare export var Checkboard: Class<Component<CheckboardProps>>;
+}
diff --git a/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/test_react-color_v2.x.x.js b/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/test_react-color_v2.x.x.js
new file mode 100644
index 0000000000..693b96a9ab
--- /dev/null
+++ b/definitions/npm/react-color_v2.x.x/flow_v0.201.x-/test_react-color_v2.x.x.js
@@ -0,0 +1,224 @@
+// @flow
+import React from "react";
+import {
+  AlphaPicker,
+  BlockPicker,
+  ChromePicker,
+  CirclePicker,
+  CompactPicker,
+  GithubPicker,
+  HuePicker,
+  PhotoshopPicker,
+  SketchPicker,
+  SliderPicker,
+  SwatchesPicker,
+  TwitterPicker,
+  CustomPicker
+} from "react-color";
+import type { InjectedColorProps } from "react-color"
+import { EditableInput, Hue } from "react-color/lib/components/common";
+import { describe, it } from "flow-typed-test";
+
+describe('react-color', () => {
+
+  describe('color', () => it('described correctly', () => {
+    // $FlowExpectedError (hex color should be a string)
+    <AlphaPicker color={101010} />;
+    <AlphaPicker color="#101010" />;
+
+    // $FlowExpectedError (hsl[a] object shouldn't have typos)
+    <BlockPicker color={{ h: 1, s: 1, I: 1 }} />;
+    <BlockPicker color={{ h: 1, s: 1, l: 1 }} />;
+    <BlockPicker color={{ h: 1, s: 1, l: 1, a: 1 }} />;
+
+    // $FlowExpectedError (rgb[a] object shouldn't have typos)
+    <ChromePicker color={{ r: 1, g: 1, p: 1 }} />;
+    <ChromePicker color={{ r: 1, g: 1, b: 1 }} />;
+    <ChromePicker color={{ r: 1, g: 1, b: 1, a: 1 }} />;
+  }));
+
+  describe('onChange', () => it('described correctly', () => {
+    <CirclePicker
+      onChange={color => {
+        (color.hex: string);
+        // $FlowExpectedError (hsl should be an HSLColor object)
+        (color.hsl: string);
+        // $FlowExpectedError (rgb should be an RGBColor object)
+        (color.rgb: string);
+      }}
+    />
+  }));
+
+  describe('onChangeComplete', () => it('described correctly', () => {
+    <CompactPicker
+      onChangeComplete={color => {
+        (color.hex: string);
+        (color.hsl: {
+          h: number,
+          s: number,
+          l: number,
+          a?: number,
+          ...
+        });
+        // $FlowExpectedError (rgb should be an RGBColor object)
+        (color.rgb: string);
+      }}
+    />
+  }));
+
+  /**
+   * Test unique component props
+   */
+
+  describe('AlphaPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (height shouldn't have a typo)
+    <AlphaPicker hight="300" />;
+    <AlphaPicker height="300" />;
+  }));
+
+  describe('BlockPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (width should be a string)
+    <BlockPicker width={300} />;
+    <BlockPicker width="300" />;
+  }));
+
+  describe('ChromePicker', () => it('described correctly', () => {
+    <ChromePicker className={undefined} />;
+    // $FlowExpectedError className should be a string
+    <ChromePicker className={1} />;
+    <ChromePicker className="test-class-name" />;
+
+    <ChromePicker defaultView={undefined} />;
+    // $FlowExpectedError className should be a string
+    <ChromePicker defaultView={1} />;
+    <ChromePicker defaultView="hex" />;
+    <ChromePicker defaultView="hsl" />;
+    <ChromePicker defaultView="hex" />;
+    // $FlowExpectedError string [1] is incompatible with enum [2] in property `defaultView`
+    <ChromePicker defaultView="unknown" />;
+
+    // $FlowExpectedError (disableAlpha should be a boolean)
+    <ChromePicker disableAlpha="false" />;
+    <ChromePicker disableAlpha={false} />;
+
+    // $FlowExpectedError in property `width`: [incompatible-type]
+    <ChromePicker width />;
+    // $FlowExpectedError in property `width`: [incompatible-type]
+    <ChromePicker width={false} />;
+    <ChromePicker width={10} />;
+    <ChromePicker width="100%" />;
+
+    // $FlowExpectedError boolean [1] is incompatible with object type [2] in property `styles`
+    <ChromePicker styles />;
+    // $FlowExpectedError number [1] is incompatible with object type [2] in property `styles`
+    <ChromePicker styles={10} />;
+    <ChromePicker styles={{width: "100%"}} />;
+  }));
+
+  describe('CirclePicker', () => it('described correctly', () => {
+    // $FlowExpectedError (colors should be an array of stirngs)
+    <CirclePicker colors={[{ r: 1, g: 1, b: 1 }]} />;
+    <CirclePicker colors={["#111111"]} />;
+  }));
+
+  describe('CompactPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (onSwatchHover should be a function)
+    <CompactPicker onSwatchHover={{}} />;
+    <CompactPicker onSwatchHover={() => {}} />;
+  }));
+
+  describe('GitHubPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (triangle should be 'hide' or 'top-left' or 'top-right')
+    <GitHubPicker triangle="bottom-right" />;
+    <GitHubPicker onSwatchHover="top-right" />;
+  }));
+
+  describe('HuePicker', () => it('described correctly', () => {
+    // $FlowExpectedError (direction should be 'horizontal' or 'vertical')
+    <HuePicker direction="sideways" />;
+    <HuePicker direction="horizontal" />;
+  }));
+
+  describe('PhotoshopPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (onAccept should be a function)
+    <PhotoshopPicker onAccept={{}} />;
+    <PhotoshopPicker onAccept={() => {}} />;
+  }));
+
+  describe('SketchPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (objects in presetColors should have a title)
+    <SketchPicker presetColors={[{ color: "#fff" }]} />;
+    <SketchPicker presetColors={[{ color: "#fff", title: "white" }]} />
+  }));
+
+  describe('SliderPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (pointer should be a valid component)
+    <SliderPicker pointer={{}} />;
+    <SliderPicker pointer={() => <h1>Pointer</h1>} />;
+  }));
+
+  describe('SwatchesPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (colors should be an Array of Array of strings)
+    <SwatchesPicker colors={["#fff", "#eee"]} />;
+    <SwatchesPicker colors={[["#fff, #eee"], ["#ddd", "#ccc"]]} />;
+  }));
+
+  describe('TwitterPicker', () => it('described correctly', () => {
+    // $FlowExpectedError (colors should be an Array of strings)
+    <TwitterPicker colors={[111, 222]} />;
+    <TwitterPicker colors={["#111", "#222"]} />;
+  }));
+
+  /**
+   * Test custom picker
+   */
+  describe('Custom Picker', () => it('described correctly', () => {
+    type MyPickerProps = InjectedColorProps & { ownProp: boolean, ... };
+    const MyPicker = ({ hex, hsl, hsv, onChange }: MyPickerProps) => {
+     const styles = {
+       hue: {
+         height: 10,
+         position: "relative",
+         marginBottom: 10
+       },
+       input: {
+         height: 34,
+         border: `1px solid ${hex}`,
+         paddingLeft: 10
+       },
+       swatch: {
+         width: 54,
+         height: 38,
+         background: hex
+       }
+     };
+     const c = hex.toUpperCase();
+     return (
+       <div>
+         <div style={styles.hue}>
+           {/* $FlowExpectedError (hsl should be a valid HSL Object) */}
+           <Hue hsl="#ffffff" onChange={onChange} />
+           {/* $FlowExpectedError wrong type of onChange callback */}
+           <Hue hsl={hsl} onChange={(str: string) => {}} />
+           <Hue hsl={hsl} onChange={onChange} />
+         </div>
+
+         <div style={{ display: "flex" }}>
+           <EditableInput
+             style={{ input: styles.input }}
+             value={hex}
+             onChange={onChange}
+           />
+           <div style={styles.swatch} />
+         </div>
+       </div>
+     );
+    };
+
+    const MyEnhancedPicker = CustomPicker(MyPicker);
+    <MyEnhancedPicker ownProp={true} />;
+    // $FlowExpectedError ownProp is required
+    <MyEnhancedPicker />;
+  }));
+
+});
diff --git a/definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.104.x-/react-custom-scrollbars_v4.2.x.js b/definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.104.x-v.200.x/react-custom-scrollbars_v4.2.x.js
similarity index 100%
rename from definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.104.x-/react-custom-scrollbars_v4.2.x.js
rename to definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.104.x-v.200.x/react-custom-scrollbars_v4.2.x.js
diff --git a/definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.201.x-/react-custom-scrollbars_v4.2.x.js b/definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.201.x-/react-custom-scrollbars_v4.2.x.js
new file mode 100644
index 0000000000..2765db0727
--- /dev/null
+++ b/definitions/npm/react-custom-scrollbars_v4.2.x/flow_v0.201.x-/react-custom-scrollbars_v4.2.x.js
@@ -0,0 +1,53 @@
+declare module "react-custom-scrollbars" {
+  declare type PositionValues = {
+    top: number,
+    left: number,
+    clientWidth: number,
+    clientHeight: number,
+    scrollWidth: number,
+    scrollHeight: number,
+    scrollLeft: number,
+    scrollTop: number,
+    ...
+  };
+
+  declare type Props = {
+    onScroll?: (event: SyntheticUIEvent<any>) => void,
+    onScrollFrame?: (values: PositionValues) => void,
+    onScrollStart?: () => void,
+    onScrollStop?: () => void,
+    onUpdate?: (values: PositionValues) => void,
+    renderView?: React$StatelessFunctionalComponent<any>,
+    renderTrackHorizontal?: React$StatelessFunctionalComponent<any>,
+    renderTrackVertical?: React$StatelessFunctionalComponent<any>,
+    renderThumbHorizontal?: React$StatelessFunctionalComponent<any>,
+    renderThumbVertical?: React$StatelessFunctionalComponent<any>,
+    hideTracksWhenNotNeeded?: boolean,
+    autoHide?: boolean,
+    autoHideTimeout?: number,
+    autoHideDuration?: number,
+    thumbSize?: number,
+    thumbMinSize?: number,
+    universal?: boolean,
+    autoHeight?: boolean,
+    autoHeightMin?: number | string,
+    autoHeightMax?: number | string,
+    ...
+  };
+
+  declare export default class Scrollbars extends React$Component<Props> {
+    scrollTop(top: number): void;
+    scrollLeft(left: number): void;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+    scrollToLeft(): void;
+    scrollToRight(): void;
+    getScrollLeft(): number;
+    getScrollTop(): number;
+    getScrollWidth(): number;
+    getScrollHeight(): number;
+    getClientWidth(): number;
+    getClientHeight(): number;
+    getValues(): PositionValues;
+  }
+}
diff --git a/definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-/react-datepicker_v1.4.x.js b/definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-v.200.x/react-datepicker_v1.4.x.js
similarity index 100%
rename from definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-/react-datepicker_v1.4.x.js
rename to definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-v.200.x/react-datepicker_v1.4.x.js
diff --git a/definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-/test_react-datepicker_v1.4.x.js b/definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-v.200.x/test_react-datepicker_v1.4.x.js
similarity index 100%
rename from definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-/test_react-datepicker_v1.4.x.js
rename to definitions/npm/react-datepicker_v1.4.x/flow_v0.104.x-v.200.x/test_react-datepicker_v1.4.x.js
diff --git a/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/react-datepicker_v1.4.x.js b/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/react-datepicker_v1.4.x.js
new file mode 100644
index 0000000000..b806ce4d04
--- /dev/null
+++ b/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/react-datepicker_v1.4.x.js
@@ -0,0 +1,88 @@
+// Based on https://github.com/Hacker0x01/react-datepicker/blob/master/docs/datepicker.md
+
+declare module 'react-datepicker' {
+  declare type moment$Moment = Object;
+  declare type Props = {|
+    allowSameDay?: boolean,
+    autoComplete?: string,
+    autoFocus?: boolean,
+    calendarClassName?: string,
+    children?: Node,
+    className?: string,
+    clearButtonTitle?: string,
+    customInput?: Node | React$Element<any>,
+    customInputRef?: string,
+    dateFormat?: string | Array<string>,
+    dateFormatCalendar?: string,
+    dayClassName?: () => ?string,
+    disabled?: boolean,
+    disabledKeyboardNavigation?: boolean,
+    dropdownMode?: 'scroll' | 'select',
+    endDate?: Date,
+    excludeDates?: Array<Date>,
+    excludeTimes?: Array<Date>,
+    filterDate?: () => boolean,
+    fixedHeight?: boolean,
+    forceShowMonthNavigation?: boolean,
+    formatWeekNumber?: () => string,
+    highlightDates?: Array<Date>,
+    id?: string,
+    includeDates?: Array<Date>,
+    includeTimes?: Array<Date>,
+    injectTimes?: Array<Date>,
+    inline?: boolean,
+    isClearable?: boolean,
+    locale?: string,
+    maxDate?: Date,
+    maxTime?: Date,
+    minDate?: Date,
+    minTime?: Date,
+    monthsShown?: number,
+    name?: string,
+    onBlur?: () => void,
+    onChange: moment$Moment => void,
+    onChangeRaw?: () => void,
+    onClickOutside?: Event => void,
+    onFocus?: (SyntheticEvent<>) => void,
+    onKeyDown?: () => void,
+    onMonthChange?: moment$Moment => void,
+    onYearChange?: moment$Moment => void,
+    onSelect?: moment$Moment => void,
+    onWeekSelect?: moment$Moment => void,
+    openToDate?: Date,
+    peekNextMonth?: boolean,
+    placeholderText?: string,
+    popperClassName?: string,
+    popperContainer?: () => Node,
+    popperModifiers?: {...},
+    popperPlacement?: 'auto' | 'top' | 'right' | 'bottom' | 'left',
+    readOnly?: boolean,
+    required?: boolean,
+    scrollableYearDropdown?: boolean,
+    selected?: Date,
+    selectsEnd?: boolean,
+    selectsStart?: boolean,
+    shouldCloseOnSelect?: boolean,
+    showMonthDropdown?: boolean,
+    showTimeSelect?: boolean,
+    showWeekNumbers?: boolean,
+    showYearDropdown?: boolean,
+    startDate?: Date,
+    startOpen?: boolean,
+    tabIndex?: number,
+    timeFormat?: string,
+    timeIntervals?: number,
+    title?: string,
+    todayButton?: Node,
+    useWeekdaysShort?: boolean,
+    utcOffset?: number | string,
+    value?: string,
+    weekLabel?: string,
+    withPortal?: boolean,
+    yearDropdownItemNumber?: number
+  |};
+
+  declare class Datepicker extends React$Component<Props> {}
+
+  declare module.exports: typeof Datepicker;
+}
diff --git a/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/test_react-datepicker_v1.4.x.js b/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/test_react-datepicker_v1.4.x.js
new file mode 100644
index 0000000000..b48fe13977
--- /dev/null
+++ b/definitions/npm/react-datepicker_v1.4.x/flow_v0.201.x-/test_react-datepicker_v1.4.x.js
@@ -0,0 +1,26 @@
+/* @flow */
+
+import * as React from 'react';
+import DatePicker from 'react-datepicker';
+
+const datepicker = (
+  <DatePicker
+    customInput={<img src="" />}
+    fixedHeight
+    popperPlacement="bottom"
+    popperModifiers={{
+      flip: {
+        enabled: false
+      }
+    }}
+    selected={new Date()}
+    onChange={() => console.log('change')}
+  />
+);
+
+const invalidDatepicker = (
+  <DatePicker
+    // $FlowExpectedError
+    onChange={{ foo: 'bar' }}
+  />
+);
diff --git a/definitions/npm/react-dnd_v2.x.x/flow_v0.201.x-/react-dnd_v2.x.x.js b/definitions/npm/react-dnd_v2.x.x/flow_v0.201.x-/react-dnd_v2.x.x.js
new file mode 100644
index 0000000000..556ceb07d2
--- /dev/null
+++ b/definitions/npm/react-dnd_v2.x.x/flow_v0.201.x-/react-dnd_v2.x.x.js
@@ -0,0 +1,214 @@
+declare module "react-dnd" {
+  declare type Identifier = string;
+
+  declare type ClientOffset = {
+    x: number,
+    y: number,
+    ...
+  };
+
+  declare type ElementOrNode = React$Element<any> | HTMLElement;
+
+  declare type DndOptions<P> = { arePropsEqual?: (props: P, otherProps: P) => boolean, ... };
+
+  declare type ComponentClassWithDefaultProps<D: {...}, P: {...}, S> = Class<
+    React$Component<P, S>
+  > & { defaultProps: D, ... };
+
+  declare type _InstanceOf<I, C: Class<I>> = I;
+  declare type InstanceOf<C> = _InstanceOf<any, C>;
+
+  declare class ConnectedComponent<C, I, P> extends React$Component<P> {
+    static DecoratedComponent: C;
+    getDecoratedComponentInstance(): I;
+    getHandlerId(): Identifier;
+    props: P;
+    state: void;
+  }
+
+  declare type Connector<SP: {...}, CP: {...}> = (<
+    P: SP,
+    D,
+    S,
+    C: ComponentClassWithDefaultProps<D, P, S>
+  >(
+    component: C
+  ) => Class<
+    ConnectedComponent<C, InstanceOf<C>, { ...CP, ... } & $Diff<$Diff<P, D>, CP>>
+  >) &
+    (<P: SP, S, C: Class<React$Component<P, S>>>(
+      component: C
+    ) => Class<
+      ConnectedComponent<C, InstanceOf<C>, { ...CP, ... } & $Diff<P, CP>>
+    >) &
+    (<P: SP, C: React$ComponentType<P>>(
+      component: C
+    ) => Class<ConnectedComponent<C, void, { ...CP, ... } & $Diff<P, CP>>>);
+
+  // Drag Source
+  // ----------------------------------------------------------------------
+
+  declare type DragSourceType<P> = Identifier | ((props: P) => Identifier);
+
+  declare type DragSourceSpec<P> = {
+    beginDrag: (
+      props: P,
+      monitor: DragSourceMonitor,
+      component: React$Component<P, any>
+    ) => Object,
+    endDrag?: (
+      props: P,
+      monitor: DragSourceMonitor,
+      component: ?React$Component<P, any>
+    ) => void,
+    canDrag?: (props: P, monitor: DragSourceMonitor) => boolean,
+    isDragging?: (props: P, monitor: DragSourceMonitor) => boolean,
+    ...
+  };
+
+  declare type DragSourceMonitor = {
+    canDrag: () => boolean,
+    isDragging: () => boolean,
+    getItemType: () => Identifier,
+    getItem: () => Object,
+    getDropResult: () => Object,
+    didDrop: () => boolean,
+    getInitialClientOffset: () => ClientOffset,
+    getInitialSourceClientOffset: () => ClientOffset,
+    getClientOffset: () => ClientOffset,
+    getDifferenceFromInitialOffset: () => ClientOffset,
+    getSourceClientOffset: () => ClientOffset,
+    ...
+  };
+
+  declare type DragSourceConnector = {
+    dragSource: () => ConnectDragSource,
+    dragPreview: () => ConnectDragPreview,
+    ...
+  };
+
+  declare type DragSourceOptions = { dropEffect?: string, ... };
+
+  declare type DragPreviewOptions = {
+    captureDraggingState?: boolean,
+    anchorX?: number,
+    anchorY?: number,
+    ...
+  };
+
+  declare type ConnectDragSource = <T: ElementOrNode>(
+    elementOrNode: T,
+    options?: DragSourceOptions
+  ) => ?T;
+
+  declare type ConnectDragPreview = <T: ElementOrNode>(
+    elementOrNode: T,
+    options?: DragPreviewOptions
+  ) => ?T;
+
+  declare type DragSourceCollector<T> = (
+    connect: DragSourceConnector,
+    monitor: DragSourceMonitor
+  ) => T;
+
+  declare function DragSource<OP: {...}, CP: {...}>(
+    type: DragSourceType<OP>,
+    spec: DragSourceSpec<OP>,
+    collect: DragSourceCollector<CP>,
+    options?: DndOptions<OP>
+  ): Connector<$Shape<OP & CP>, CP>;
+
+  // Drop Target
+  // ----------------------------------------------------------------------
+
+  declare type DropTargetTypes<P> =
+    | Identifier
+    | Array<Identifier>
+    | ((props: P) => Identifier | Array<Identifier>);
+
+  declare type DropTargetSpec<P> = {
+    drop?: (
+      props: P,
+      monitor: DropTargetMonitor,
+      component: React$Component<P, any>
+    ) => ?Object,
+    hover?: (
+      props: P,
+      monitor: DropTargetMonitor,
+      component: React$Component<P, any>
+    ) => void,
+    canDrop?: (props: P, monitor: DropTargetMonitor) => boolean,
+    ...
+  };
+
+  declare type DropTargetMonitor = {
+    canDrop: () => boolean,
+    isOver: (options?: { shallow: boolean, ... }) => boolean,
+    getItemType: () => Identifier,
+    getItem: () => Object,
+    getDropResult: () => Object,
+    didDrop: () => boolean,
+    getInitialClientOffset: () => ClientOffset,
+    getInitialSourceClientOffset: () => ClientOffset,
+    getClientOffset: () => ClientOffset,
+    getDifferenceFromInitialOffset: () => ClientOffset,
+    getSourceClientOffset: () => ClientOffset,
+    ...
+  };
+
+  declare type DropTargetConnector = { dropTarget: () => ConnectDropTarget, ... };
+
+  declare type ConnectDropTarget = <T: ElementOrNode>(elementOrNode: T) => ?T;
+
+  declare type DropTargetCollector<T> = (
+    connect: DropTargetConnector,
+    monitor: DropTargetMonitor
+  ) => T;
+
+  declare function DropTarget<OP: {...}, CP: {...}>(
+    types: DropTargetTypes<OP>,
+    spec: DropTargetSpec<OP>,
+    collect: DropTargetCollector<CP>,
+    options?: DndOptions<OP>
+  ): Connector<$Shape<OP & CP>, CP>;
+
+  // Drag Layer
+  // ----------------------------------------------------------------------
+
+  declare type DragLayerMonitor = {
+    isDragging: () => boolean,
+    getItemType: () => Identifier,
+    getItem: () => Object,
+    getInitialClientOffset: () => ClientOffset,
+    getInitialSourceClientOffset: () => ClientOffset,
+    getClientOffset: () => ClientOffset,
+    getDifferenceFromInitialOffset: () => ClientOffset,
+    getSourceClientOffset: () => ClientOffset,
+    ...
+  };
+
+  declare function DragLayer<OP: {...}, CP: {...}>(
+    collect: (monitor: DragLayerMonitor) => CP,
+    options?: DndOptions<OP>
+  ): Connector<$Shape<OP & CP>, CP>;
+
+  // Drag Drop Context
+  // ----------------------------------------------------------------------
+
+  declare type ProviderProps = {
+    backend: mixed,
+    children: React$Element<any>,
+    window?: Object,
+    ...
+  };
+
+  declare class DragDropContextProvider<ProviderProps> extends React$Component<
+    ProviderProps
+  > {
+    props: ProviderProps;
+  }
+
+  declare function DragDropContext<OP: {...}, CP: {...}>(
+    backend: mixed
+  ): Connector<$Shape<OP & CP>, CP>;
+}
diff --git a/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-/test_react-dnd-v2.js b/definitions/npm/react-dnd_v2.x.x/flow_v0.201.x-/test_react-dnd-v2.js
similarity index 100%
rename from definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-/test_react-dnd-v2.js
rename to definitions/npm/react-dnd_v2.x.x/flow_v0.201.x-/test_react-dnd-v2.js
diff --git a/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-/react-dnd_v2.x.x.js b/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-v.200.x/react-dnd_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-/react-dnd_v2.x.x.js
rename to definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-v.200.x/react-dnd_v2.x.x.js
diff --git a/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-v.200.x/test_react-dnd-v2.js b/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-v.200.x/test_react-dnd-v2.js
new file mode 100644
index 0000000000..31e0bdef38
--- /dev/null
+++ b/definitions/npm/react-dnd_v2.x.x/flow_v0.98.x-v.200.x/test_react-dnd-v2.js
@@ -0,0 +1,474 @@
+/* @flow */
+
+import * as React from "react";
+import ReactDOM from "react-dom";
+import { DragSource, DropTarget, DragLayer, DragDropContext } from "react-dnd";
+
+// Test Drag Source Component with default props
+// ----------------------------------------------------------------------
+
+type KnightDefaultProps = { color: string, ... };
+
+type KnightOrigProps = KnightDefaultProps & {
+  title: string,
+  count?: number,
+  ...
+};
+
+type KnightCollectProps = {
+  connectDragSource: (e: React.Element<any>) => null | React.Node,
+  connectDragPreview: (e: Image) => ?Image,
+  isDragging: boolean,
+  ...
+};
+
+type KnightProps = KnightOrigProps & KnightCollectProps;
+
+type KnightState = { num: number, ... };
+
+const knightSource = {
+  beginDrag() {
+    return {};
+  }
+};
+
+function knightCollect(connect, monitor) {
+  return {
+    connectDragSource: connect.dragSource(),
+    connectDragPreview: connect.dragPreview(),
+    isDragging: monitor.isDragging()
+  };
+}
+
+class Knight extends React.Component<KnightProps, KnightState> {
+  state: KnightState = {
+    num: 3
+  };
+
+  static defaultProps: KnightDefaultProps = {
+    color: "blue"
+  };
+
+  componentDidMount() {
+    const img = new Image();
+    img.onload = () => {
+      this.props.connectDragPreview(img);
+    };
+  }
+
+  foo(): string {
+    return "foo";
+  }
+
+  render() {
+    const { color, title, connectDragSource, isDragging } = this.props;
+    return connectDragSource(
+      <div
+        title={title}
+        style={{
+          color,
+          fontSize: 40,
+          fontWeight: "bold",
+          cursor: "move",
+          opacity: isDragging ? 0.5 : 1
+        }}
+      >
+        ♘
+      </div>
+    );
+  }
+}
+
+const DndKnight = DragSource("knight", knightSource, knightCollect)(Knight);
+
+(DndKnight.DecoratedComponent: typeof Knight);
+
+const dndKnight: DndKnight = (null: any);
+
+(dndKnight.getHandlerId(): string);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight.getHandlerId(): number);
+
+(dndKnight.getDecoratedComponentInstance(): Knight);
+
+(dndKnight.getDecoratedComponentInstance().foo(): string);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight.getDecoratedComponentInstance().foo(): number);
+
+(dndKnight.getDecoratedComponentInstance().state.num: number);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight.getDecoratedComponentInstance().state.num: string);
+
+// $FlowExpectedError: Missing required prop
+(<DndKnight />: React.Element<typeof DndKnight>);
+
+(<DndKnight title="foo" />: React.Element<typeof DndKnight>);
+
+(<DndKnight title="foo" color="red" />: React.Element<typeof DndKnight>);
+
+(<DndKnight title="foo" color={3} />: React.Element<typeof DndKnight>);
+
+(<DndKnight title="foo" color="red" extra="x" />: React.Element<
+  typeof DndKnight
+>);
+
+(<DndKnight title="foo" color="red" count={3} />: React.Element<
+  typeof DndKnight
+>);
+
+// $FlowExpectedError: Invalid optional prop
+(<DndKnight title="foo" color="red" count="x" />: React.Element<
+  typeof DndKnight
+>);
+
+(<DndKnight title="foo" color="red" isDragging={false} />: React.Element<
+  typeof DndKnight
+>);
+
+(<DndKnight title="foo" color="red" isDragging="false" />: React.Element<
+  typeof DndKnight
+>);
+
+// Test Drag Source Component without default props
+// ----------------------------------------------------------------------
+
+class Knight2 extends React.Component<KnightProps, KnightState> {
+  state: KnightState = {
+    num: 3
+  };
+
+  componentDidMount() {
+    const img = new Image();
+    img.onload = () => {
+      this.props.connectDragPreview(img);
+    };
+  }
+
+  foo(): string {
+    return "foo";
+  }
+
+  render() {
+    const { color, title, connectDragSource, isDragging } = this.props;
+    return connectDragSource(
+      <div
+        title={title}
+        style={{
+          color,
+          fontSize: 40,
+          fontWeight: "bold",
+          cursor: "move",
+          opacity: isDragging ? 0.5 : 1
+        }}
+      >
+        ♘
+      </div>
+    );
+  }
+}
+
+const DndKnight2 = DragSource("knight", knightSource, knightCollect)(Knight2);
+
+(DndKnight2.DecoratedComponent: typeof Knight2);
+
+const dndKnight2: DndKnight2 = (null: any);
+
+(dndKnight2.getHandlerId(): string);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight2.getHandlerId(): number);
+
+(dndKnight2.getDecoratedComponentInstance(): Knight2);
+
+(dndKnight2.getDecoratedComponentInstance().foo(): string);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight2.getDecoratedComponentInstance().foo(): number);
+
+(dndKnight2.getDecoratedComponentInstance().state.num: number);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight2.getDecoratedComponentInstance().state.num: string);
+
+// $FlowExpectedError: Missing required prop
+(<DndKnight2 />: React.Element<typeof DndKnight2>);
+
+// $FlowExpectedError: Missing (non-)default prop
+(<DndKnight2 title="foo" />: React.Element<typeof DndKnight2>);
+
+(<DndKnight2 title="foo" color="red" />: React.Element<typeof DndKnight2>);
+
+// $FlowExpectedError: Invalid (non-)default prop
+(<DndKnight2 title="foo" color={3} />: React.Element<typeof DndKnight2>);
+
+(<DndKnight2 title="foo" color="red" extra="x" />: React.Element<
+  typeof DndKnight2
+>);
+
+(<DndKnight2 title="foo" color="red" count={3} />: React.Element<
+  typeof DndKnight2
+>);
+
+// $FlowExpectedError: Invalid optional prop
+(<DndKnight2 title="foo" color="red" count="x" />: React.Element<
+  typeof DndKnight2
+>);
+
+(<DndKnight2 title="foo" color="red" isDragging={false} />: React.Element<
+  typeof DndKnight2
+>);
+
+(<DndKnight2 title="foo" color="red" isDragging="false" />: React.Element<
+  typeof DndKnight2
+>);
+
+// Test Drag Source Functional Component
+// ----------------------------------------------------------------------
+
+const Knight3 = ({ color, title, isDragging }: KnightProps) => (
+  <div
+    title={title}
+    style={{
+      color,
+      fontSize: 40,
+      fontWeight: "bold",
+      cursor: "move",
+      opacity: isDragging ? 0.5 : 1
+    }}
+  >
+    ♘
+  </div>
+);
+
+const DndKnight3 = DragSource("knight", knightSource, knightCollect)(Knight3);
+
+(DndKnight3.DecoratedComponent: typeof Knight3);
+
+const dndKnight3: DndKnight3 = (null: any);
+
+(dndKnight3.getHandlerId(): string);
+
+// $FlowExpectedError: Type mismatch
+(dndKnight3.getHandlerId(): number);
+
+(dndKnight3.getDecoratedComponentInstance(): void);
+
+// FIXME: Should error, missing required prop
+(<DndKnight3 />: React.Element<typeof DndKnight3>);
+
+// FIXME: Should error, missing (non-)default prop
+(<DndKnight3 title="foo" />: React.Element<typeof DndKnight3>);
+
+(<DndKnight3 title="foo" color="red" />: React.Element<typeof DndKnight3>);
+
+// FIXME: Should error, invalid (non-)default prop
+(<DndKnight3 title="foo" color={3} />: React.Element<typeof DndKnight3>);
+
+(<DndKnight3 title="foo" color="red" extra="x" />: React.Element<
+  typeof DndKnight3
+>);
+
+(<DndKnight3 title="foo" color="red" count={3} />: React.Element<
+  typeof DndKnight3
+>);
+
+// FIXME: Should error, invalid optional prop
+(<DndKnight3 title="foo" color="red" count="x" />: React.Element<
+  typeof DndKnight3
+>);
+
+(<DndKnight3 title="foo" color="red" isDragging={false} />: React.Element<
+  typeof DndKnight3
+>);
+
+(<DndKnight3 title="foo" color="red" isDragging="false" />: React.Element<
+  typeof DndKnight3
+>);
+
+// Test Drop Target
+// ----------------------------------------------------------------------
+
+function moveKnight(toX: number, toY: number) {}
+
+function canMoveKnight(toX: number, toY: number) {
+  return true;
+}
+
+type SquareProps = { black: boolean, ... };
+
+class Square extends React.Component<SquareProps> {
+  static defaultProps: SquareProps = {
+    black: true
+  };
+
+  render() {
+    const { black } = this.props;
+    const fill = black ? "black" : "white";
+
+    return <div style={{ backgroundColor: fill }} />;
+  }
+}
+
+type BoardSquareDefaultProps = { x: number, ... };
+
+type BoardSquareProps = BoardSquareDefaultProps & {
+  y: number,
+  count?: number,
+  connectDropTarget: (e: React.Element<any>) => null | React.Node,
+  isOver: boolean,
+  canDrop: boolean,
+  ...
+};
+
+const boardSquareTarget = {
+  canDrop(props) {
+    return canMoveKnight(props.x, props.y);
+  },
+
+  drop(props) {
+    moveKnight(props.x, props.y);
+  }
+};
+
+function boardSquareCollect(connect, monitor) {
+  return {
+    connectDropTarget: connect.dropTarget(),
+    isOver: monitor.isOver(),
+    canDrop: monitor.canDrop()
+  };
+}
+
+class BoardSquare extends React.Component<BoardSquareProps> {
+  static defaultProps: BoardSquareDefaultProps = {
+    x: 0
+  };
+
+  renderOverlay(color: string) {
+    return (
+      <div
+        style={{
+          position: "absolute",
+          top: 0,
+          left: 0,
+          height: "100%",
+          width: "100%",
+          zIndex: 1,
+          opacity: 0.5,
+          backgroundColor: color
+        }}
+      />
+    );
+  }
+
+  render() {
+    const { x, y, connectDropTarget, isOver, canDrop } = this.props;
+    const black = (x + y) % 2 === 1;
+
+    return connectDropTarget(
+      <div
+        style={{
+          position: "relative",
+          width: "100%",
+          height: "100%"
+        }}
+      >
+        <Square black={black} />
+        {isOver && !canDrop && this.renderOverlay("red")}
+        {!isOver && canDrop && this.renderOverlay("yellow")}
+        {isOver && canDrop && this.renderOverlay("green")}
+      </div>
+    );
+  }
+}
+
+const DndBoardSquare = DropTarget(
+  "boardsquare",
+  boardSquareTarget,
+  boardSquareCollect
+)(BoardSquare);
+
+(DndBoardSquare.DecoratedComponent: typeof BoardSquare);
+
+// $FlowExpectedError: Missing required prop
+(<DndBoardSquare />: React.Element<typeof DndBoardSquare>);
+
+(<DndBoardSquare y={5} />: React.Element<typeof DndBoardSquare>);
+
+// $FlowExpectedError: Invalid required prop
+(<DndBoardSquare y="5" />: React.Element<typeof DndBoardSquare>);
+
+(<DndBoardSquare y={5} x={5} />: React.Element<typeof DndBoardSquare>);
+
+(<DndBoardSquare y={5} x="5" />: React.Element<typeof DndBoardSquare>);
+
+(<DndBoardSquare y={5} count={5} />: React.Element<typeof DndBoardSquare>);
+
+// $FlowExpectedError: Invalid optional prop
+(<DndBoardSquare y={5} count="5" />: React.Element<typeof DndBoardSquare>);
+
+// Test Custom Drag Layer
+// ----------------------------------------------------------------------
+
+type CustomDragLayerProps = {
+  isDragging: boolean,
+  title: string,
+  ...
+};
+
+function dragLayerCollect(monitor) {
+  return {
+    isDragging: monitor.isDragging(),
+    item: monitor.getItem()
+  };
+}
+
+class CustomDragLayer extends React.Component<CustomDragLayerProps> {
+  static defaultProps: CustomDragLayerProps = {
+    isDragging: false,
+    title: ""
+  };
+
+  render() {
+    const { title, isDragging } = this.props;
+    if (!isDragging) {
+      return null;
+    }
+
+    return <div>{title}</div>;
+  }
+}
+
+const DndCustomDragLayer = DragLayer(dragLayerCollect)(CustomDragLayer);
+
+(DndCustomDragLayer.DecoratedComponent: typeof CustomDragLayer);
+
+// Test Drag Drop Context
+// ----------------------------------------------------------------------
+
+type BoardProps = {
+  width: number,
+  height: number,
+  ...
+};
+
+class Board extends React.Component<BoardProps> {
+  static defaultProps: BoardProps = {
+    width: 400,
+    height: 400
+  };
+
+  render() {
+    const styles = {
+      width: this.props.width,
+      height: this.props.height
+    };
+    return <div style={styles} />;
+  }
+}
+
+const DndBoard = DragDropContext({})(Board);
+
+(DndBoard.DecoratedComponent: typeof Board);
diff --git a/definitions/npm/react-flip-move_v2.9.x/flow_v0.104.x-/react-flip-move_v2.9.x.js b/definitions/npm/react-flip-move_v2.9.x/flow_v0.104.x-v.200.x/react-flip-move_v2.9.x.js
similarity index 100%
rename from definitions/npm/react-flip-move_v2.9.x/flow_v0.104.x-/react-flip-move_v2.9.x.js
rename to definitions/npm/react-flip-move_v2.9.x/flow_v0.104.x-v.200.x/react-flip-move_v2.9.x.js
diff --git a/definitions/npm/react-flip-move_v2.9.x/flow_v0.201.x-/react-flip-move_v2.9.x.js b/definitions/npm/react-flip-move_v2.9.x/flow_v0.201.x-/react-flip-move_v2.9.x.js
new file mode 100644
index 0000000000..df9160a1ff
--- /dev/null
+++ b/definitions/npm/react-flip-move_v2.9.x/flow_v0.201.x-/react-flip-move_v2.9.x.js
@@ -0,0 +1,107 @@
+declare module "react-flip-move" {
+  declare export type Styles = { [key: string]: string, ... };
+
+  declare type ReactStyles = { [key: string]: string | number, ... };
+
+  declare export type Animation = {
+    from: Styles,
+    to: Styles,
+    ...
+  };
+
+  declare export type Presets = {
+    elevator: Animation,
+    fade: Animation,
+    accordionVertical: Animation,
+    accordionHorizontal: Animation,
+    none: null,
+    ...
+  };
+
+  declare export type AnimationProp = $Keys<Presets> | boolean | Animation;
+
+  declare export type ClientRect = {
+    top: number,
+    right: number,
+    bottom: number,
+    left: number,
+    height: number,
+    width: number,
+    ...
+  };
+
+  // can't use $Shape<React$Element<*>> here, because we use it in intersection
+  declare export type ElementShape = {
+    +type: $PropertyType<React$Element<any>, "type">,
+    +props: $PropertyType<React$Element<any>, "props">,
+    +key: $PropertyType<React$Element<any>, "key">,
+    +ref: $PropertyType<React$Element<any>, "ref">,
+    ...
+  };
+
+  declare type ChildHook = (element: ElementShape, node: ?HTMLElement) => mixed;
+
+  declare export type ChildrenHook = (
+    elements: Array<ElementShape>,
+    nodes: Array<?HTMLElement>
+  ) => mixed;
+
+  declare export type GetPosition = (node: HTMLElement) => ClientRect;
+
+  declare export type VerticalAlignment = "top" | "bottom";
+
+  declare export type Child = void | null | boolean | React$Element<any>;
+
+  // can't import from React, see https://github.com/facebook/flow/issues/4787
+  declare type ChildrenArray<T> = $ReadOnlyArray<ChildrenArray<T>> | T;
+
+  declare type BaseProps = {
+    easing: string,
+    typeName: string,
+    disableAllAnimations: boolean,
+    getPosition: GetPosition,
+    maintainContainerHeight: boolean,
+    verticalAlignment: VerticalAlignment,
+    ...
+  };
+
+  declare type PolymorphicProps = {
+    duration: string | number,
+    delay: string | number,
+    staggerDurationBy: string | number,
+    staggerDelayBy: string | number,
+    enterAnimation: AnimationProp,
+    leaveAnimation: AnimationProp,
+    ...
+  };
+
+  declare type Hooks = {
+    onStart?: ChildHook,
+    onFinish?: ChildHook,
+    onStartAll?: ChildrenHook,
+    onFinishAll?: ChildrenHook,
+    ...
+  };
+
+  declare export type DelegatedProps = { style?: ReactStyles, ... };
+
+  declare export type FlipMoveDefaultProps = BaseProps & PolymorphicProps;
+
+  declare export type CommonProps = BaseProps &
+    Hooks & { children?: ChildrenArray<Child>, ... };
+
+  declare export type FlipMoveProps = FlipMoveDefaultProps &
+    CommonProps &
+    DelegatedProps & {
+    appearAnimation?: AnimationProp,
+    // deprecated, use disableAllAnimations instead
+    disableAnimations?: boolean,
+    ...
+  };
+
+  declare class FlipMove extends React$Component<FlipMoveProps> {
+    static defaultProps: FlipMoveDefaultProps
+  }
+
+  declare export default typeof FlipMove
+}
diff --git a/definitions/npm/react-helmet_v3.x.x/flow_v0.104.x-/react-helmet_v3.x.x.js b/definitions/npm/react-helmet_v3.x.x/flow_v0.104.x-v.200.x/react-helmet_v3.x.x.js
similarity index 100%
rename from definitions/npm/react-helmet_v3.x.x/flow_v0.104.x-/react-helmet_v3.x.x.js
rename to definitions/npm/react-helmet_v3.x.x/flow_v0.104.x-v.200.x/react-helmet_v3.x.x.js
diff --git a/definitions/npm/react-helmet_v3.x.x/flow_v0.201.x-/react-helmet_v3.x.x.js b/definitions/npm/react-helmet_v3.x.x/flow_v0.201.x-/react-helmet_v3.x.x.js
new file mode 100644
index 0000000000..fdcf21d0b6
--- /dev/null
+++ b/definitions/npm/react-helmet_v3.x.x/flow_v0.201.x-/react-helmet_v3.x.x.js
@@ -0,0 +1,38 @@
+declare module "react-helmet" {
+  declare type Props = {
+    htmlAttributes?: Object,
+    title?: string,
+    defaultTitle?: string,
+    titleTemplate?: string,
+    base?: Object,
+    meta?: Array<Object>,
+    link?: Array<Object>,
+    script?: Array<Object>,
+    noscript?: Array<Object>,
+    style?: Array<Object>,
+    onChangeClientState?: (
+      newState: Object,
+      addedTags: Object,
+      removeTags: Object
+    ) => void | mixed,
+    ...
+  };
+  declare interface HeadAttribute {
+    toString(): string;
+    toComponent(): React$Element<any>;
+  }
+  declare interface Head {
+    htmlAttributes: HeadAttribute;
+    title: HeadAttribute;
+    base: HeadAttribute;
+    meta: HeadAttribute;
+    link: HeadAttribute;
+    script: HeadAttribute;
+    style: HeadAttribute;
+  }
+
+  declare class Helmet extends React$Component<Props> {
+    static rewind(): Head;
+  }
+  declare module.exports: typeof Helmet;
+}
diff --git a/definitions/npm/react-helmet_v5.x.x/flow_v0.104.x-/react-helmet_v5.x.x.js b/definitions/npm/react-helmet_v5.x.x/flow_v0.104.x-v.200.x/react-helmet_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-helmet_v5.x.x/flow_v0.104.x-/react-helmet_v5.x.x.js
rename to definitions/npm/react-helmet_v5.x.x/flow_v0.104.x-v.200.x/react-helmet_v5.x.x.js
diff --git a/definitions/npm/react-helmet_v5.x.x/flow_v0.201.x-/react-helmet_v5.x.x.js b/definitions/npm/react-helmet_v5.x.x/flow_v0.201.x-/react-helmet_v5.x.x.js
new file mode 100644
index 0000000000..00f31ea8f8
--- /dev/null
+++ b/definitions/npm/react-helmet_v5.x.x/flow_v0.201.x-/react-helmet_v5.x.x.js
@@ -0,0 +1,57 @@
+declare module 'react-helmet' {
+  declare type Props = {
+    base?: Object,
+    bodyAttributes?: Object,
+    children?: React$Node,
+    defaultTitle?: string,
+    defer?: boolean,
+    encodeSpecialCharacters?: boolean,
+    htmlAttributes?: Object,
+    link?: Array<Object>,
+    meta?: Array<Object>,
+    noscript?: Array<Object>,
+    onChangeClientState?: (
+      newState?: Object,
+      addedTags?: Object,
+      removeTags?: Object
+    ) => any,
+    script?: Array<Object>,
+    style?: Array<Object>,
+    title?: string,
+    titleAttributes?: Object,
+    titleTemplate?: string,
+    ...
+  }
+
+  declare interface TagMethods {
+    toString(): string;
+    toComponent(): [React$Element<any>] | React$Element<any> | Array<Object>;
+  }
+
+  declare interface AttributeTagMethods {
+    toString(): string;
+    toComponent(): { [string]: any, ... };
+  }
+
+  declare interface StateOnServer {
+    base: TagMethods;
+    bodyAttributes: AttributeTagMethods,
+    htmlAttributes: AttributeTagMethods;
+    link: TagMethods;
+    meta: TagMethods;
+    noscript: TagMethods;
+    script: TagMethods;
+    style: TagMethods;
+    title: TagMethods;
+  }
+
+  declare class Helmet extends React$Component<Props> {
+    static rewind(): StateOnServer;
+    static renderStatic(): StateOnServer;
+    static canUseDom(canUseDOM: boolean): void;
+  }
+
+  declare export default typeof Helmet
+  declare export var Helmet: typeof Helmet
+}
+
diff --git a/definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-/react-i18next_v6.x.x.js b/definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-v.200.x/react-i18next_v6.x.x.js
similarity index 100%
rename from definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-/react-i18next_v6.x.x.js
rename to definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-v.200.x/react-i18next_v6.x.x.js
diff --git a/definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-/test_react-i18next_v6.x.x.js b/definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-v.200.x/test_react-i18next_v6.x.x.js
similarity index 100%
rename from definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-/test_react-i18next_v6.x.x.js
rename to definitions/npm/react-i18next_v6.x.x/flow_v0.104.x-v.200.x/test_react-i18next_v6.x.x.js
diff --git a/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/react-i18next_v6.x.x.js b/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/react-i18next_v6.x.x.js
new file mode 100644
index 0000000000..a9ceb754a7
--- /dev/null
+++ b/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/react-i18next_v6.x.x.js
@@ -0,0 +1,107 @@
+declare module "react-i18next" {
+  declare type TFunction = (key?: ?string, data?: ?Object) => string;
+  declare type Locales = string | Array<string>;
+
+  declare type TranslatorProps = {
+    t: TFunction,
+    i18nLoadedAt: Date,
+    i18n: Object,
+    ...
+  };
+
+  declare type Translator<OP, P> = (
+    component: React$ComponentType<P>
+  ) => Class<React$Component<OP, any>>;
+
+  declare type TranslateOptions = $Shape<{
+    wait: boolean,
+    nsMode: "default" | "fallback",
+    bindi18n: false | string,
+    bindStore: false | string,
+    withRef: boolean,
+    translateFuncName: string,
+    i18n: Object,
+    ...
+  }>;
+
+  declare function translate<OP, P>(
+    locales?: Locales,
+    options?: TranslateOptions
+  ): Translator<OP, P>;
+
+  declare type I18nProps = {
+    i18n?: Object,
+    ns?: string | Array<string>,
+    children: (t: TFunction, {
+      i18n: Object,
+      t: TFunction,
+      ...
+    }) => React$Node,
+    initialI18nStore?: Object,
+    initialLanguage?: string,
+    ...
+  };
+  declare var I18n: React$ComponentType<I18nProps>;
+
+  declare type InterpolateProps = {
+    className?: string,
+    dangerouslySetInnerHTMLPartElement?: string,
+    i18n?: Object,
+    i18nKey?: string,
+    options?: Object,
+    parent?: string,
+    style?: Object,
+    t?: TFunction,
+    useDangerouslySetInnerHTML?: boolean,
+    ...
+  };
+  declare var Interpolate: React$ComponentType<InterpolateProps>;
+
+  declare type TransProps = {
+    count?: number,
+    parent?: string,
+    i18n?: Object,
+    i18nKey?: string,
+    t?: TFunction,
+    ...
+  };
+  declare var Trans: React$ComponentType<TransProps>;
+
+  declare type ProviderProps = {
+    i18n: Object,
+    children: React$Element<any>,
+    ...
+  };
+  declare var I18nextProvider: React$ComponentType<ProviderProps>;
+
+  declare type NamespacesProps = {
+    components: Array<React$ComponentType<any>>,
+    i18n: { loadNamespaces: Function, ... },
+    ...
+  };
+  declare function loadNamespaces(props: NamespacesProps): Promise<void>;
+
+  declare var reactI18nextModule: {
+    type: "3rdParty",
+    init: (instance: Object) => void,
+    ...
+  };
+
+  declare var defaultOptions: {
+    wait: false,
+    withRef: false,
+    bindI18n: "languageChanged loaded",
+    bindStore: "added removed",
+    translateFuncName: "t",
+    nsMode: "default",
+    ...
+  };
+
+  declare function setDefaults(options: TranslateOptions): void;
+
+  declare function getDefaults(): TranslateOptions;
+
+  declare function getI18n(): Object;
+
+  declare function setI18n(instance: Object): void;
+}
diff --git a/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/test_react-i18next_v6.x.x.js b/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/test_react-i18next_v6.x.x.js
new file mode 100644
index 0000000000..c506d9b939
--- /dev/null
+++ b/definitions/npm/react-i18next_v6.x.x/flow_v0.201.x-/test_react-i18next_v6.x.x.js
@@ -0,0 +1,171 @@
+// @flow
+
+import * as React from "react";
+import {
+  loadNamespaces,
+  translate,
+  I18nextProvider,
+  I18n,
+  Interpolate,
+  Trans,
+  setDefaults,
+  reactI18nextModule,
+  defaultOptions,
+  getDefaults,
+  getI18n,
+  setI18n
+} from "react-i18next";
+import type { TFunction, Translator } from "react-i18next";
+
+const i18n = { loadNamespaces: () => {} };
+
+<I18nextProvider i18n={i18n} children={<div />} />;
+
+// $FlowExpectedError - missing children prop
+<I18nextProvider i18n={i18n} />;
+// $FlowExpectedError - missing i18n prop
+<I18nextProvider children={<div />} />;
+
+// passing
+loadNamespaces({ components: [], i18n });
+loadNamespaces({ components: [() => <div />], i18n });
+
+// $FlowExpectedError - too few arguments
+loadNamespaces();
+// $FlowExpectedError - wrong type
+loadNamespaces("");
+// $FlowExpectedError - wrong component type
+loadNamespaces({ components: [{}], i18n });
+
+type OwnProps = { s: string, ... };
+type Props = OwnProps & { t: TFunction, ... };
+
+const Comp = ({ s, t }: Props) => <div prop1={t("")} prop2={" " + s} />;
+
+class ClassComp extends React.Component<Props> {
+  render() {
+    const { s, t } = this.props;
+    return <div prop={t("")} />;
+  }
+}
+
+// $FlowExpectedError - wrong argument type
+const FlowErrorComp = ({ s, t }: Props) => t("", "")
+
+class FlowErrorClassComp extends React.Component<Props> {
+  render() {
+    const { s, t } = this.props;
+    // $FlowExpectedError - wrong argument type
+    return <div prop={t({})} />; // misuse of t()
+  }
+}
+
+// passing
+translate();
+// $FlowExpectedError - wrong argument type
+translate({});
+
+const translator: Translator<OwnProps, Props> = translate("");
+const WrappedStatelessComp = translator(Comp);
+
+// passing
+<WrappedStatelessComp s="" />;
+
+// $FlowExpectedError - missing prop "s"
+<WrappedStatelessComp />;
+// $FlowExpectedError - wrong type
+<WrappedStatelessComp s={1} />;
+
+const WrappedClassComp = translator(ClassComp);
+
+// passing
+<WrappedClassComp s="" />;
+
+// $FlowExpectedError - missing prop "s"
+<WrappedClassComp />;
+// $FlowExpectedError - wrong type
+<WrappedClassComp s={1} />;
+
+// passing
+<I18n>
+  {(t: TFunction) =>
+    <span>
+      {t("title")}
+    </span>}
+</I18n>;
+<I18n ns="translations">
+  {(t: TFunction, { i18n }: { i18n: Object, ... }) =>
+    <div>
+      <span>
+        {t("title")}
+      </span>
+      <button onClick={() => i18n.changeLanguage("de")}>de</button>
+      <button onClick={() => i18n.changeLanguage("en")}>en</button>
+    </div>}
+</I18n>;
+// $FlowExpectedError - no children passed to I18n component
+<I18n ns="translations" />;
+
+// passing
+<Interpolate />;
+<Interpolate i18nKey="translation.key" keyValue={5} />;
+<Interpolate
+  className="string"
+  dangerouslySetInnerHTMLPartElement="span"
+  i18n={i18n}
+  i18nKey="translation.key"
+  options={{}}
+  parent="div"
+  style={{}}
+  t={key => ""}
+  useDangerouslySetInnerHTML={true}
+/>;
+
+// $FlowExpectedError - i18nKey prop wrong type
+<Interpolate i18nKey={1} />;
+
+// passing
+<Trans i18nKey="translation.key" />;
+<Trans i18nKey="translation.key" count={5} />;
+<Trans i18nKey="translation.key" count={5} parent="div" i18n={i18n} />;
+
+// $FlowExpectedError - i18nKey prop wrong type
+<Trans i18nKey={5} />;
+
+// passing
+reactI18nextModule.init(i18n);
+reactI18nextModule.type;
+// $FlowExpectedError - no field property on reactI18nextModule
+reactI18nextModule.field;
+
+// passing
+defaultOptions.wait;
+defaultOptions.withRef;
+defaultOptions.bindI18n;
+defaultOptions.bindStore;
+defaultOptions.translateFuncName;
+defaultOptions.nsMode;
+// $FlowExpectedError - no field property on defaultOptions
+defaultOptions.field;
+
+// passing
+setDefaults({ wait: true });
+// $FlowExpectedError - setDefaults must be called with an object
+setDefaults("option");
+// $FlowExpectedError - other is not a valid option
+setDefaults({ other: true });
+
+// passing
+getDefaults();
+// $FlowExpectedError - no arguments should be passed to getDefaults
+getDefaults("string");
+
+// passing
+getI18n();
+// $FlowExpectedError - no arguments should be passed to getI18n
+getI18n("string");
+
+// passing
+setI18n(i18n);
+// $FlowExpectedError - setI18n must be called with an object
+setI18n("option");
diff --git a/definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-/react-i18next_v7.x.x.js b/definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-v.200.x/react-i18next_v7.x.x.js
similarity index 100%
rename from definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-/react-i18next_v7.x.x.js
rename to definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-v.200.x/react-i18next_v7.x.x.js
diff --git a/definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-/test_react-i18next_v7.x.x.js b/definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-v.200.x/test_react-i18next_v7.x.x.js
similarity index 100%
rename from definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-/test_react-i18next_v7.x.x.js
rename to definitions/npm/react-i18next_v7.x.x/flow_v0.104.x-v.200.x/test_react-i18next_v7.x.x.js
diff --git a/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/react-i18next_v7.x.x.js b/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/react-i18next_v7.x.x.js
new file mode 100644
index 0000000000..024ebba6c8
--- /dev/null
+++ b/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/react-i18next_v7.x.x.js
@@ -0,0 +1,107 @@
+declare module "react-i18next" {
+  declare type TFunction = (key?: ?string, data?: ?Object) => string;
+
+  declare type TranslatorProps = {|
+    t: TFunction,
+    i18nLoadedAt: Date,
+    i18n: Object
+  |};
+
+  declare type TranslatorPropsVoid = {
+    t: TFunction | void,
+    i18nLoadedAt: Date | void,
+    i18n: Object | void,
+    ...
+  };
+
+  declare type Translator<P: {...}, Component: React$ComponentType<P>> = (
+    WrappedComponent: Component
+  ) => React$ComponentType<
+    $Diff<React$ElementConfig<Component>, TranslatorPropsVoid>
+  >;
+
+  declare type TranslateOptions = $Shape<{
+    wait: boolean,
+    nsMode: "default" | "fallback",
+    bindi18n: false | string,
+    bindStore: false | string,
+    withRef: boolean,
+    translateFuncName: string,
+    i18n: Object,
+    usePureComponent: boolean,
+    ...
+  }>;
+
+  declare function translate<P: {...}, Component: React$ComponentType<P>>(
+    namespaces?: | string
+    | Array<string>
+    | (($Diff<P, TranslatorPropsVoid>) => string | Array<string>),
+    options?: TranslateOptions
+  ): Translator<P, Component>;
+
+  declare type I18nProps = {
+    i18n?: Object,
+    ns?: string | Array<string>,
+    children: (t: TFunction, {
+      i18n: Object,
+      t: TFunction,
+      ...
+    }) => React$Node,
+    initialI18nStore?: Object,
+    initialLanguage?: string,
+    ...
+  };
+  declare var I18n: React$ComponentType<I18nProps>;
+
+  declare type InterpolateProps = {
+    className?: string,
+    dangerouslySetInnerHTMLPartElement?: string,
+    i18n?: Object,
+    i18nKey?: string,
+    options?: Object,
+    parent?: string,
+    style?: Object,
+    t?: TFunction,
+    useDangerouslySetInnerHTML?: boolean,
+    ...
+  };
+  declare var Interpolate: React$ComponentType<InterpolateProps>;
+
+  declare type TransProps = {
+    count?: number,
+    parent?: string,
+    i18n?: Object,
+    i18nKey?: string,
+    t?: TFunction,
+    ...
+  };
+  declare var Trans: React$ComponentType<TransProps>;
+
+  declare type ProviderProps = {
+    i18n: Object,
+    children: React$Element<any>,
+    ...
+  };
+  declare var I18nextProvider: React$ComponentType<ProviderProps>;
+
+  declare type NamespacesProps = {
+    components: Array<React$ComponentType<any>>,
+    i18n: { loadNamespaces: Function, ... },
+    ...
+  };
+  declare function loadNamespaces(props: NamespacesProps): Promise<void>;
+
+  declare var reactI18nextModule: {
+    type: "3rdParty",
+    init: (instance: Object) => void,
+    ...
+  };
+
+  declare function setDefaults(options: TranslateOptions): void;
+
+  declare function getDefaults(): TranslateOptions;
+
+  declare function getI18n(): Object;
+
+  declare function setI18n(instance: Object): void;
+}
diff --git a/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/test_react-i18next_v7.x.x.js b/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/test_react-i18next_v7.x.x.js
new file mode 100644
index 0000000000..bab989ab22
--- /dev/null
+++ b/definitions/npm/react-i18next_v7.x.x/flow_v0.201.x-/test_react-i18next_v7.x.x.js
@@ -0,0 +1,333 @@
+// @flow
+
+import * as React from "react";
+import {
+  loadNamespaces,
+  translate,
+  I18nextProvider,
+  I18n,
+  Interpolate,
+  Trans,
+  setDefaults,
+  reactI18nextModule,
+  getDefaults,
+  getI18n,
+  setI18n
+} from "react-i18next";
+import type {
+  TFunction,
+  TranslateOptions,
+  TranslatorProps
+} from "react-i18next";
+import { describe, it } from "flow-typed-test";
+
+const i18n = { loadNamespaces: () => {} };
+
+describe("react-i18next", () => {
+  describe("<I18nextProvider />", () => {
+    it("passes when passed correct props", () => {
+      <I18nextProvider i18n={i18n} children={<div />} />;
+    });
+
+    it("raises error when missing children prop", () => {
+      // $FlowExpectedError - missing children prop
+      <I18nextProvider i18n={i18n} />;
+    });
+
+    it("raises error when missing i18n prop", () => {
+      // $FlowExpectedError - missing i18n prop
+      <I18nextProvider children={<div />} />;
+    });
+  });
+
+  describe("loadNamespaces", () => {
+    it("passes when called with correct arguments", () => {
+      loadNamespaces({ components: [], i18n });
+      loadNamespaces({ components: [() => <div />], i18n });
+    });
+
+    it("raises error when called with incorrect arguments", () => {
+      // $FlowExpectedError - too few arguments
+      loadNamespaces();
+      // $FlowExpectedError - wrong type
+      loadNamespaces("");
+      // $FlowExpectedError - wrong components type
+      loadNamespaces({ components: [{}], i18n });
+    });
+  });
+
+  describe("TFunction", () => {
+    it("passes when passed valid arguments", () => {
+      const testFn = (t: TFunction) => {
+        t("key");
+        t("key", { val: "val" });
+      };
+    });
+
+    it("errors when passed invalid arguments", () => {
+      const testFn = (t: TFunction) => {
+        // $FlowExpectedError wrong second argument type
+        t("key", "key2");
+        // $FlowExpectedError First argument must be a string
+        t({ val: "val" });
+      };
+    });
+  });
+
+  describe("translate HOC", () => {
+    it("passes when called with correct arguments", () => {
+      const namspaces: Array<string> = ["namespace1", "namespace2"];
+      translate();
+      translate(namspaces);
+      translate("namespace1");
+      translate(({ s }) => s);
+      translate(({ s }) => [s]);
+    });
+
+    it("errors when called with invalid arguments", () => {
+      // $FlowExpectedError - wrong argument type
+      translate({});
+    });
+
+    describe("Stateless Functional Components", () => {
+      it("passes if the component is passed required props", () => {
+        const Comp = ({ s, t }: {
+          s: string,
+          t: TFunction,
+          ...
+        }) => (
+          <div prop1={t("")} prop2={" " + s} />
+        );
+        const WrappedComp = translate()(Comp);
+        <WrappedComp s="" />;
+      });
+
+      it("errors if the component is missing required props", () => {
+        const Comp = ({ s, t }: {
+          s: string,
+          t: TFunction,
+          ...
+        }) => (
+          <div prop1={t("")} prop2={" " + s} />
+        );
+        const WrappedComp = translate()(Comp);
+        // $FlowExpectedError - missing prop "s"
+        <WrappedComp />;
+      });
+
+      it("errors if the component is passed props of the wrong type", () => {
+        // $FlowExpectedError - wrong type
+        const Comp = ({ s, t }: {
+          s: string,
+          t: TFunction,
+          ...
+        }) => (
+          <div prop1={t("")} prop2={" " + s} />
+        );
+        const WrappedComp = translate()(Comp);
+        // $FlowExpectedError - wrong type
+        <WrappedComp s={1} />;
+      });
+    });
+
+    describe("Class Components", () => {
+      it("passes if the component is passed required props", () => {
+        class Comp extends React.Component<{
+          s: string,
+          t: TFunction,
+          ...
+        }> {
+          render() {
+            const { s, t } = this.props;
+            return <span>{t(s)}</span>;
+          }
+        }
+        const WrappedComp = translate()(Comp);
+        <WrappedComp s="" />;
+      });
+
+      it("errors if the component is missing required props", () => {
+        class Comp extends React.Component<{
+          s: string,
+          t: TFunction,
+          ...
+        }> {
+          render() {
+            const { s, t } = this.props;
+            return <span>{t(s)}</span>;
+          }
+        }
+        const WrappedComp = translate()(Comp);
+        // $FlowExpectedError - missing prop "s"
+        <WrappedComp />;
+      });
+
+      it("errors if the component is passed props of the wrong type", () => {
+        class Comp extends React.Component<{
+          s: string,
+          t: TFunction,
+          ...
+        }> {
+          render() {
+            const { s, t } = this.props;
+            return <span>{t(s)}</span>;
+          }
+        }
+        const WrappedComp = translate()(Comp);
+        // $FlowExpectedError - wrong type
+        <WrappedComp s={1} />;
+      });
+
+      it("passes if a required prop is handled by defaultProps", () => {
+        class Comp extends React.Component<{
+          s: string,
+          t: TFunction,
+          ...
+        }> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            const { s, t } = this.props;
+            return <span>{t(s)}</span>;
+          }
+        }
+        const WrappedComp = translate()(Comp);
+        <WrappedComp />;
+      });
+
+      it("errors if a required prop that has a defaultProp is passed the wrong type", () => {
+        class Comp extends React.Component<{
+          s: string,
+          t: TFunction,
+          ...
+        }> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            const { s, t } = this.props;
+            return <span>{t(s)}</span>;
+          }
+        }
+        const WrappedComp = translate()(Comp);
+        // $FlowExpectedError - wrong type
+        <WrappedComp s={123} />;
+      });
+    });
+  });
+
+  describe("<I18n />", () => {
+    it("passes when passed correct props", () => {
+      <I18n>{(t: TFunction) => <span>{t("title")}</span>}</I18n>;
+      <I18n ns="translations">
+        {(t: TFunction, { i18n }: { i18n: Object, ... }) => (
+          <div>
+            <span>{t("title")}</span>
+            <button onClick={() => i18n.changeLanguage("de")}>de</button>
+            <button onClick={() => i18n.changeLanguage("en")}>en</button>
+          </div>
+        )}
+      </I18n>;
+    });
+
+    it("errors when no children are passed", () => {
+      // $FlowExpectedError - no children passed to I18n component
+      <I18n ns="translations" />;
+    });
+  });
+
+  describe("<Interpolate />", () => {
+    it("passes when passed correct props", () => {
+      <Interpolate />;
+      <Interpolate i18nKey="translation.key" keyValue={5} />;
+      <Interpolate
+        className="string"
+        dangerouslySetInnerHTMLPartElement="span"
+        i18n={i18n}
+        i18nKey="translation.key"
+        options={{}}
+        parent="div"
+        style={{}}
+        t={key => ""}
+        useDangerouslySetInnerHTML={true}
+      />;
+    });
+
+    it("fails when passed props of wrong type", () => {
+      // $FlowExpectedError - i18nKey prop wrong type
+      <Interpolate i18nKey={1} />;
+    });
+  });
+
+  describe("<Trans />", () => {
+    it("passes when passed correct props", () => {
+      <Trans i18nKey="translation.key" />;
+      <Trans i18nKey="translation.key" count={5} />;
+      <Trans i18nKey="translation.key" count={5} parent="div" i18n={i18n} />;
+    });
+
+    it("errors when passed props of wrong type", () => {
+      // $FlowExpectedError - i18nKey prop wrong type
+      <Trans i18nKey={5} />;
+    });
+  });
+
+  describe("reactI18nextModule", () => {
+    it("has correct properties", () => {
+      reactI18nextModule.init(i18n);
+      reactI18nextModule.type;
+    });
+
+    it("errors if trying to access an unknown property", () => {
+      // $FlowExpectedError - no field property on reactI18nextModule
+      reactI18nextModule.field;
+    });
+  });
+
+  describe("setDefaults", () => {
+    it("passes when passed an object with allowed properties", () => {
+      setDefaults({ wait: true });
+    });
+
+    it("errors if passes a non-object or an invalid proeprty", () => {
+      // $FlowExpectedError - setDefaults must be called with an object
+      setDefaults("option");
+      // $FlowExpectedError - other is not a valid option
+      setDefaults({ other: true });
+    });
+  });
+
+  describe("getDefaults", () => {
+    it("passes when called without an argument", () => {
+      const options: TranslateOptions = getDefaults();
+    });
+
+    it("errors if passed an argument", () => {
+      // $FlowExpectedError - no arguments should be passed to getDefaults
+      getDefaults("string");
+    });
+  });
+
+  describe("getI18n", () => {
+    it("passes when called without an argument", () => {
+      getI18n();
+    });
+
+    it("errors if passed an argument", () => {
+      // $FlowExpectedError - no arguments should be passed to getI18n
+      getI18n("string");
+    });
+  });
+
+  describe("setI18n", () => {
+    it("passes when called with an object", () => {
+      setI18n(i18n);
+    });
+
+    it("errors if passed a non-object", () => {
+      // $FlowExpectedError - i18n object should be passed to setI18n
+      setI18n("string");
+    });
+  });
+});
diff --git a/definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-/react-loadable_v5.x.x.js b/definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-v.200.x/react-loadable_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-/react-loadable_v5.x.x.js
rename to definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-v.200.x/react-loadable_v5.x.x.js
diff --git a/definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-/test_react-loadable_v5.x.x.js b/definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-v.200.x/test_react-loadable_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-/test_react-loadable_v5.x.x.js
rename to definitions/npm/react-loadable_v5.x.x/flow_v0.104.x-v.200.x/test_react-loadable_v5.x.x.js
diff --git a/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/react-loadable_v5.x.x.js b/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/react-loadable_v5.x.x.js
new file mode 100644
index 0000000000..9ab3d73159
--- /dev/null
+++ b/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/react-loadable_v5.x.x.js
@@ -0,0 +1,67 @@
+declare type $Await<T, P: Promise<T>> = T;
+
+declare module 'react-loadable' {
+  declare type LoadingProps = {
+    isLoading: boolean,
+    pastDelay: boolean,
+    timedOut: boolean,
+    retry: () => void,
+    error: ?Error,
+    ...
+  };
+
+  declare type CommonOptions = {
+    loading: React$ComponentType<LoadingProps>,
+    delay?: number,
+    timeout?: number,
+    modules?: Array<string>,
+    webpack?: () => Array<number>,
+    ...
+  };
+
+  declare type OptionsWithoutRender<TProps> = {
+    ...CommonOptions,
+    loader(): Promise<React$ComponentType<TProps> | { default: React$ComponentType<TProps>, ... }>,
+    ...
+  };
+
+  declare type OptionsWithRender<TProps, TModule> = {
+    ...CommonOptions,
+    loader(): Promise<TModule>,
+    render(loaded: TModule, props: TProps): React$Node,
+    ...
+  };
+
+  declare type Options<TProps, TModule> = OptionsWithoutRender<TProps> | OptionsWithRender<TProps, TModule>;
+
+  declare type MapOptions<TProps, TModules: { +[key: string]: any, ... }> = {
+    ...CommonOptions,
+    loader: { [key: $Keys<TModules>]: () => Promise<any>, ... },
+    render(loaded: TModules, props: TProps): React$Node,
+    ...
+  };
+
+  declare class LoadableComponent<TProps> extends React$Component<TProps> {
+    static preload(): Promise<void>
+  }
+
+  declare type CaptureProps = { report(moduleName: string): void, ... };
+  
+  /**
+  * A type level function like
+  * <T>({ [string]: () => Promise<T> }) -> ({ [string]: T })
+  * It would be helpful to apply type arguments to Loadable.Map<> like below.
+  * 
+  * Loadable.Map<Props, typeof { A: () => import("a") }>({...});
+  */
+  declare type MapModules<L> = $ObjMap<L, <P>(P) => $Await<any, $Call<P>>>;
+
+  declare module.exports: {
+    <TProps, TModule>(opts: Options<TProps, TModule>): Class<LoadableComponent<TProps>>,
+    Map<TProps, TModules>(opts: MapOptions<TProps, TModules>): Class<LoadableComponent<TProps>>,
+    Capture: React$ComponentType<CaptureProps>,
+    preloadAll(): Promise<void>,
+    preloadReady(): Promise<void>,
+    ...
+  };
+}
diff --git a/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/test_react-loadable_v5.x.x.js b/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/test_react-loadable_v5.x.x.js
new file mode 100644
index 0000000000..c3b4d2f576
--- /dev/null
+++ b/definitions/npm/react-loadable_v5.x.x/flow_v0.201.x-/test_react-loadable_v5.x.x.js
@@ -0,0 +1,226 @@
+// @flow
+
+import React from 'react';
+import Loadable, { type MapModules } from 'react-loadable';
+import { describe, it } from 'flow-typed-test';
+
+type Props = { a: string, ... };
+class Component extends React.Component<Props> {}
+
+describe('options', () => {
+  it('should fail when props is not provided', () => {
+    // $FlowExpectedError
+    Loadable();
+  });
+
+  it('should fail when loader is missing', () => {
+    // $FlowExpectedError
+    Loadable({
+      loading: () => null
+    });
+  });
+
+  it('should fail when loader option does not return a promise that resolves to a react component or a module object with default export which is a react component', () => {
+    // $FlowExpectedError
+    Loadable({
+      loader: () => Promise.resolve(1),
+      loading: () => null
+    });
+  });
+
+  it('delay property should be a number', () => {
+    // $FlowExpectedError
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      delay: ''
+    });
+
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      delay: 1
+    });
+  });
+
+  it('timeout property should be a number', () => {
+    // $FlowExpectedError
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      timeout: ''
+    });
+
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      timeout: 1
+    });
+  });
+
+  it('webpack option should be a function', () => {
+    // $FlowExpectedError
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      webpack: []
+    });
+
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      webpack: () => [1]
+    });
+  });
+
+  it('modules options should be an array of strings', () => {
+    // $FlowExpectedError modules option should be an array of module names
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      modules: [1]
+    });
+
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      modules: ['f', 'o', 'o']
+    });
+  });
+
+  it('render option should take a resolved module and related component props', () => {
+    // $FlowExpectedError render option should take a resolved module and related component props
+    Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null,
+      render: (a: string, b: string) => null
+    });
+  });
+});
+
+describe('props refinements', () => {
+  class SyncComponent extends React.Component<{
+    a: string,
+    b: number,
+    ...
+  }> {}
+
+  it('should refine props type from render function', () => {
+    const LoadableComponent = Loadable({
+      loader: (): Promise<number> => Promise.resolve(1),
+      loading: () => null,
+      render: (b: number, props: Props) => <SyncComponent a={props.a} b={b} />
+    });
+
+    const foo = <LoadableComponent a="foo"/>;
+    // $FlowExpectedError
+    const bar = <LoadableComponent a={1} />;
+  });
+
+  it('should refine props type from loader option', () => {
+    const Loaded1 = Loadable({
+      loader: () => Promise.resolve(Component),
+      loading: () => null
+    });
+
+    // $FlowExpectedError
+    const noWay = <Loaded1 a={1} />;
+    <Loaded1 a="foo"/>;
+
+    const Loaded2 = Loadable({
+      loader: () => Promise.resolve({ default: Component }),
+      loading: () => null
+    });
+
+    // $FlowExpectedError
+    const noWay = <Loaded2 a={1} />;
+
+    <Loaded2 a="foo"/>
+  });
+});
+
+describe('result component', () => {
+  it('should be a react component', () => {
+    const LoadableComponent: React$ComponentType<Props> = Loadable({
+      loader: () => Promise.resolve({ default: Component }),
+      loading: () => null
+    });
+  });
+
+  it('should have preload() static method', () => {
+    const LoadableComponent = Loadable({
+      loader: () => Promise.resolve({ default: Component }),
+      loading: () => null
+    });
+
+    LoadableComponent.preload();
+  });
+});
+
+it('Loadable.Map() should work', () => {
+  class Component extends React.Component<{
+    a: string,
+    b: number,
+    ...
+  }> {}
+
+  const LoadableMap = Loadable.Map({
+    loading: () => null,
+    loader: {
+      Cmp: () => Promise.resolve({ foo: Component }),
+      b: () => Promise.resolve(1)
+    },
+    render: (loaded: {
+      Cmp: { foo: React$ComponentType<{
+        a: string,
+        b: number,
+        ...
+      }>, ... },
+      b: number,
+      ...
+    }, props: { a: string, ... }) => <loaded.Cmp.foo a={props.a} b={loaded.b} />
+  });
+
+  <LoadableMap a="foo" />
+});
+
+it('Loadable.Map() can infer type of modules', () => {
+  class Component extends React.Component<{
+    a: string,
+    b: number,
+    ...
+  }> {}
+  const loader = {
+    Cmp: () => Promise.resolve({ foo: Component }),
+    b: () => Promise.resolve(1)
+  };
+
+  const LoadableMap = Loadable.Map<any, MapModules<typeof loader>>({
+    loading: () => null,
+    loader,
+    render: (loaded, props) => {
+      // $FlowExpectedError
+      (loaded: empty);
+      (loaded: {
+        Cmp: { foo: React$ComponentType<{
+          a: string,
+          b: number,
+          ...
+        }>, ... },
+        b: number,
+        ...
+      });
+      return <loaded.Cmp.foo a={props.a} b={loaded.b} />;
+    }
+  });
+
+  <LoadableMap a="foo" />
+});
+
+it('Loadable.preloadAll()', () => {
+  Loadable.preloadAll();
+});
+
+it('Loadable.preloadReady()', () => {
+  Loadable.preloadReady();
+});
diff --git a/definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-/react-native-maps_v0.16.x.js b/definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-v.200.x/react-native-maps_v0.16.x.js
similarity index 100%
rename from definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-/react-native-maps_v0.16.x.js
rename to definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-v.200.x/react-native-maps_v0.16.x.js
diff --git a/definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-/test_react-native-maps.js b/definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-v.200.x/test_react-native-maps.js
similarity index 100%
rename from definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-/test_react-native-maps.js
rename to definitions/npm/react-native-maps_v0.16.x/flow_v0.104.x-v.200.x/test_react-native-maps.js
diff --git a/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/react-native-maps_v0.16.x.js b/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/react-native-maps_v0.16.x.js
new file mode 100644
index 0000000000..29700c00db
--- /dev/null
+++ b/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/react-native-maps_v0.16.x.js
@@ -0,0 +1,205 @@
+declare module 'react-native-maps' {
+  declare export type Region = {|
+    latitude: number,
+    longitude: number,
+    latitudeDelta: number,
+    longitudeDelta: number,
+  |};
+
+  declare export type LatLng = {|
+    latitude: number,
+    longitude: number,
+  |};
+
+  declare export type MapType = 'standard' | 'satellite' | 'hybrid' | 'terrain';
+
+  declare export type Point = {|
+    x: number,
+    y: number,
+  |};
+
+  declare export type EdgePadding = {|
+    top: number,
+    right: number,
+    bottom: number,
+    left: number,
+  |};
+
+  declare export type EdgeInsets = {|
+    top: number,
+    left: number,
+    bottom: number,
+    right: number,
+  |};
+
+  declare class EventWithCoordinateAndPosition extends Event {
+    coordinate: LatLng;
+    position: Point;
+  }
+
+  declare export class InteractWithMapEvent extends Event {
+    nativeEvent: EventWithCoordinateAndPosition;
+  }
+
+  declare type MapViewProps = {
+    provider?: ?'google',
+    region?: Region,
+    initialRegion?: Region,
+    liteMode?: boolean,
+    mapType?: MapType,
+    showsUserLocation?: boolean,
+    followsUserLocation?: boolean,
+    showsMyLocationButton?: boolean,
+    showsPointsOfInterest?: boolean,
+    showsCompass?: boolean,
+    showsScale?: boolean,
+    showsBuildings?: boolean,
+    showsTraffic?: boolean,
+    showsIndoors?: boolean,
+    zoomEnabled?: boolean,
+    rotateEnabled?: boolean,
+    scrollEnabled?: boolean,
+    pitchEnabled?: boolean,
+    toolbarEnabled?: boolean,
+    cacheEnabled?: boolean,
+    loadingEnabled?: boolean,
+    loadingIndicatorColor?: string,
+    loadingBackgroundColor?: string,
+    moveOnMarkerPress?: Boolean,
+    legalLabelInsets?: EdgeInsets,
+    onRegionChange?: (region: Region) => void,
+    onRegionChangeComplete?: (region: Region) => void,
+    onPress?: (event: InteractWithMapEvent) => void,
+    onPanDrag?: (event: InteractWithMapEvent) => void,
+    onLongPress?: (event: InteractWithMapEvent) => void,
+    onMarkerPress?: (event: SyntheticEvent<any>) => void,
+    onMarkerSelect?: (event: SyntheticEvent<any>) => void,
+    onMarkerDeselect?: (event: SyntheticEvent<any>) => void,
+    onCalloutPress?: (event: SyntheticEvent<any>) => void,
+    onMarkerDragStart?: (event: InteractWithMapEvent) => void,
+    onMarkerDrag?: (event: InteractWithMapEvent) => void,
+    onMarkerDragEnd?: (event: InteractWithMapEvent) => void,
+    ...
+  };
+
+  declare type ImageSourcePropType =
+    | number
+    | {
+    uri: string,
+    width?: number,
+    height?: number,
+    scale?: number,
+    ...
+  };
+
+  declare type CalloutProps = {
+    tooltip?: boolean,
+    onPress?: (event: SyntheticEvent<any>) => void,
+    ...
+  };
+
+  declare class Callout extends React$Component<CalloutProps> {}
+
+  declare type MarkerProps = {
+    title?: string,
+    description?: string,
+    image?: ImageSourcePropType,
+    pinColor?: string,
+    coordinate: LatLng,
+    centerOffset?: Point,
+    calloutOffset?: Point,
+    anchor?: Point,
+    calloutAnchor?: Point,
+    flat?: Boolean,
+    identifier?: String,
+    rotation?: number,
+    draggable?: ?boolean,
+    onPress?: (event: InteractWithMapEvent) => void,
+    onSelect?: (event: InteractWithMapEvent) => void,
+    onDeselect?: (event: InteractWithMapEvent) => void,
+    onCalloutPress?: (event: SyntheticEvent<any>) => void,
+    onDragStart?: (event: InteractWithMapEvent) => void,
+    onDrag?: (event: InteractWithMapEvent) => void,
+    onDragEnd?: (event: InteractWithMapEvent) => void,
+    ...
+  };
+
+  declare class Marker extends React$Component<MarkerProps> {
+    showCallout: () => void;
+    hideCallout: () => void;
+  }
+
+  declare type PolygonProps = {
+    coordinates: LatLng[],
+    strokeWidth?: number,
+    strokeColor?: string,
+    fillColor?: string,
+    lineCap?: string,
+    lineJoin?: LatLng[],
+    miterLimit?: number,
+    geodesic?: boolean,
+    lineDashPhase?: number,
+    lineDashPattern?: number[],
+    onPress?: (event: SyntheticEvent<any>) => void,
+    ...
+  };
+
+  declare class Polygon extends React$Component<PolygonProps> {}
+
+  declare type PolylineProps = {
+    coordinates: LatLng[],
+    strokeWidth?: number,
+    strokeColor?: string,
+    lineCap?: string,
+    lineJoin?: LatLng[],
+    miterLimit?: number,
+    geodesic?: boolean,
+    lineDashPhase?: number,
+    lineDashPattern?: number[],
+    onPress?: (event: SyntheticEvent<any>) => void,
+    ...
+  };
+
+  declare class Polyline extends React$Component<PolylineProps> {}
+
+  declare type CircleProps = {
+    center: LatLng,
+    radius: number,
+    strokeWidth?: number,
+    strokeColor?: string,
+    fillColor?: string,
+    zIndex?: number,
+    lineCap?: string,
+    lineJoin?: LatLng[],
+    miterLimit?: number,
+    geodesic?: boolean,
+    lineDashPhase?: number,
+    lineDashPattern?: number[],
+    ...
+  };
+
+  declare class Circle extends React$Component<CircleProps> {}
+
+  declare class MapView extends React$Component<MapViewProps> {
+    static Marker: typeof Marker;
+    static Callout: typeof Callout;
+    static Polygon: typeof Polygon;
+    static Polyline: typeof Polyline;
+    static Circle: typeof Circle;
+
+    animateToRegion: (region: Region, duration?: number) => void;
+    animateToCoordinate: (coordinate: LatLng, duration?: number) => void;
+    fitToElements: (animated: boolean) => void;
+    fitToSuppliedMarkers: (markerIDs: string[], animated: boolean) => void;
+    fitToCoordinates: (
+      coordinates: LatLng[],
+      options?: {
+        edgePadding?: EdgePadding,
+        animated?: boolean,
+        ...
+      },
+    ) => void;
+  }
+
+  declare export default typeof MapView
+}
diff --git a/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/test_react-native-maps.js b/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/test_react-native-maps.js
new file mode 100644
index 0000000000..23d8772427
--- /dev/null
+++ b/definitions/npm/react-native-maps_v0.16.x/flow_v0.201.x-/test_react-native-maps.js
@@ -0,0 +1,12 @@
+import MapView from 'react-native-maps';
+import React, { Component } from 'react';
+
+// $FlowExpectedError
+const A = <MapView initialRegion="mexico" />;
+
+const B = <MapView />;
+
+// $FlowExpectedError
+const C = <MapView.Marker />;
+
+const D = <MapView.Marker coordinate={{ latitude: 50, longitude: 50 }} />;
diff --git a/definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-/react-navigation_v1.x.x.js b/definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-v.200.x/react-navigation_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-/react-navigation_v1.x.x.js
rename to definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-v.200.x/react-navigation_v1.x.x.js
diff --git a/definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-/test_react-navigation.js b/definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-v.200.x/test_react-navigation.js
similarity index 100%
rename from definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-/test_react-navigation.js
rename to definitions/npm/react-navigation_v1.x.x/flow_v0.104.x-v.200.x/test_react-navigation.js
diff --git a/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/react-navigation_v1.x.x.js b/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/react-navigation_v1.x.x.js
new file mode 100644
index 0000000000..9d23d76bb0
--- /dev/null
+++ b/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/react-navigation_v1.x.x.js
@@ -0,0 +1,1155 @@
+declare module 'react-navigation' {
+  import type { ComponentType, Node, ElementType, Ref, Element } from 'react'
+  /**
+   * First, a bunch of things we would love to import but instead must
+   * reconstruct (mostly copy-pasted).
+   */
+
+  // This is a bastardization of the true StyleObj type located in
+  // react-native/Libraries/StyleSheet/StyleSheetTypes. We unfortunately can't
+  // import that here, and it's too lengthy (and consequently too brittle) to
+  // copy-paste here either.
+  declare type StyleObj =
+    | null
+    | void
+    | number
+    | false
+    | ''
+    | $ReadOnlyArray<StyleObj>
+    | { [name: string]: any, ... };
+  declare type ViewStyleProp = StyleObj;
+  declare type TextStyleProp = StyleObj;
+  declare type AnimatedViewStyleProp = StyleObj;
+  declare type AnimatedTextStyleProp = StyleObj;
+
+  // This is copied from the Layout type in
+  // react-native-tab-view/src/TabViewTypeDefinitions
+  declare type TabViewLayout = {
+    height: number,
+    width: number,
+    ...
+  };
+
+  // This is copied from react-native/Libraries/Image/ImageSource.js
+  declare type ImageURISource = {
+    uri?: string,
+    bundle?: string,
+    method?: string,
+    headers?: Object,
+    body?: string,
+    cache?: 'default' | 'reload' | 'force-cache' | 'only-if-cached',
+    width?: number,
+    height?: number,
+    scale?: number,
+    ...
+  };
+  declare type ImageSource = ImageURISource | number | Array<ImageURISource>;
+
+  // This one is too large to copy. Actual definition is in
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type AnimatedValue = Object;
+
+  declare type HeaderForceInset = {
+    horizontal?: string,
+    vertical?: string,
+    left?: string,
+    right?: string,
+    top?: string,
+    bottom?: string,
+    ...
+  };
+
+  /**
+   * Next, all the type declarations
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationNavigateAction = {|
+    type: 'Navigation/NAVIGATE',
+    routeName: string,
+    params?: NavigationParams,
+
+    // The action to run inside the sub-router
+    action?: NavigationNavigateAction,
+
+    key?: string,
+  |};
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+
+  declare export type NavigationSetParamsAction = {|
+    type: 'Navigation/SET_PARAMS',
+
+    // The key of the route where the params should be set
+    key: string,
+
+    // The new params to merge into the existing route params
+    params: NavigationParams,
+  |};
+
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+
+  declare export type NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+
+  declare export type NavigationUriAction = {|
+    type: 'Navigation/URI',
+    uri: string,
+  |};
+
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationPopAction = {|
+    +type: 'Navigation/POP',
+    +n?: number,
+    +immediate?: boolean,
+  |};
+  declare export type NavigationPopToTopAction = {|
+    +type: 'Navigation/POP_TO_TOP',
+    +immediate?: boolean,
+    +key?: string,
+  |};
+  declare export type NavigationPushAction = {|
+    +type: 'Navigation/PUSH',
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+    +key?: string,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationReplaceAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationBackAction
+    | NavigationSetParamsAction
+    | NavigationResetAction;
+
+  /**
+   * NavigationState is a tree of routes for a single navigator, where each
+   * child route may either be a NavigationScreenRoute or a
+   * NavigationRouterRoute. NavigationScreenRoute represents a leaf screen,
+   * while the NavigationRouterRoute represents the state of a child navigator.
+   *
+   * NOTE: NavigationState is a state tree local to a single navigator and
+   * its child navigators (via the routes field).
+   * If we're in navigator nested deep inside the app, the state will only be
+   * the state for that navigator.
+   * The state for the root navigator of our app represents the whole navigation
+   * state for the whole app.
+   */
+  declare export type NavigationState = {
+    /**
+     * Index refers to the active child route in the routes array.
+     */
+    index: number,
+    routes: Array<NavigationRoute>,
+    ...
+  };
+
+  declare export type NavigationRoute =
+    | NavigationLeafRoute
+    | NavigationStateRoute;
+
+  declare export type NavigationLeafRoute = {
+    /**
+     * React's key used by some navigators. No need to specify these manually,
+     * they will be defined by the router.
+     */
+    key: string,
+    /**
+     * For example 'Home'.
+     * This is used as a key in a route config when creating a navigator.
+     */
+    routeName: string,
+    /**
+     * Path is an advanced feature used for deep linking and on the web.
+     */
+    path?: string,
+    /**
+     * Params passed to this route when navigating to it,
+     * e.g. `{ car_id: 123 }` in a route that displays a car.
+     */
+    params?: NavigationParams,
+    ...
+  };
+
+  declare export type NavigationStateRoute = NavigationLeafRoute &
+    NavigationState;
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps?: {...}
+  ) => Options;
+
+  declare export type NavigationRouter<State: NavigationState, Options: {...}> = {
+    /**
+     * The reducer that outputs the new navigation state for a given action,
+     * with an optional previous state. When the action is considered handled
+     * but the state is unchanged, the output state is null.
+     */
+    getStateForAction: (action: NavigationAction, lastState: ?State) => ?State,
+    /**
+     * Maps a URI-like string to an action. This can be mapped to a state
+     * using `getStateForAction`.
+     */
+    getActionForPathAndParams: (
+      path: string,
+      params?: NavigationParams
+    ) => ?NavigationAction,
+    getPathAndParamsForState: (
+      state: State
+    ) => {
+      path: string,
+      params?: NavigationParams,
+      ...
+    },
+    getComponentForRouteName: (routeName: string) => NavigationComponent,
+    getComponentForState: (state: State) => NavigationComponent,
+    /**
+     * Gets the screen navigation options for a given screen.
+     *
+     * For example, we could get the config for the 'Foo' screen when the
+     * `navigation.state` is:
+     *
+     *  {routeName: 'Foo', key: '123'}
+     */
+    getScreenOptions: NavigationScreenOptionsGetter<Options>,
+    ...
+  };
+
+  declare export type NavigationScreenDetails<T> = {
+    options: T,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    ...
+  };
+
+  declare export type NavigationScreenOptions = { title?: string, ... };
+
+  declare export type NavigationScreenConfigProps = $Shape<{
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: {...},
+    ...
+  }>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({
+    ...$Exact<NavigationScreenConfigProps>,
+    navigationOptions: Options,
+    ...
+  }) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationContainer<NavigationStateRoute, any, any>;
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: {...}
+  > = ComponentType<NavigationNavigatorProps<Options, Route> & Props> &
+    ({...} | { navigationOptions: NavigationScreenConfig<Options>, ... });
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: {...}
+  > = ComponentType<NavigationNavigatorProps<Options, State> & Props> & {
+    router: NavigationRouter<State, Options>,
+    navigationOptions?: ?NavigationScreenConfig<Options>,
+    ...
+  };
+
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | ({
+    navigationOptions?: NavigationScreenConfig<any>,
+    path?: string,
+    ...
+  } & NavigationScreenRouteConfig);
+
+  declare export type NavigationScreenRouteConfig =
+    | { screen: NavigationComponent, ... }
+    | { getScreen: () => NavigationComponent, ... };
+
+  declare export type NavigationPathsConfig = { [routeName: string]: string, ... };
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Header
+   */
+
+  declare export type HeaderMode = 'float' | 'screen' | 'none';
+
+  declare export type HeaderProps = $Shape<
+    NavigationSceneRendererProps & {
+      mode: HeaderMode,
+      router: NavigationRouter<NavigationState, NavigationStackScreenOptions>,
+      getScreenDetails: NavigationScene => NavigationScreenDetails<
+        NavigationStackScreenOptions
+      >,
+      leftInterpolator: (props: NavigationSceneRendererProps) => {...},
+      titleInterpolator: (props: NavigationSceneRendererProps) => {...},
+      rightInterpolator: (props: NavigationSceneRendererProps) => {...},
+      ...
+    }
+  >;
+
+  /**
+   * Stack Navigator
+   */
+
+  declare export type NavigationStackScreenOptions = NavigationScreenOptions & {
+    header?: ?(Node | (HeaderProps => Node)),
+    headerTransparent?: boolean,
+    headerTitle?: string | Node | ElementType,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: Node | ElementType,
+    headerBackTitle?: ?string,
+    headerBackImage?: ImageSource,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: HeaderForceInset,
+    headerBackground?: Node | ElementType,
+    gesturesEnabled?: boolean,
+    gestureResponseDistance?: {
+      vertical?: number,
+      horizontal?: number,
+      ...
+    },
+    gestureDirection?: 'default' | 'inverted',
+    ...
+  };
+
+  declare export type NavigationStackRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    initialRouteKey?: string,
+  |};
+
+  declare export type NavigationStackViewConfig = {|
+    mode?: 'card' | 'modal',
+    headerMode?: HeaderMode,
+    headerTransitionPreset?: 'fade-in-place' | 'uikit',
+    cardStyle?: ViewStyleProp,
+    transitionConfig?: () => TransitionConfig,
+    onTransitionStart?: () => void,
+    onTransitionEnd?: () => void,
+  |};
+
+  declare export type StackNavigatorConfig = {|
+    ...NavigationStackViewConfig,
+    ...NavigationStackRouterConfig,
+  |};
+
+  /**
+   * Switch Navigator
+   */
+
+  declare export type NavigationSwitchRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    order?: Array<string>,
+    backBehavior?: 'none' | 'initialRoute', // defaults to `'none'`
+    resetOnBlur?: boolean, // defaults to `true`
+  |};
+
+  /**
+   * Tab Navigator
+   */
+
+  declare export type NavigationTabRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    // todo: type these as the real route names rather than 'string'
+    order?: Array<string>,
+    // Does the back button cause the router to switch to the initial tab
+    backBehavior?: 'none' | 'initialRoute', // defaults `initialRoute`
+  |};
+
+  declare type TabScene = {
+    route: NavigationRoute,
+    focused: boolean,
+    index: number,
+    tintColor?: ?string,
+    ...
+  };
+
+  declare export type NavigationTabScreenOptions = {|
+    ...$Exact<NavigationScreenOptions>,
+    tabBarIcon?:
+      | Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?Node),
+    tabBarLabel?:
+      | string
+      | Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?Node),
+    tabBarVisible?: boolean,
+    tabBarTestIDProps?: {
+      testID?: string,
+      accessibilityLabel?: string,
+      ...
+    },
+    tabBarOnPress?: (
+      scene: TabScene,
+      jumpToIndex: (index: number) => void
+    ) => void,
+  |};
+
+  /**
+   * Drawer
+   */
+
+  declare export type NavigationDrawerScreenOptions = {|
+    ...$Exact<NavigationScreenOptions>,
+    drawerIcon?:
+      | Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?Node),
+    drawerLabel?:
+      | Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?Node),
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+  |};
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  declare export type NavigationProp<S> = {
+    +state: S,
+    dispatch: NavigationDispatch,
+    ...
+  };
+
+  declare export type EventType =
+    | 'willFocus'
+    | 'didFocus'
+    | 'willBlur'
+    | 'didBlur'
+    | 'action';
+
+  declare export type NavigationEventPayload = {
+    type: EventType,
+    action: NavigationAction,
+    state: NavigationState,
+    lastState: ?NavigationState,
+    ...
+  };
+
+  declare export type NavigationEventCallback = (
+    payload: NavigationEventPayload
+  ) => void;
+
+  declare export type NavigationEventSubscription = { remove: () => void, ... };
+
+  declare export type NavigationScreenProp<+S> = {
+    +state: S,
+    dispatch: NavigationDispatch,
+    goBack: (routeKey?: ?string) => boolean,
+    navigate: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    getParam: (paramName: string, fallback?: any) => any,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    push: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    replace: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    pop: (n?: number, params?: { immediate?: boolean, ... }) => boolean,
+    popToTop: (params?: { immediate?: boolean, ... }) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: {...},
+    navigationOptions?: O,
+    ...
+  }>;
+
+  //declare export type NavigationNavigatorProps<O: {}, S: {}> =
+  //  | {}
+  //  | { navigation: NavigationScreenProp<S> }
+  //  | { screenProps: {} }
+  //  | { navigationOptions: O }
+  //  | {
+  //      navigation: NavigationScreenProp<S>,
+  //      screenProps: {},
+  //    }
+  //  | {
+  //      navigation: NavigationScreenProp<S>,
+  //      navigationOptions: O,
+  //    }
+  //  | {
+  //      screenProps: {},
+  //      navigationOptions: O,
+  //    }
+  //  | {
+  //      navigation: NavigationScreenProp<S>,
+  //      screenProps: {},
+  //      navigationOptions: O,
+  //    };
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: {...}
+  > = ComponentType<NavigationContainerProps<State, Options> & Props> & {
+    router: NavigationRouter<State, Options>,
+    navigationOptions?: ?NavigationScreenConfig<Options>,
+    ...
+  };
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    screenProps?: any,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * Gestures, Animations, and Interpolators
+   */
+
+  declare export type NavigationGestureDirection = 'horizontal' | 'vertical';
+
+  declare export type NavigationLayout = {
+    height: AnimatedValue,
+    initHeight: number,
+    initWidth: number,
+    isMeasured: boolean,
+    width: AnimatedValue,
+    ...
+  };
+
+  declare export type NavigationScene = {
+    index: number,
+    isActive: boolean,
+    isStale: boolean,
+    key: string,
+    route: NavigationRoute,
+    ...
+  };
+
+  declare export type NavigationTransitionProps = $Shape<{
+    // The layout of the screen container
+    layout: NavigationLayout,
+    // The destination navigation state of the transition
+    navigation: NavigationScreenProp<NavigationState>,
+    // The progressive index of the transitioner's navigation state.
+    position: AnimatedValue,
+    // The value that represents the progress of the transition when navigation
+    // state changes from one to another. Its numeric value will range from 0
+    // to 1.
+    //  progress.__getAnimatedValue() < 1 : transtion is happening.
+    //  progress.__getAnimatedValue() == 1 : transtion completes.
+    progress: AnimatedValue,
+    // All the scenes of the transitioner.
+    scenes: Array<NavigationScene>,
+    // The active scene, corresponding to the route at
+    // `navigation.state.routes[navigation.state.index]`. When rendering
+    // NavigationSceneRendererPropsIndex, the scene does not refer to the active
+    // scene, but instead the scene that is being rendered. The index always
+    // is the index of the scene
+    scene: NavigationScene,
+    index: number,
+    screenProps?: {...},
+    ...
+  }>;
+
+  // The scene renderer props are nearly identical to the props used for
+  // rendering a transition. The exception is that the passed scene is not the
+  // active scene but is instead the scene that the renderer should render
+  // content for.
+  declare export type NavigationSceneRendererProps = NavigationTransitionProps;
+
+  declare export type NavigationTransitionSpec = {
+    duration?: number,
+    // An easing function from `Easing`.
+    easing?: (t: number) => number,
+    // A timing function such as `Animated.timing`.
+    timing?: (value: AnimatedValue, config: any) => any,
+    ...
+  };
+
+  /**
+   * Describes a visual transition from one screen to another.
+   */
+  declare export type TransitionConfig = {
+    // The basics properties of the animation, such as duration and easing
+    transitionSpec?: NavigationTransitionSpec,
+    // How to animate position and opacity of the screen
+    // based on the value generated by the transitionSpec
+    screenInterpolator?: (props: NavigationSceneRendererProps) => {...},
+    // How to animate position and opacity of the header componetns
+    // based on the value generated by the transitionSpec
+    headerLeftInterpolator?: (props: NavigationSceneRendererProps) => {...},
+    headerTitleInterpolator?: (props: NavigationSceneRendererProps) => {...},
+    headerRightInterpolator?: (props: NavigationSceneRendererProps) => {...},
+    // The style of the container. Useful when a scene doesn't have
+    // 100% opacity and the underlying container is visible.
+    containerStyle?: ViewStyleProp,
+    ...
+  };
+
+  declare export type NavigationAnimationSetter = (
+    position: AnimatedValue,
+    newState: NavigationState,
+    lastState: NavigationState
+  ) => void;
+
+  declare export type NavigationSceneRenderer = () => Node;
+
+  declare export type NavigationStyleInterpolator = (
+    props: NavigationSceneRendererProps
+  ) => AnimatedViewStyleProp;
+
+  declare export type LayoutEvent = { nativeEvent: { layout: {
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    ...
+  }, ... }, ... };
+
+  declare export type SceneIndicesForInterpolationInputRange = {
+    first: number,
+    last: number,
+    ...
+  };
+
+  /**
+   * Now we type the actual exported module
+   */
+
+  declare export function createNavigationContainer<S: NavigationState, O: {...}>(
+    Component: NavigationNavigator<S, O, any>
+  ): NavigationContainer<S, O, any>;
+
+  declare export var StateUtils: {
+    get: (state: NavigationState, key: string) => ?NavigationRoute,
+    indexOf: (state: NavigationState, key: string) => number,
+    has: (state: NavigationState, key: string) => boolean,
+    push: (state: NavigationState, route: NavigationRoute) => NavigationState,
+    pop: (state: NavigationState) => NavigationState,
+    jumpToIndex: (state: NavigationState, index: number) => NavigationState,
+    jumpTo: (state: NavigationState, key: string) => NavigationState,
+    back: (state: NavigationState) => NavigationState,
+    forward: (state: NavigationState) => NavigationState,
+    replaceAt: (
+      state: NavigationState,
+      key: string,
+      route: NavigationRoute
+    ) => NavigationState,
+    replaceAtIndex: (
+      state: NavigationState,
+      index: number,
+      route: NavigationRoute
+    ) => NavigationState,
+    reset: (
+      state: NavigationState,
+      routes: Array<NavigationRoute>,
+      index?: number
+    ) => NavigationState,
+    ...
+  };
+
+  declare export function addNavigationHelpers<S: {...}>(
+    navigation: NavigationProp<S>
+  ): NavigationScreenProp<S>;
+
+  declare export var NavigationActions: {
+    BACK: 'Navigation/BACK',
+    INIT: 'Navigation/INIT',
+    NAVIGATE: 'Navigation/NAVIGATE',
+    RESET: 'Navigation/RESET',
+    REPLACE: 'Navigation/REPLACE',
+    SET_PARAMS: 'Navigation/SET_PARAMS',
+    URI: 'Navigation/URI',
+    back: {
+      (payload?: { key?: ?string, ... }): NavigationBackAction,
+      toString: () => string,
+      ...
+    },
+    init: {
+      (payload?: { params?: NavigationParams, ... }): NavigationInitAction,
+      toString: () => string,
+      ...
+    },
+    navigate: {
+      (payload: {
+        routeName: string,
+        params?: ?NavigationParams,
+        action?: ?NavigationNavigateAction,
+        ...
+      }): NavigationNavigateAction,
+      toString: () => string,
+      ...
+    },
+    reset: {
+      (payload: {
+        index: number,
+        key?: ?string,
+        actions: Array<NavigationNavigateAction>,
+        ...
+      }): NavigationResetAction,
+      toString: () => string,
+      ...
+    },
+    replace: {
+      (payload: {
+        routeName: string,
+        key: string,
+        newKey?: ?string,
+        params?: ?NavigationParams,
+        action?: ?NavigationNavigateAction,
+        immediate?: ?boolean,
+        ...
+      }): NavigationReplaceAction,
+      toString: () => string,
+      ...
+    },
+    setParams: {
+      (payload: {
+        key: string,
+        params: NavigationParams,
+        ...
+      }): NavigationSetParamsAction,
+      toString: () => string,
+      ...
+    },
+    uri: {
+      (payload: { uri: string, ... }): NavigationUriAction,
+      toString: () => string,
+      ...
+    },
+    ...
+  };
+
+  declare type _RouterProp<S: NavigationState, O: {...}> = { router: NavigationRouter<S, O>, ... };
+  declare type _NavigatorCreator<
+    NavigationViewProps: {...},
+    S: NavigationState,
+    O: {...}
+  > = (
+    NavigationView: ComponentType<_RouterProp<S, O> & NavigationViewProps>
+  ) => NavigationNavigator<S, O, NavigationViewProps>;
+  declare export function createNavigator<
+    S: NavigationState,
+    O: {...},
+    NavigatorConfig: {...},
+    NavigationViewProps: NavigationNavigatorProps<O, S>
+  >(
+    router: NavigationRouter<S, O>,
+    routeConfigs?: NavigationRouteConfigMap,
+    navigatorConfig?: NavigatorConfig
+  ): _NavigatorCreator<NavigationViewProps, S, O>;
+
+  declare export function StackNavigator(
+    routeConfigMap: NavigationRouteConfigMap,
+    stackConfig?: StackNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+
+  declare type _TabViewConfig = {|
+    tabBarComponent?: ElementType,
+    tabBarPosition?: 'top' | 'bottom',
+    tabBarOptions?: {...},
+    swipeEnabled?: boolean,
+    animationEnabled?: boolean,
+    configureTransition?: (
+      currentTransitionProps: Object,
+      nextTransitionProps: Object
+    ) => Object,
+    initialLayout?: TabViewLayout,
+  |};
+  declare type _TabNavigatorConfig = {|
+    ...NavigationTabRouterConfig,
+    ..._TabViewConfig,
+    lazy?: boolean,
+    removeClippedSubviews?: boolean,
+    containerOptions?: void,
+  |};
+  declare export function TabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _TabNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+  declare type _SwitchNavigatorConfig = {|
+    ...NavigationSwitchRouterConfig,
+  |};
+  declare export function SwitchNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _SwitchNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+
+  declare type _DrawerViewConfig = {|
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth?: number | (() => number),
+    drawerPosition?: 'left' | 'right',
+    drawerOpenRoute?: string,
+    drawerCloseRoute?: string,
+    drawerToggleRoute?: string,
+    contentComponent?: ElementType,
+    contentOptions?: {...},
+    style?: ViewStyleProp,
+    useNativeAnimations?: boolean,
+    drawerBackgroundColor?: string,
+    screenProps?: {...},
+  |};
+  declare type _DrawerNavigatorConfig = $Exact<{
+    ...NavigationTabRouterConfig,
+    ..._DrawerViewConfig,
+    containerConfig?: void,
+    ...
+  }>;
+  declare export function DrawerNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _DrawerNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+
+  declare export function StackRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationStackRouterConfig
+  ): NavigationRouter<any, NavigationStackScreenOptions>;
+
+  declare export function TabRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: NavigationTabRouterConfig
+  ): NavigationRouter<any, any>;
+
+  declare type _TransitionerProps = {
+    configureTransition: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps
+    ) => NavigationTransitionSpec,
+    navigation: NavigationScreenProp<NavigationState>,
+    onTransitionEnd?: (...args: Array<mixed>) => void,
+    onTransitionStart?: (...args: Array<mixed>) => void,
+    render: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps
+    ) => Node,
+    ...
+  };
+  declare export var Transitioner: ComponentType<_TransitionerProps>;
+
+  declare type _CardStackTransitionerProps = {
+    headerMode: HeaderMode,
+    mode: 'card' | 'modal',
+    router: NavigationRouter<NavigationState, NavigationStackScreenOptions>,
+    cardStyle?: ViewStyleProp,
+    onTransitionStart?: () => void,
+    onTransitionEnd?: () => void,
+    /**
+     * Optional custom animation when transitioning between screens.
+     */
+    transitionConfig?: () => TransitionConfig,
+    ...
+  } & NavigationNavigatorProps<NavigationStackScreenOptions, NavigationState>;
+  declare export var CardStackTransitioner: ComponentType<
+    _CardStackTransitionerProps
+  >;
+
+  declare type _CardStackProps = {
+    screenProps?: {...},
+    headerMode: HeaderMode,
+    headerComponent?: ElementType,
+    mode: 'card' | 'modal',
+    router: NavigationRouter<NavigationState, NavigationStackScreenOptions>,
+    cardStyle?: ViewStyleProp,
+    onTransitionStart?: () => void,
+    onTransitionEnd?: () => void,
+    /**
+     * Optional custom animation when transitioning between screens.
+     */
+    transitionConfig?: () => TransitionConfig,
+    // NavigationTransitionProps:
+    layout: NavigationLayout,
+    navigation: NavigationScreenProp<NavigationState>,
+    position: AnimatedValue,
+    progress: AnimatedValue,
+    scenes: Array<NavigationScene>,
+    scene: NavigationScene,
+    index: number,
+    ...
+  };
+  declare export var CardStack: ComponentType<_CardStackProps>;
+
+  declare type _CardProps = {
+    ...$Exact<NavigationSceneRendererProps>,
+    children: Node,
+    onComponentRef: Ref<any>,
+    pointerEvents: string,
+    style: any,
+    ...
+  };
+  declare export var Card: ComponentType<_CardProps>;
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewProps = {
+    forceInset?: {
+      top?: _SafeAreaViewForceInsetValue,
+      bottom?: _SafeAreaViewForceInsetValue,
+      left?: _SafeAreaViewForceInsetValue,
+      right?: _SafeAreaViewForceInsetValue,
+      vertical?: _SafeAreaViewForceInsetValue,
+      horizontal?: _SafeAreaViewForceInsetValue,
+      ...
+    },
+    children?: Node,
+    style?: AnimatedViewStyleProp,
+    ...
+  };
+  declare export var SafeAreaView: ComponentType<_SafeAreaViewProps>;
+
+  declare export var Header: ComponentType<HeaderProps> & { HEIGHT: number, ... };
+
+  declare type _HeaderTitleProps = {
+    children: Node,
+    selectionColor?: string | number,
+    style?: AnimatedTextStyleProp,
+    ...
+  };
+  declare export var HeaderTitle: ComponentType<_HeaderTitleProps>;
+
+  declare type _HeaderBackButtonProps = {
+    onPress?: () => void,
+    pressColorAndroid?: string,
+    title?: ?string,
+    titleStyle?: ?TextStyleProp,
+    tintColor?: ?string,
+    truncatedTitle?: ?string,
+    width?: ?number,
+    ...
+  };
+  declare export var HeaderBackButton: ComponentType<
+    _HeaderBackButtonProps
+  >;
+
+  declare type _DrawerViewProps = {
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth: number | (() => number),
+    drawerPosition: 'left' | 'right',
+    drawerOpenRoute: string,
+    drawerCloseRoute: string,
+    drawerToggleRoute: string,
+    contentComponent: ElementType,
+    contentOptions?: {...},
+    style?: ViewStyleProp,
+    useNativeAnimations: boolean,
+    drawerBackgroundColor: string,
+    screenProps?: {...},
+    navigation: NavigationScreenProp<NavigationState>,
+    router: NavigationRouter<NavigationState, NavigationDrawerScreenOptions>,
+    ...
+  };
+  declare export var DrawerView: ComponentType<_DrawerViewProps>;
+
+  declare type _DrawerScene = {
+    route: NavigationRoute,
+    focused: boolean,
+    index: number,
+    tintColor?: string,
+    ...
+  };
+  declare type _DrawerItem = {
+    route: NavigationRoute,
+    focused: boolean,
+    ...
+  };
+  declare type _DrawerItemsProps = {
+    navigation: NavigationScreenProp<NavigationState>,
+    items: Array<NavigationRoute>,
+    activeItemKey?: ?string,
+    activeTintColor?: string,
+    activeBackgroundColor?: string,
+    inactiveTintColor?: string,
+    inactiveBackgroundColor?: string,
+    getLabel: (scene: _DrawerScene) => ?(Node | string),
+    renderIcon: (scene: _DrawerScene) => ?Node,
+    onItemPress: (info: _DrawerItem) => void,
+    itemsContainerForceInset?: Object,
+    itemsContainerStyle?: ViewStyleProp,
+    itemStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    activeLabelStyle?: TextStyleProp,
+    inactiveLabelStyle?: TextStyleProp,
+    iconContainerStyle?: ViewStyleProp,
+    drawerPosition: 'left' | 'right',
+    ...
+  };
+  declare export var DrawerItems: ComponentType<_DrawerItemsProps>;
+
+  declare type _TabViewProps = {
+    tabBarComponent?: ElementType,
+    tabBarPosition?: 'top' | 'bottom',
+    tabBarOptions?: {...},
+    swipeEnabled?: boolean,
+    animationEnabled?: boolean,
+    configureTransition?: (
+      currentTransitionProps: Object,
+      nextTransitionProps: Object
+    ) => Object,
+    initialLayout: TabViewLayout,
+    screenProps?: {...},
+    navigation: NavigationScreenProp<NavigationState>,
+    router: NavigationRouter<NavigationState, NavigationTabScreenOptions>,
+    ...
+  };
+  declare export var TabView: ComponentType<_TabViewProps>;
+
+  declare type _TabBarTopProps = {
+    activeTintColor: string,
+    inactiveTintColor: string,
+    showIcon: boolean,
+    showLabel: boolean,
+    upperCaseLabel: boolean,
+    allowFontScaling: boolean,
+    position: AnimatedValue,
+    tabBarPosition: string,
+    navigation: NavigationScreenProp<NavigationState>,
+    jumpToIndex: (index: number) => void,
+    getLabel: (scene: TabScene) => ?(Node | string),
+    getOnPress: (
+      previousScene: NavigationRoute,
+      scene: TabScene
+    ) => ({
+      previousScene: NavigationRoute,
+      scene: TabScene,
+      jumpToIndex: (index: number) => void,
+      ...
+    }) => void,
+    renderIcon: (scene: TabScene) => Element<any>,
+    labelStyle?: TextStyleProp,
+    iconStyle?: ViewStyleProp,
+    ...
+  };
+  declare export var TabBarTop: ComponentType<_TabBarTopProps>;
+
+  declare type _TabBarBottomProps = {
+    activeTintColor: string,
+    activeBackgroundColor: string,
+    adaptive?: boolean,
+    inactiveTintColor: string,
+    inactiveBackgroundColor: string,
+    showLabel: boolean,
+    showIcon: boolean,
+    allowFontScaling: boolean,
+    position: AnimatedValue,
+    navigation: NavigationScreenProp<NavigationState>,
+    jumpToIndex: (index: number) => void,
+    getLabel: (scene: TabScene) => ?(Node | string),
+    getOnPress: (
+      previousScene: NavigationRoute,
+      scene: TabScene
+    ) => ({
+      previousScene: NavigationRoute,
+      scene: TabScene,
+      jumpToIndex: (index: number) => void,
+      ...
+    }) => void,
+    getTestIDProps: (scene: TabScene) => (scene: TabScene) => any,
+    renderIcon: (scene: TabScene) => Node,
+    style?: ViewStyleProp,
+    animateStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    tabStyle?: ViewStyleProp,
+    showIcon?: boolean,
+    ...
+  };
+  declare export var TabBarBottom: ComponentType<_TabBarBottomProps>;
+
+  declare export function withNavigation<Props: {...}>(
+    Component: ComponentType<Props>
+  ): ComponentType<
+    $Diff<
+      Props,
+      { navigation: NavigationScreenProp<NavigationStateRoute> | void, ... }
+    >
+  >;
+  declare export function withNavigationFocus<Props: {...}>(
+    Component: ComponentType<Props>
+  ): ComponentType<$Diff<Props, { isFocused: boolean | void, ... }>>;
+}
diff --git a/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/test_react-navigation.js b/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/test_react-navigation.js
new file mode 100644
index 0000000000..e3c8f8bdbd
--- /dev/null
+++ b/definitions/npm/react-navigation_v1.x.x/flow_v0.201.x-/test_react-navigation.js
@@ -0,0 +1,159 @@
+// @flow
+
+import type {
+  NavigationScreenProp,
+} from 'react-navigation';
+
+import {
+  TabNavigator,
+  StackNavigator,
+  DrawerNavigator,
+} from 'react-navigation';
+import React from 'react';
+
+/**
+ * Screens
+ */
+
+const FunctionalScreenComponent = (
+  { navigation }: { navigation: NavigationScreenProp<any>, ... },
+) => {
+  return "Test";
+};
+TabNavigator({
+  Test1: { screen: FunctionalScreenComponent },
+});
+
+class ClassScreenComponent extends React.Component<any> {
+  render() {
+    return "Test";
+  }
+}
+StackNavigator({
+  Test1: { screen: ClassScreenComponent },
+});
+
+// $FlowExpectedError numbers can never be components
+StackNavigator({
+  Test1: { screen: 5 },
+});
+
+// $FlowExpectedError you need a screen!
+TabNavigator({
+  Test1: { blah: "test" },
+});
+
+DrawerNavigator({
+  Test1: { getScreen: () => FunctionalScreenComponent },
+});
+
+/**
+ * Configs
+ */
+
+StackNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    mode: "card",
+    initialRouteName: "Test1",
+  },
+);
+
+StackNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError stack not drawer!
+  {
+    initialRouteName: "Test1",
+    drawerBackgroundColor: "green",
+  },
+);
+
+TabNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError tab not drawer!
+  {
+    drawerBackgroundColor: "green",
+  },
+);
+
+TabNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    initialRouteName: "Test1",
+  },
+);
+
+DrawerNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    drawerBackgroundColor: "green",
+  },
+);
+
+DrawerNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError drawer not tab!
+  {
+    tabBarPosition: "top",
+  },
+);
+
+/**
+ * Nav options
+ */
+
+StackNavigator({
+  Test1: {
+    screen: FunctionalScreenComponent,
+    navigationOptions: {
+      headerTitle: 'Home',
+    },
+  },
+});
+
+class ComponentWithNavOptions extends React.Component<any> {
+  static navigationOptions = {
+    headerTitle: "Home",
+  };
+  render() {
+    return "Test";
+  }
+}
+StackNavigator({
+  Test1: { screen: ComponentWithNavOptions },
+});
+
+class ComponentWithFunctionalNavOptions extends React.Component<any> {
+  static navigationOptions = (
+    { navigation }: { navigation: NavigationScreenProp<any>, ... },
+  ) => ({
+    headerTitle: navigation.state.routeName,
+  });
+  render() {
+    return "Test";
+  }
+}
+
+/**
+ * Nested
+ */
+
+const nestedNavigator = TabNavigator({
+  Test1: { screen: FunctionalScreenComponent },
+});
+StackNavigator({
+  Test2: { screen: nestedNavigator },
+  Test3: { screen: ClassScreenComponent },
+});
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/react-redux_v5.x.x.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/react-redux_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/react-redux_v5.x.x.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/react-redux_v5.x.x.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_Provider.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_Provider.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_Provider.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_Provider.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connect.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connect.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connect.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connect.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectAdvanced.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectDispatch.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectDispatch.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectHOC.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectHOC.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectInfer.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectInfer.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectMergeProps.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectState.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectState.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectState.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectState.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectThunk.js b/definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
similarity index 100%
rename from definitions/npm/react-redux_v5.x.x/flow_v0.142.x-/test_connectThunk.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/react-redux_v5.x.x.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/react-redux_v5.x.x.js
new file mode 100644
index 0000000000..386c695ecc
--- /dev/null
+++ b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/react-redux_v5.x.x.js
@@ -0,0 +1,277 @@
+/**
+The order of type arguments for connect() is as follows:
+
+connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(…)
+
+In Flow v0.89 only the first two are mandatory to specify. Other 4 can be repaced with the new awesome type placeholder:
+
+connect<Props, OwnProps, _, _, _, _>(…)
+
+But beware, in case of weird type errors somewhere in random places
+just type everything and get to a green field and only then try to
+remove the definitions you see bogus.
+
+Decrypting the abbreviations:
+  WC = Component being wrapped
+  S = State
+  D = Dispatch
+  OP = OwnProps
+  SP = StateProps
+  DP = DispatchProps
+  MP = Merge props
+  RSP = Returned state props
+  RDP = Returned dispatch props
+  RMP = Returned merge props
+  CP = Props for returned component
+  Com = React Component
+  ST = Static properties of Com
+  EFO = Extra factory options (used only in connectAdvanced)
+*/
+
+declare module "react-redux" {
+  // ------------------------------------------------------------
+  // Typings for connect()
+  // ------------------------------------------------------------
+
+  declare export type Options<S, OP, SP, MP> = {|
+    pure?: boolean,
+    withRef?: boolean,
+    areStatesEqual?: (next: S, prev: S) => boolean,
+    areOwnPropsEqual?: (next: OP, prev: OP) => boolean,
+    areStatePropsEqual?: (next: SP, prev: SP) => boolean,
+    areMergedPropsEqual?: (next: MP, prev: MP) => boolean,
+    storeKey?: string,
+  |};
+
+  declare type MapStateToProps<-S, -OP, +SP> =
+    | ((state: S, ownProps: OP) => SP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (State, OwnProps) => (State, OwnProps) => StateProps
+    // and provide the StateProps type to the SP type parameter.
+    | ((state: S, ownProps: OP) => (state: S, ownProps: OP) => SP);
+
+  declare type Bind<D> = <A, R>((...A) => R) => (...A) => $Call<D, R>;
+
+  declare type MapDispatchToPropsFn<D, -OP, +DP> =
+    | ((dispatch: D, ownProps: OP) => DP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (Dispatch, OwnProps) => (Dispatch, OwnProps) => DispatchProps
+    // and provide the DispatchProps type to the DP type parameter.
+    | ((dispatch: D, ownProps: OP) => (dispatch: D, ownProps: OP) => DP);
+
+  declare class ConnectedComponent<OP, +WC> extends React$Component<OP> {
+    static +WrappedComponent: WC;
+    getWrappedInstance(): React$ElementRef<WC>;
+  }
+  // The connection of the Wrapped Component and the Connected Component
+  // happens here in `MP: P`. It means that type wise MP belongs to P,
+  // so to say MP >= P.
+  declare type Connector<P, OP, MP: P> = <WC: React$ComponentType<P>>(
+    WC,
+  ) => Class<ConnectedComponent<OP, WC>> & WC;
+
+  // No `mergeProps` argument
+
+  // Got error like inexact OwnProps is incompatible with exact object type?
+  // Just make the OP parameter for `connect()` an exact object.
+  declare type MergeOP<OP, D> = {| ...$Exact<OP>, dispatch: D |};
+  declare type MergeOPSP<OP, SP, D> = {| ...$Exact<OP>, ...SP, dispatch: D |};
+  declare type MergeOPDP<OP, DP> = {| ...$Exact<OP>, ...DP |};
+  declare type MergeOPSPDP<OP, SP, DP> = {| ...$Exact<OP>, ...SP, ...DP |};
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    mapStateToProps?: null | void,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOP<OP, D>>,
+  ): Connector<P, OP, MergeOP<OP, D>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSP<OP, SP, D>>,
+  ): Connector<P, OP, MergeOPSP<OP, SP, D>>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, DP>>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, $ObjMap<DP, Bind<D>>>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+  ): Connector<P, OP, {| ...OP, ...SP, ...DP |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSPDP<OP, SP, DP>>,
+  ): Connector<P, OP, MergeOPSPDP<OP, SP, $ObjMap<DP, Bind<D>>>>;
+
+  // With `mergeProps` argument
+
+  declare type MergeProps<+P, -OP, -SP, -DP> = (
+    stateProps: SP,
+    dispatchProps: DP,
+    ownProps: OP,
+  ) => P;
+
+  declare export function connect<-P, -OP, -SP: {||}, -DP: {||}, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, {||}, {| dispatch: D |}>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  declare export function connect<-P, -OP, -SP, -DP: {||}, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, SP, {| dispatch: D |}>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, {||}, DP>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, {||}, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, SP, DP>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, SP, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // ------------------------------------------------------------
+  // Typings for Provider
+  // ------------------------------------------------------------
+
+  declare export class Provider<Store> extends React$Component<{
+    store: Store,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export function createProvider(
+    storeKey?: string,
+    subKey?: string,
+  ): Class<Provider<any>>;
+
+  // ------------------------------------------------------------
+  // Typings for connectAdvanced()
+  // ------------------------------------------------------------
+
+  declare type ConnectAdvancedOptions = {
+    getDisplayName?: (name: string) => string,
+    methodName?: string,
+    renderCountProp?: string,
+    shouldHandleStateChanges?: boolean,
+    storeKey?: string,
+    withRef?: boolean,
+    ...
+  };
+
+  declare type SelectorFactoryOptions<Com> = {
+    getDisplayName: (name: string) => string,
+    methodName: string,
+    renderCountProp: ?string,
+    shouldHandleStateChanges: boolean,
+    storeKey: string,
+    withRef: boolean,
+    displayName: string,
+    wrappedComponentName: string,
+    WrappedComponent: Com,
+    ...
+  };
+
+  declare type MapStateToPropsEx<S: Object, SP: Object, RSP: Object> = (
+    state: S,
+    props: SP,
+  ) => RSP;
+
+  declare type SelectorFactory<
+    Com: React$ComponentType<any>,
+    Dispatch,
+    S: Object,
+    OP: Object,
+    EFO: Object,
+    CP: Object,
+  > = (
+    dispatch: Dispatch,
+    factoryOptions: SelectorFactoryOptions<Com> & EFO,
+  ) => MapStateToPropsEx<S, OP, CP>;
+
+  declare export function connectAdvanced<
+    Com: React$ComponentType<any>,
+    D,
+    S: Object,
+    OP: Object,
+    CP: Object,
+    EFO: Object,
+    ST: { [_: $Keys<Com>]: any, ... },
+  >(
+    selectorFactory: SelectorFactory<Com, D, S, OP, EFO, CP>,
+    connectAdvancedOptions: ?(ConnectAdvancedOptions & EFO),
+  ): (component: Com) => React$ComponentType<OP> & $Shape<ST>;
+
+  declare export default {
+    Provider: typeof Provider,
+    createProvider: typeof createProvider,
+    connect: typeof connect,
+    connectAdvanced: typeof connectAdvanced,
+    ...
+  };
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_Provider.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_Provider.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_Provider.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_Provider.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connect.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connect.js
new file mode 100644
index 0000000000..84d0e7e83b
--- /dev/null
+++ b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connect.js
@@ -0,0 +1,779 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck1case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2case() {
+  type Props = { numProp: string, ... };
+
+  const Component = ({ numProp }: Props) => {
+    return <span>{numProp}</span>;
+  };
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for numProp
+  const Connected = connect<Props, {||}, _,_,_,_>(null, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck3case() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for numProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck4case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, {})(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testExactProps() {
+  type Dispatch = () => void;
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {|
+    ...OwnProps,
+    fromStateToProps: string,
+    dispatch: Dispatch,
+  |};
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {|
+    forMapStateToProps: string,
+    passthrough: number,
+  |};
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testInexactOwnProps() {
+  type OwnProps = {
+    passthrough: number,
+    forMapStateToProps: string,
+    ...
+  };
+  type Props = {
+    // to eliminate the cripy `undefined`
+    ...$Exact<OwnProps>,
+    fromStateToProps: string,
+    ...
+  };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {
+    forMapStateToProps: string,
+    passthrough: number,
+    ...
+  };
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsDoesNotPassDispatch() {
+  type Dispatch = () => void;
+  type OwnProps = {||};
+  type Props = {| ...OwnProps, fromMapDispatchToProps: string, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.fromMapDispatchToProps}</div>;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({})
+  const mapDispatchToProps = (dispatch: any, ownProps: any) => {
+    return {fromMapDispatchToProps: 'yo'}
+  }
+  // $FlowExpectedError[prop-missing] dispatch should not be provided in Props when mapDispatchToProps is present
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type OwnProps = {|
+    passthrough: number,
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  //$FlowExpectedError[invalid-obj-map] dispatch1 should be number
+  const Connected3 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  e.push(Connected3);
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type OwnProps1 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMergeProps: number
+  |};
+  type OwnProps2 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect<Props, OwnProps1, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps2, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type OwnProps = {|
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+    forMergeProps: number
+  |};
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render() {
+      return <div></div>;
+    }
+  }
+  // here in Props comes dispatch property
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {withRef: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: false, withRef: false})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {ref: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong key
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {wrongKey: true})(Com));
+}
+
+function testDispatch() {
+  type Props = { dispatch: empty => empty, ... }
+  class Com extends React.Component<Props> {
+    render() {
+      return <div></div>;
+    }
+  }
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+function testNoDispatch() {
+  type Props = {||}
+  class Com extends React.Component<Props> {
+    render() {
+      return <div></div>;
+    }
+  }
+  // $FlowExpectedError[prop-missing] property `dispatch` is missing in `Props`
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+
+function testHoistConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+}
+
+function itsOkToReturnMoreThanNeededPropsFromMapStateToProps() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2caseAgain() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    //$FlowExpectedError[incompatible-return] boolean [1] is incompatible with number [2]
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+  num: number, ... };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  //$FlowExpectedError[incompatible-type-arg] number [1] is incompatible with string [2] in property `str`
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Com);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testPassingDispatchPropWithoutDispatchFunction() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div />;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {...};
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {}
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testPassingDispatchTypeIsPassedThrough() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: string |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div />;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({});
+
+  // $FlowExpectedError[incompatible-type-arg] dispatch mismatched from type Dispatch
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectAdvanced.js
new file mode 100644
index 0000000000..f194896251
--- /dev/null
+++ b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectAdvanced.js
@@ -0,0 +1,128 @@
+// @flow
+import React from "react";
+import { connectAdvanced } from "react-redux";
+
+function testConnectAdvanced() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.fromInputProps} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const {
+      getDisplayName,
+      methodName,
+      renderCountProp,
+      shouldHandleStateChanges,
+      storeKey,
+      withRef,
+      displayName,
+      wrappedComponentName,
+    }: {
+      getDisplayName: (name: string) => string,
+      methodName: string,
+      renderCountProp: ?string,
+      shouldHandleStateChanges: boolean,
+      storeKey: string,
+      withRef: boolean,
+      displayName: string,
+      wrappedComponentName: string,
+      ...
+    } = selectorFactoryOptions;
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connectAdvanced(selectorFactory)('');
+}
+
+function testConnectAdvancedWithStatelessFunctionalComponent() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.fromInputProps} {props.fromStateToProps}</div>;
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+}
+
+function testConnectAdvancedConnectOptions() {
+  const selectorFactory = () => () => ({});
+  connectAdvanced(selectorFactory, {
+    getDisplayName: (name: string) => name + name,
+    methodName: 'methodName',
+    renderCountProp: 'renderCount',
+    shouldHandleStateChanges: false,
+    storeKey: 'storeKey',
+    withRef: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must take a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: number) => name + name});
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must return a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: string) => name.length});
+
+  //$FlowExpectedError[incompatible-call] methodName must be a string
+  connectAdvanced(selectorFactory, {methodName: 5});
+
+  //$FlowExpectedError[incompatible-call] renderCountProp must be a string
+  connectAdvanced(selectorFactory, {renderCountProp: 5});
+
+  //$FlowExpectedError[incompatible-call] shouldHandleStateChanges must be defined if passed in
+  connectAdvanced(selectorFactory, {shouldHandleStateChanges: null});
+
+  //$FlowExpectedError[incompatible-call] storeKey must be a string
+  connectAdvanced(selectorFactory, {storeKey: 5});
+
+  //$FlowExpectedError[incompatible-call] withRef must be defined if passed in
+  connectAdvanced(selectorFactory, {withRef: null});
+
+  connectAdvanced(selectorFactory, {otherOption: "other options are allowed"});
+}
+
+function testConnectAdvancedExtraOptions() {
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const { otherOption }: { otherOption: string, ... } = selectorFactoryOptions;
+    return () => ({});
+  }
+
+  connectAdvanced(selectorFactory, {otherOption: "other options typecheck too"});
+  connectAdvanced(selectorFactory, {otherOption: 5});
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectDispatch.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectDispatch.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectDispatch.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectHOC.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectHOC.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectHOC.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectHOC.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectInfer.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectInfer.js
new file mode 100644
index 0000000000..6c7b1f49b4
--- /dev/null
+++ b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectInfer.js
@@ -0,0 +1,588 @@
+/*
+  Keep here examples which still work without type parameters specified,
+  even if the current Flow verion still reports misleading errors.
+  This helps keep the usage of Flow amazing type inferent on the good level.
+*/
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  // Flow also erroneously complains about fromStateToProps
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  connect(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the wrong type for passthroug,
+  // giving passthrough a number fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type Props = {
+    passthrough: number,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected />;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  const Connected2 = connect(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // giving the `mapDispatchToProps` to connect above
+  // fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  const Connected3 = connect(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the wrong type of `dispatch1`,
+  // giving `num` the correct type fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] dispatch1 should be number
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234}/>;
+  // Here Flow reports that `forMapStateToProps` is missing from props,
+  // while the real error is still the missing `passthrough`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render() {
+      return <div></div>;
+    }
+  }
+  connect(null, null, null, {pure: true})(Com);
+  connect(null, null, null, {withRef: true})(Com);
+  connect(null, null, null, {pure: false, withRef: false})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {pure: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {ref: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong key
+  connect(null, null, null, {wrongKey: true})(Com);
+}
+
+function testHoistConnectedComponent() {
+  type Props = {
+    passthrough: number,
+    passthroughWithDefaultProp: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+  //$FlowExpectedError[incompatible-use] property `notStatic` is missing in statics
+  Connected.notStatic;
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return { // no error
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+
+
+function testAllowsKnownPropInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.str
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected />;
+}
+
+function testForbidsLiteralOfInvalidTypeInMapStateToProps() {
+  type Props = {
+  str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithLiteralOfInvalidType = (state: State) => {
+    return {
+      str: 123
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithLiteralOfInvalidType)(Com);
+  //$FlowExpectedError[incompatible-use] string is incompatible with number
+  <Connected />
+}
+
+function testForbidsStateProperyOfInvalidTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithStatePropertyOfInvalidType = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithStatePropertyOfInvalidType)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+function testForbidsSelectorWithInvalidReturnTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  function selectorReturningNumber(state: State) {
+    return state.num
+  }
+
+  const mapStateToPropsWithSelectorWithInvalidTypeReturnValue = (state: State) => {
+    return {
+      str: selectorReturningNumber(state)
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithSelectorWithInvalidTypeReturnValue)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectMergeProps.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectMergeProps.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectMergeProps.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectState.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectState.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectState.js
rename to definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectState.js
diff --git a/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectThunk.js b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectThunk.js
new file mode 100644
index 0000000000..ff43fd3550
--- /dev/null
+++ b/definitions/npm/react-redux_v5.x.x/flow_v0.201.x-/test_connectThunk.js
@@ -0,0 +1,199 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyDispatchFunction_samePropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Promise<number>,
+  |};
+  type MapDispatchToPropsFn = Dispatch => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch) => ({
+    action: () => dispatch(action()),
+    thunk: () => dispatch(thunk())
+  });
+
+  type Props = { // in the case of a function passed to `connect()` Flow infers
+  // the same type of function is both the Props and DispatchProps objects
+  // (see the testDispatchThunk() to get the difference)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_differentDispatchPropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = { // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[incompatible-type-arg] here the property returns a thunk...
+  //$FlowExpectedError[prop-missing]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_differentDispatchPropsAreOK() {
+  type State = {|
+    state1: 'state1'
+  |}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[incompatible-call] here the property returns a thunk...
+  //$FlowExpectedError[prop-missing]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/react-redux_v6.x.x.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/react-redux_v6.x.x.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/react-redux_v6.x.x.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/react-redux_v6.x.x.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_Provider.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_Provider.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_Provider.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_Provider.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connect.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connect.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connect.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connect.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectAdvanced.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectDispatch.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectDispatch.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
new file mode 100644
index 0000000000..1e7a3ac6f8
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
@@ -0,0 +1,171 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = [];
+
+function checkSimplePropertyInjection() {
+  type OwnProps = {
+    foo: number,
+    bar: string,
+    ...
+  };
+  type Props = {
+    ...OwnProps,
+    foo: number,
+    ...
+  };
+  const mapStateToProps = () => ({ foo: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, OwnProps, _, _, _, _>(mapStateToProps)(Com);
+
+  <Connected foo={42} bar="str" />;
+  //$FlowExpectedError[incompatible-use] property `foo` is missing in props [1] but exists in `OwnProps`
+  <Connected bar="str" />;
+  e.push(Connected);
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { foo: number | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { foo: number | void, ... }>,
+    ) {
+      return <Component {...props} foo={42} />;
+    };
+  }
+
+  const Decorated = injectProp(Connected);
+  // OK without `foo`
+  <Decorated bar="str" />;
+  // OK with a not needed `foo`
+  <Decorated foo={42} bar="str" />;
+  //$FlowExpectedError[prop-missing] property `bar` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_OK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  // OK with a not needed `injected1`
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_exactOK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [1] but exists in `OwnProps` [2]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_wrongOrder() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  // injectProp must go before connect()
+  const composedDecorators = compose(
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+    injectProp,
+  );
+
+  const Decorated = composedDecorators(Com);
+  //$FlowExpectedError[incompatible-use] property `injected1` is missing in props
+  <Decorated own1={1} />;
+  // OK with an explicitly provided `injected1`
+  <Decorated own1={1} injected1="str" />;
+  e.push(Decorated);
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectInfer.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectInfer.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
new file mode 100644
index 0000000000..472175cbf9
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
@@ -0,0 +1,608 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyOwnProps_ok() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_wrongDispatch() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_noPassthrough() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      a: 1
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    //$FlowExpectedError[prop-missing] property `passthrough` is missing in object literal [1] but exists in `OwnProps` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({state1: state.state1})
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(undefined, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_wrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: { wrong: boolean, ... }, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in object type [1] but exists in object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    undefined,
+    mapDispatchToProps,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_WrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  type MapDispatchToPropsFn = Dispatch => DispatchProps
+  const mapDispatchToPropsFn: MapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {|wrong:boolean|}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in  object type [1] but exists in  object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_wrongDispatchProp() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with  string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (
+    stateProps: {|wrong:boolean|},
+    dispatchProps: DispatchProps,
+    ownProps: OwnProps
+  ) => {
+    return {
+      ...ownProps,
+      state1: 'state1',
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    // yes, a bit cryptic
+    //$FlowExpectedError[prop-missing] property `state1` is missing in  object type [1] but exists in  object literal [2]
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentProps() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentPropsWithError() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    //$FlowExpectedError[prop-missing] property `c` is missing in object literal [1] but exists in  `Props` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectState.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectState.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectState.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectState.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectThunk.js b/definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
similarity index 100%
rename from definitions/npm/react-redux_v6.x.x/flow_v0.142.x-/test_connectThunk.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/react-redux_v6.x.x.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/react-redux_v6.x.x.js
new file mode 100644
index 0000000000..2fddef9231
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/react-redux_v6.x.x.js
@@ -0,0 +1,277 @@
+/**
+The order of type arguments for connect() is as follows:
+
+connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(…)
+
+In Flow v0.89 only the first two are mandatory to specify. Other 4 can be repaced with the new awesome type placeholder:
+
+connect<Props, OwnProps, _, _, _, _>(…)
+
+But beware, in case of weird type errors somewhere in random places
+just type everything and get to a green field and only then try to
+remove the definitions you see bogus.
+
+Decrypting the abbreviations:
+  WC = Component being wrapped
+  S = State
+  D = Dispatch
+  OP = OwnProps
+  SP = StateProps
+  DP = DispatchProps
+  MP = Merge props
+  RSP = Returned state props
+  RDP = Returned dispatch props
+  RMP = Returned merge props
+  CP = Props for returned component
+  Com = React Component
+  ST = Static properties of Com
+  EFO = Extra factory options (used only in connectAdvanced)
+*/
+
+declare module "react-redux" {
+  // ------------------------------------------------------------
+  // Typings for connect()
+  // ------------------------------------------------------------
+
+  declare export type Options<S, OP, SP, MP> = {|
+    pure?: boolean,
+    forwardRef?: boolean,
+    areStatesEqual?: (next: S, prev: S) => boolean,
+    areOwnPropsEqual?: (next: OP, prev: OP) => boolean,
+    areStatePropsEqual?: (next: SP, prev: SP) => boolean,
+    areMergedPropsEqual?: (next: MP, prev: MP) => boolean,
+    storeKey?: string,
+  |};
+
+  declare type MapStateToProps<-S, -OP, +SP> =
+    | ((state: S, ownProps: OP) => SP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (State, OwnProps) => (State, OwnProps) => StateProps
+    // and provide the StateProps type to the SP type parameter.
+    | ((state: S, ownProps: OP) => (state: S, ownProps: OP) => SP);
+
+  declare type Bind<D> = <A, R>((...A) => R) => (...A) => $Call<D, R>;
+
+  declare type MapDispatchToPropsFn<D, -OP, +DP> =
+    | ((dispatch: D, ownProps: OP) => DP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (Dispatch, OwnProps) => (Dispatch, OwnProps) => DispatchProps
+    // and provide the DispatchProps type to the DP type parameter.
+    | ((dispatch: D, ownProps: OP) => (dispatch: D, ownProps: OP) => DP);
+
+  declare class ConnectedComponent<OP, +WC> extends React$Component<OP> {
+    static +WrappedComponent: WC;
+    getWrappedInstance(): React$ElementRef<WC>;
+  }
+  // The connection of the Wrapped Component and the Connected Component
+  // happens here in `MP: P`. It means that type wise MP belongs to P,
+  // so to say MP >= P.
+  declare type Connector<P, OP, MP: P> = <WC: React$ComponentType<P>>(
+    WC,
+  ) => Class<ConnectedComponent<OP, WC>> & WC;
+
+  // No `mergeProps` argument
+
+  // Got error like inexact OwnProps is incompatible with exact object type?
+  // Just make the OP parameter for `connect()` an exact object.
+  declare type MergeOP<OP, D> = {| ...$Exact<OP>, dispatch: D |};
+  declare type MergeOPSP<OP, SP, D> = {| ...$Exact<OP>, ...SP, dispatch: D |};
+  declare type MergeOPDP<OP, DP> = {| ...$Exact<OP>, ...DP |};
+  declare type MergeOPSPDP<OP, SP, DP> = {| ...$Exact<OP>, ...SP, ...DP |};
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    mapStateToProps?: null | void,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOP<OP, D>>,
+  ): Connector<P, OP, MergeOP<OP, D>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSP<OP, SP, D>>,
+  ): Connector<P, OP, MergeOPSP<OP, SP, D>>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, DP>>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, $ObjMap<DP, Bind<D>>>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+  ): Connector<P, OP, {| ...OP, ...SP, ...DP |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSPDP<OP, SP, DP>>,
+  ): Connector<P, OP, MergeOPSPDP<OP, SP, $ObjMap<DP, Bind<D>>>>;
+
+  // With `mergeProps` argument
+
+  declare type MergeProps<+P, -OP, -SP, -DP> = (
+    stateProps: SP,
+    dispatchProps: DP,
+    ownProps: OP,
+  ) => P;
+
+  declare export function connect<-P, -OP, -SP: {||}, -DP: {||}, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, {||}, {| dispatch: D |}>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  declare export function connect<-P, -OP, -SP, -DP: {||}, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, SP, {| dispatch: D |}>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, {||}, DP>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, {||}, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, SP, DP>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, SP, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // ------------------------------------------------------------
+  // Typings for Provider
+  // ------------------------------------------------------------
+
+  declare export class Provider<Store> extends React$Component<{
+    store: Store,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export function createProvider(
+    storeKey?: string,
+    subKey?: string,
+  ): Class<Provider<any>>;
+
+  // ------------------------------------------------------------
+  // Typings for connectAdvanced()
+  // ------------------------------------------------------------
+
+  declare type ConnectAdvancedOptions = {
+    getDisplayName?: (name: string) => string,
+    methodName?: string,
+    renderCountProp?: string,
+    shouldHandleStateChanges?: boolean,
+    storeKey?: string,
+    forwardRef?: boolean,
+    ...
+  };
+
+  declare type SelectorFactoryOptions<Com> = {
+    getDisplayName: (name: string) => string,
+    methodName: string,
+    renderCountProp: ?string,
+    shouldHandleStateChanges: boolean,
+    storeKey: string,
+    forwardRef: boolean,
+    displayName: string,
+    wrappedComponentName: string,
+    WrappedComponent: Com,
+    ...
+  };
+
+  declare type MapStateToPropsEx<S: Object, SP: Object, RSP: Object> = (
+    state: S,
+    props: SP,
+  ) => RSP;
+
+  declare type SelectorFactory<
+    Com: React$ComponentType<any>,
+    Dispatch,
+    S: Object,
+    OP: Object,
+    EFO: Object,
+    CP: Object,
+  > = (
+    dispatch: Dispatch,
+    factoryOptions: SelectorFactoryOptions<Com> & EFO,
+  ) => MapStateToPropsEx<S, OP, CP>;
+
+  declare export function connectAdvanced<
+    Com: React$ComponentType<any>,
+    D,
+    S: Object,
+    OP: Object,
+    CP: Object,
+    EFO: Object,
+    ST: { [_: $Keys<Com>]: any, ... },
+  >(
+    selectorFactory: SelectorFactory<Com, D, S, OP, EFO, CP>,
+    connectAdvancedOptions: ?(ConnectAdvancedOptions & EFO),
+  ): (component: Com) => React$ComponentType<OP> & $Shape<ST>;
+
+  declare export default {
+    Provider: typeof Provider,
+    createProvider: typeof createProvider,
+    connect: typeof connect,
+    connectAdvanced: typeof connectAdvanced,
+    ...
+  };
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_Provider.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_Provider.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_Provider.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_Provider.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connect.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connect.js
new file mode 100644
index 0000000000..4ffd5cbc7b
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connect.js
@@ -0,0 +1,779 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck1case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2case() {
+  type Props = { numProp: string, ... };
+
+  const Component = ({ numProp }: Props) => {
+    return <span>{numProp}</span>;
+  };
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for numProp
+  const Connected = connect<Props, {||}, _,_,_,_>(null, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck3case() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck4case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, {})(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testExactProps() {
+  type Dispatch = () => void;
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {|
+    ...OwnProps,
+    fromStateToProps: string,
+    dispatch: Dispatch,
+  |};
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {|
+    forMapStateToProps: string,
+    passthrough: number,
+  |};
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testInexactOwnProps() {
+  type OwnProps = {
+    passthrough: number,
+    forMapStateToProps: string,
+    ...
+  };
+  type Props = {
+    // to eliminate the cripy `undefined`
+    ...$Exact<OwnProps>,
+    fromStateToProps: string,
+    ...
+  };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {
+    forMapStateToProps: string,
+    passthrough: number,
+    ...
+  };
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsDoesNotPassDispatch() {
+  type Dispatch = () => void;
+  type OwnProps = {||};
+  type Props = {| ...OwnProps, fromMapDispatchToProps: string, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.fromMapDispatchToProps}</div>;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({})
+  const mapDispatchToProps = (dispatch: any, ownProps: any) => {
+    return {fromMapDispatchToProps: 'yo'}
+  }
+  // $FlowExpectedError[prop-missing] dispatch should not be provided in Props when mapDispatchToProps is present
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type OwnProps = {|
+    passthrough: number,
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  //$FlowExpectedError[invalid-obj-map] dispatch1 should be number
+  const Connected3 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  e.push(Connected3);
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type OwnProps1 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMergeProps: number
+  |};
+  type OwnProps2 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect<Props, OwnProps1, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps2, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type OwnProps = {|
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+    forMergeProps: number
+  |};
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render() {
+      return <div></div>;
+    }
+  }
+  // here in Props comes dispatch property
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {forwardRef: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: false, forwardRef: false})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {ref: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong key
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {wrongKey: true})(Com));
+}
+
+function testDispatch() {
+  type Props = { dispatch: empty => empty, ... }
+  class Com extends React.Component<Props> {
+    render() {
+      return <div></div>;
+    }
+  }
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+function testNoDispatch() {
+  type Props = {||}
+  class Com extends React.Component<Props> {
+    render() {
+      return <div></div>;
+    }
+  }
+  // $FlowExpectedError[prop-missing] property `dispatch` is missing in `Props`
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+
+function testHoistConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+}
+
+function itsOkToReturnMoreThanNeededPropsFromMapStateToProps() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2caseAgain() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    //$FlowExpectedError[incompatible-return] boolean [1] is incompatible with number [2]
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+  num: number, ... };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  //$FlowExpectedError[incompatible-type-arg] number [1] is incompatible with string [2] in property `str`
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Com);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testPassingDispatchPropWithoutDispatchFunction() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div />;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {...};
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {}
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testPassingDispatchTypeIsPassedThrough() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: string |};
+  class Com extends React.Component<Props> {
+    render() {
+      return <div />;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({});
+
+  // $FlowExpectedError[incompatible-type-arg] dispatch mismatched from type Dispatch
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectAdvanced.js
new file mode 100644
index 0000000000..ccf54cdf1b
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectAdvanced.js
@@ -0,0 +1,128 @@
+// @flow
+import React from "react";
+import { connectAdvanced } from "react-redux";
+
+function testConnectAdvanced() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.fromInputProps} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const {
+      getDisplayName,
+      methodName,
+      renderCountProp,
+      shouldHandleStateChanges,
+      storeKey,
+      forwardRef,
+      displayName,
+      wrappedComponentName,
+    }: {
+      getDisplayName: (name: string) => string,
+      methodName: string,
+      renderCountProp: ?string,
+      shouldHandleStateChanges: boolean,
+      storeKey: string,
+      forwardRef: boolean,
+      displayName: string,
+      wrappedComponentName: string,
+      ...
+    } = selectorFactoryOptions;
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connectAdvanced(selectorFactory)('');
+}
+
+function testConnectAdvancedWithStatelessFunctionalComponent() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.fromInputProps} {props.fromStateToProps}</div>;
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+}
+
+function testConnectAdvancedConnectOptions() {
+  const selectorFactory = () => () => ({});
+  connectAdvanced(selectorFactory, {
+    getDisplayName: (name: string) => name + name,
+    methodName: 'methodName',
+    renderCountProp: 'renderCount',
+    shouldHandleStateChanges: false,
+    storeKey: 'storeKey',
+    forwardRef: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must take a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: number) => name + name});
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must return a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: string) => name.length});
+
+  //$FlowExpectedError[incompatible-call] methodName must be a string
+  connectAdvanced(selectorFactory, {methodName: 5});
+
+  //$FlowExpectedError[incompatible-call] renderCountProp must be a string
+  connectAdvanced(selectorFactory, {renderCountProp: 5});
+
+  //$FlowExpectedError[incompatible-call] shouldHandleStateChanges must be defined if passed in
+  connectAdvanced(selectorFactory, {shouldHandleStateChanges: null});
+
+  //$FlowExpectedError[incompatible-call] storeKey must be a string
+  connectAdvanced(selectorFactory, {storeKey: 5});
+
+  //$FlowExpectedError[incompatible-call] forwardRef must be defined if passed in
+  connectAdvanced(selectorFactory, {forwardRef: null});
+
+  connectAdvanced(selectorFactory, {otherOption: "other options are allowed"});
+}
+
+function testConnectAdvancedExtraOptions() {
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const { otherOption }: { otherOption: string, ... } = selectorFactoryOptions;
+    return () => ({});
+  }
+
+  connectAdvanced(selectorFactory, {otherOption: "other options typecheck too"});
+  connectAdvanced(selectorFactory, {otherOption: 5});
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectDispatch.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectDispatch.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectDispatch.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectHOC.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectHOC.js
new file mode 100644
index 0000000000..1e7a3ac6f8
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectHOC.js
@@ -0,0 +1,171 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = [];
+
+function checkSimplePropertyInjection() {
+  type OwnProps = {
+    foo: number,
+    bar: string,
+    ...
+  };
+  type Props = {
+    ...OwnProps,
+    foo: number,
+    ...
+  };
+  const mapStateToProps = () => ({ foo: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, OwnProps, _, _, _, _>(mapStateToProps)(Com);
+
+  <Connected foo={42} bar="str" />;
+  //$FlowExpectedError[incompatible-use] property `foo` is missing in props [1] but exists in `OwnProps`
+  <Connected bar="str" />;
+  e.push(Connected);
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { foo: number | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { foo: number | void, ... }>,
+    ) {
+      return <Component {...props} foo={42} />;
+    };
+  }
+
+  const Decorated = injectProp(Connected);
+  // OK without `foo`
+  <Decorated bar="str" />;
+  // OK with a not needed `foo`
+  <Decorated foo={42} bar="str" />;
+  //$FlowExpectedError[prop-missing] property `bar` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_OK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  // OK with a not needed `injected1`
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_exactOK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [1] but exists in `OwnProps` [2]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_wrongOrder() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  // injectProp must go before connect()
+  const composedDecorators = compose(
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+    injectProp,
+  );
+
+  const Decorated = composedDecorators(Com);
+  //$FlowExpectedError[incompatible-use] property `injected1` is missing in props
+  <Decorated own1={1} />;
+  // OK with an explicitly provided `injected1`
+  <Decorated own1={1} injected1="str" />;
+  e.push(Decorated);
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectInfer.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectInfer.js
new file mode 100644
index 0000000000..c3817f895f
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectInfer.js
@@ -0,0 +1,588 @@
+/*
+  Keep here examples which still work without type parameters specified,
+  even if the current Flow verion still reports misleading errors.
+  This helps keep the usage of Flow amazing type inferent on the good level.
+*/
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  // Flow also erroneously complains about fromStateToProps
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  connect(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the wrong type for passthroug,
+  // giving passthrough a number fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type Props = {
+    passthrough: number,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected />;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  const Connected2 = connect(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // giving the `mapDispatchToProps` to connect above
+  // fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  const Connected3 = connect(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the wrong type of `dispatch1`,
+  // giving `num` the correct type fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] dispatch1 should be number
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234}/>;
+  // Here Flow reports that `forMapStateToProps` is missing from props,
+  // while the real error is still the missing `passthrough`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps, dispatchProps, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render() {
+      return <div></div>;
+    }
+  }
+  connect(null, null, null, {pure: true})(Com);
+  connect(null, null, null, {forwardRef: true})(Com);
+  connect(null, null, null, {pure: false, forwardRef: false})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {pure: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {ref: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong key
+  connect(null, null, null, {wrongKey: true})(Com);
+}
+
+function testHoistConnectedComponent() {
+  type Props = {
+    passthrough: number,
+    passthroughWithDefaultProp: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render() {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+  //$FlowExpectedError[incompatible-use] property `notStatic` is missing in statics
+  Connected.notStatic;
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return { // no error
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+
+
+function testAllowsKnownPropInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.str
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected />;
+}
+
+function testForbidsLiteralOfInvalidTypeInMapStateToProps() {
+  type Props = {
+  str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithLiteralOfInvalidType = (state: State) => {
+    return {
+      str: 123
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithLiteralOfInvalidType)(Com);
+  //$FlowExpectedError[incompatible-use] string is incompatible with number
+  <Connected />
+}
+
+function testForbidsStateProperyOfInvalidTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithStatePropertyOfInvalidType = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithStatePropertyOfInvalidType)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+function testForbidsSelectorWithInvalidReturnTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render() {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  function selectorReturningNumber(state: State) {
+    return state.num
+  }
+
+  const mapStateToPropsWithSelectorWithInvalidTypeReturnValue = (state: State) => {
+    return {
+      str: selectorReturningNumber(state)
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithSelectorWithInvalidTypeReturnValue)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />
+}
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectMergeProps.js
new file mode 100644
index 0000000000..472175cbf9
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectMergeProps.js
@@ -0,0 +1,608 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyOwnProps_ok() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_wrongDispatch() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_noPassthrough() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      a: 1
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    //$FlowExpectedError[prop-missing] property `passthrough` is missing in object literal [1] but exists in `OwnProps` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({state1: state.state1})
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(undefined, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_wrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: { wrong: boolean, ... }, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in object type [1] but exists in object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    undefined,
+    mapDispatchToProps,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_WrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  type MapDispatchToPropsFn = Dispatch => DispatchProps
+  const mapDispatchToPropsFn: MapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {|wrong:boolean|}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in  object type [1] but exists in  object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_wrongDispatchProp() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with  string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (
+    stateProps: {|wrong:boolean|},
+    dispatchProps: DispatchProps,
+    ownProps: OwnProps
+  ) => {
+    return {
+      ...ownProps,
+      state1: 'state1',
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    // yes, a bit cryptic
+    //$FlowExpectedError[prop-missing] property `state1` is missing in  object type [1] but exists in  object literal [2]
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentProps() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentPropsWithError() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    //$FlowExpectedError[prop-missing] property `c` is missing in object literal [1] but exists in  `Props` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectState.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectState.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectState.js
rename to definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectState.js
diff --git a/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectThunk.js b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectThunk.js
new file mode 100644
index 0000000000..1d096d2fb0
--- /dev/null
+++ b/definitions/npm/react-redux_v6.x.x/flow_v0.201.x-/test_connectThunk.js
@@ -0,0 +1,199 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyDispatchFunction_samePropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Promise<number>,
+  |};
+  type MapDispatchToPropsFn = Dispatch => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch) => ({
+    action: () => dispatch(action()),
+    thunk: () => dispatch(thunk())
+  });
+
+  type Props = { // in the case of a function passed to `connect()` Flow infers
+  // the same type of function is both the Props and DispatchProps objects
+  // (see the testDispatchThunk() to get the difference)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_differentDispatchPropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = { // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-type-arg]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_differentDispatchPropsAreOK() {
+  type State = {|
+    state1: 'state1'
+  |}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = state => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-call]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/react-redux_v7.x.x.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/react-redux_v7.x.x.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/react-redux_v7.x.x.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/react-redux_v7.x.x.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_Provider.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_Provider.js
new file mode 100644
index 0000000000..381e042bc4
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_Provider.js
@@ -0,0 +1,55 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+
+import React from "react";
+import { Provider, createProvider } from "react-redux";
+
+describe('Provider', () => {
+  it('should give an error when the store is missing', () => {
+    // $FlowExpectedError[prop-missing]
+    <Provider />;
+
+    // Also for custom providers
+    const CustomProvider: Class<Provider<any>> = createProvider("ikea");
+
+    // $FlowExpectedError[prop-missing]
+    <CustomProvider />;
+  });
+});
+
+describe('Custom Store (eg for ThunkActions)', () => {
+
+  // This represents a common typing for Thunk Actions.
+
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  // R = Result of a thunk action
+  type ThunkDispatch = <R>(action: ThunkAction<R>) => R;
+  type PlainDispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type ThunkAction<R> = (dispatch: Dispatch, GetState) => R;
+  // The `dispatch` function can accept either a plain action or a thunk action.
+  // This is similar to a type `(action: Action | ThunkAction) => any` except this
+  // allows to type the return value as well.
+  type Dispatch = PlainDispatch & ThunkDispatch;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('accepts a custom store', () => {
+    declare var store: Store;
+    <Provider store={store} />;
+  });
+});
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_batch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_batch.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_batch.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_batch.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connect.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connect.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connect.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connect.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectAdvanced.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectAdvanced.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
new file mode 100644
index 0000000000..ab8707645a
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
@@ -0,0 +1,105 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function object_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function object_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[invalid-obj-map] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,_,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
+
+function function_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function function_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[incompatible-call] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,DispatchProps,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectHOC.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectHOC.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectInfer.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectInfer.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectMergeProps.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectState.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectState.js
new file mode 100644
index 0000000000..c222ba4960
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectState.js
@@ -0,0 +1,41 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function sameStateIsOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+
+  const Connected = connect<Props, {||}, _,_,State,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function differentStatesAreNotOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+  type OtherState = {|
+    b: number
+  |};
+
+  //$FlowExpectedError[incompatible-call] property `b` is missing in `State` but exists in `OtherState`
+  const Connected = connect<Props, {||}, _,_,OtherState,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectThunk.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_connectThunk.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_shallowEqual.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_shallowEqual.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_shallowEqual.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_shallowEqual.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useDispatch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useDispatch.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useDispatch.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useSelector.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useSelector.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useSelector.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useSelector.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useStore.js b/definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useStore.js
similarity index 100%
rename from definitions/npm/react-redux_v7.x.x/flow_v0.142.x-/test_useStore.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.142.x-v.200.x/test_useStore.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/react-redux_v7.x.x.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/react-redux_v7.x.x.js
new file mode 100644
index 0000000000..5d890d1c2c
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/react-redux_v7.x.x.js
@@ -0,0 +1,332 @@
+/**
+The order of type arguments for connect() is as follows:
+
+connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(…)
+
+In Flow v0.89 only the first two are mandatory to specify. Other 4 can be repaced with the new awesome type placeholder:
+
+connect<Props, OwnProps, _, _, _, _>(…)
+
+But beware, in case of weird type errors somewhere in random places
+just type everything and get to a green field and only then try to
+remove the definitions you see bogus.
+
+Decrypting the abbreviations:
+  WC = Component being wrapped
+  S = State
+  D = Dispatch
+  OP = OwnProps
+  SP = StateProps
+  DP = DispatchProps
+  MP = Merge props
+  RSP = Returned state props
+  RDP = Returned dispatch props
+  RMP = Returned merge props
+  CP = Props for returned component
+  Com = React Component
+  SS = Selected state
+  ST = Static properties of Com
+  EFO = Extra factory options (used only in connectAdvanced)
+*/
+
+declare module "react-redux" {
+  // ------------------------------------------------------------
+  // Typings for connect()
+  // ------------------------------------------------------------
+
+  declare export type Options<S, OP, SP, MP> = {|
+    pure?: boolean,
+    forwardRef?: boolean,
+    areStatesEqual?: (next: S, prev: S) => boolean,
+    areOwnPropsEqual?: (next: OP, prev: OP) => boolean,
+    areStatePropsEqual?: (next: SP, prev: SP) => boolean,
+    areMergedPropsEqual?: (next: MP, prev: MP) => boolean,
+    storeKey?: string,
+  |};
+
+  declare type MapStateToProps<-S, -OP, +SP> =
+    | ((state: S, ownProps: OP) => SP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (State, OwnProps) => (State, OwnProps) => StateProps
+    // and provide the StateProps type to the SP type parameter.
+    | ((state: S, ownProps: OP) => (state: S, ownProps: OP) => SP);
+
+  declare type Bind<D> = <A, R>((...A) => R) => (...A) => $Call<D, R>;
+
+  declare type MapDispatchToPropsFn<D, -OP, +DP> =
+    | ((dispatch: D, ownProps: OP) => DP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (Dispatch, OwnProps) => (Dispatch, OwnProps) => DispatchProps
+    // and provide the DispatchProps type to the DP type parameter.
+    | ((dispatch: D, ownProps: OP) => (dispatch: D, ownProps: OP) => DP);
+
+  declare class ConnectedComponentClass<OP, +WC> extends React$Component<OP> {
+    static +WrappedComponent: WC;
+    getWrappedInstance(): React$ElementRef<WC>;
+  }
+
+  declare export type ConnectedComponent<OP, +WC> = ConnectedComponentClass<OP, WC>;
+
+  // The connection of the Wrapped Component and the Connected Component
+  // happens here in `MP: P`. It means that type wise MP belongs to P,
+  // so to say MP >= P.
+  declare type Connector<P, OP, MP: P> = <WC: React$ComponentType<P>>(
+    WC,
+  ) => Class<ConnectedComponentClass<OP, WC>> & WC;
+
+  // No `mergeProps` argument
+
+  // Got error like inexact OwnProps is incompatible with exact object type?
+  // Just make the OP parameter for `connect()` an exact object.
+  declare type MergeOP<OP, D> = {| ...$Exact<OP>, dispatch: D |};
+  declare type MergeOPSP<OP, SP, D> = {| ...$Exact<OP>, ...SP, dispatch: D |};
+  declare type MergeOPDP<OP, DP> = {| ...$Exact<OP>, ...DP |};
+  declare type MergeOPSPDP<OP, SP, DP> = {| ...$Exact<OP>, ...SP, ...DP |};
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    mapStateToProps?: null | void,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOP<OP, D>>,
+  ): Connector<P, OP, MergeOP<OP, D>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSP<OP, SP, D>>,
+  ): Connector<P, OP, MergeOPSP<OP, SP, D>>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, DP>>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, $ObjMap<DP, Bind<D>>>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+  ): Connector<P, OP, {| ...OP, ...SP, ...DP |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSPDP<OP, SP, DP>>,
+  ): Connector<P, OP, MergeOPSPDP<OP, SP, $ObjMap<DP, Bind<D>>>>;
+
+  // With `mergeProps` argument
+
+  declare type MergeProps<+P, -OP, -SP, -DP> = (
+    stateProps: SP,
+    dispatchProps: DP,
+    ownProps: OP,
+  ) => P;
+
+  declare export function connect<-P, -OP, -SP: {||}, -DP: {||}, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, {||}, {| dispatch: D |}>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  declare export function connect<-P, -OP, -SP, -DP: {||}, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, SP, {| dispatch: D |}>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, {||}, DP>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, {||}, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, SP, DP>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, SP, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // ------------------------------------------------------------
+  // Typings for Hooks
+  // ------------------------------------------------------------
+
+  /* Action and AnyAction are taken from the redux TypeScript types defined here:
+   * https://github.com/reduxjs/redux/blob/d794c56f78eccb56ba3c67971c26df8ee34dacc1/src/types/actions.ts
+   *
+   * We turn them into objects so that they can be spread.
+   *
+   * We use AnyAction as the default for useDispatch as DefinitelyTyped does:
+   * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/f7ec78508c6797e42f87a4390735bc2c650a1bfd/types/react-redux/index.d.ts#L540
+   */
+  declare export type Action<T> = {
+    type: T,
+    ...
+  }
+
+  declare export type AnyAction = {
+    ...Action<any>,
+    [string]: any
+  }
+
+  declare export type Dispatch<-A: Action<any>> = (action: A, ...extraArgs: any[]) => mixed
+
+  // Since A is contravariant in Dispatch, empty is a reasonable bound here. This is equivalent
+  // to using mixed as a default in a read-only position.
+  declare export function useDispatch<D: Dispatch<empty> = Dispatch<AnyAction>>(): (
+    & (<T: { [key: string]: any }>(T) => T)
+    // Supports thunks at their various lengths and use cases depending if user has typed them as tuple vs array
+    & (<T>((...args: [any]) => T) => T)
+    & (<T>((...args: [any, any]) => T) => T)
+    & (<T>((...args: [any, any, any]) => T) => T)
+    & (<T>((...args: Array<any>) => T) => T)
+    & D
+  );
+
+  declare export function useSelector<S, SS>(
+    selector: (state: S) => SS,
+    equalityFn?: (a: SS, b: SS) => boolean,
+  ): SS;
+
+  declare export function useStore<Store>(): Store;
+
+  // ------------------------------------------------------------
+  // Typings for Provider
+  // ------------------------------------------------------------
+
+  declare export class Provider<Store> extends React$Component<{
+    store: Store,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export function createProvider(
+    storeKey?: string,
+    subKey?: string,
+  ): Class<Provider<any>>;
+
+  // ------------------------------------------------------------
+  // Typings for connectAdvanced()
+  // ------------------------------------------------------------
+
+  declare type ConnectAdvancedOptions = {
+    getDisplayName?: (name: string) => string,
+    methodName?: string,
+    renderCountProp?: string,
+    shouldHandleStateChanges?: boolean,
+    storeKey?: string,
+    forwardRef?: boolean,
+    ...
+  };
+
+  declare type SelectorFactoryOptions<Com> = {
+    getDisplayName: (name: string) => string,
+    methodName: string,
+    renderCountProp: ?string,
+    shouldHandleStateChanges: boolean,
+    storeKey: string,
+    forwardRef: boolean,
+    displayName: string,
+    wrappedComponentName: string,
+    WrappedComponent: Com,
+    ...
+  };
+
+  declare type MapStateToPropsEx<S: Object, SP: Object, RSP: Object> = (
+    state: S,
+    props: SP,
+  ) => RSP;
+
+  declare type SelectorFactory<
+    Com: React$ComponentType<any>,
+    Dispatch,
+    S: Object,
+    OP: Object,
+    EFO: Object,
+    CP: Object,
+  > = (
+    dispatch: Dispatch,
+    factoryOptions: SelectorFactoryOptions<Com> & EFO,
+  ) => MapStateToPropsEx<S, OP, CP>;
+
+  declare export function connectAdvanced<
+    Com: React$ComponentType<any>,
+    D,
+    S: Object,
+    OP: Object,
+    CP: Object,
+    EFO: Object,
+    ST: { [_: $Keys<Com>]: any, ... },
+  >(
+    selectorFactory: SelectorFactory<Com, D, S, OP, EFO, CP>,
+    connectAdvancedOptions: ?(ConnectAdvancedOptions & EFO),
+  ): (component: Com) => React$ComponentType<OP> & $Shape<ST>;
+
+  declare export function batch(() => void): void
+
+  declare export function shallowEqual<T>(left: T, right: any): boolean
+
+  declare export default {
+    Provider: typeof Provider,
+    createProvider: typeof createProvider,
+    connect: typeof connect,
+    connectAdvanced: typeof connectAdvanced,
+    useDispatch: typeof useDispatch,
+    useSelector: typeof useSelector,
+    useStore: typeof useStore,
+    batch: typeof batch,
+    ...
+  };
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_Provider.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_Provider.js
new file mode 100644
index 0000000000..381e042bc4
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_Provider.js
@@ -0,0 +1,55 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+
+import React from "react";
+import { Provider, createProvider } from "react-redux";
+
+describe('Provider', () => {
+  it('should give an error when the store is missing', () => {
+    // $FlowExpectedError[prop-missing]
+    <Provider />;
+
+    // Also for custom providers
+    const CustomProvider: Class<Provider<any>> = createProvider("ikea");
+
+    // $FlowExpectedError[prop-missing]
+    <CustomProvider />;
+  });
+});
+
+describe('Custom Store (eg for ThunkActions)', () => {
+
+  // This represents a common typing for Thunk Actions.
+
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  // R = Result of a thunk action
+  type ThunkDispatch = <R>(action: ThunkAction<R>) => R;
+  type PlainDispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type ThunkAction<R> = (dispatch: Dispatch, GetState) => R;
+  // The `dispatch` function can accept either a plain action or a thunk action.
+  // This is similar to a type `(action: Action | ThunkAction) => any` except this
+  // allows to type the return value as well.
+  type Dispatch = PlainDispatch & ThunkDispatch;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('accepts a custom store', () => {
+    declare var store: Store;
+    <Provider store={store} />;
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_batch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_batch.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_batch.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_batch.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connect.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connect.js
new file mode 100644
index 0000000000..fba293f984
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connect.js
@@ -0,0 +1,823 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+import type { ConnectedComponent } from "react-redux";
+
+export let e: Array<any> = []
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck1case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2case() {
+  type Props = { numProp: string, ... };
+
+  const Component = ({ numProp }: Props) => {
+    return <span>{numProp}</span>;
+  };
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for numProp
+  const Connected = connect<Props, {||}, _,_,_,_>(null, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck3case() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck4case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, {})(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testExactProps() {
+  type Dispatch = () => void;
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {|
+    ...OwnProps,
+    fromStateToProps: string,
+    dispatch: Dispatch,
+  |};
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {|
+    forMapStateToProps: string,
+    passthrough: number,
+  |};
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testInexactOwnProps() {
+  type OwnProps = {
+    passthrough: number,
+    forMapStateToProps: string,
+    ...
+  };
+  type Props = {
+    // to eliminate the cripy `undefined`
+    ...$Exact<OwnProps>,
+    fromStateToProps: string,
+    ...
+  };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {
+    forMapStateToProps: string,
+    passthrough: number,
+    ...
+  };
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsDoesNotPassDispatch() {
+  type Dispatch = () => void;
+  type OwnProps = {||};
+  type Props = {| ...OwnProps, fromMapDispatchToProps: string, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.fromMapDispatchToProps}</div>;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({})
+  const mapDispatchToProps = (dispatch: any, ownProps: any) => {
+    return {fromMapDispatchToProps: 'yo'}
+  }
+  // $FlowExpectedError[prop-missing] dispatch should not be provided in Props when mapDispatchToProps is present
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type OwnProps = {|
+    passthrough: number,
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  //$FlowExpectedError[invalid-obj-map] dispatch1 should be number
+  const Connected3 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  e.push(Connected3);
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type OwnProps1 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMergeProps: number
+  |};
+  type OwnProps2 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (
+    stateProps: { ... },
+    dispatchProps: { ... },
+    ownProps: { forMergeProps: number, ... },
+  ) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect<Props, OwnProps1, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps2, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type OwnProps = {|
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+    forMergeProps: number
+  |};
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  // here in Props comes dispatch property
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {forwardRef: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: false, forwardRef: false})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {pure: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {ref: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong key
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {wrongKey: true})(Com));
+}
+
+function testDispatch() {
+  type Props = { dispatch: empty => empty, ... }
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+function testNoDispatch() {
+  type Props = {||}
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  // $FlowExpectedError[prop-missing] property `dispatch` is missing in `Props`
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+
+function testHoistConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+}
+
+function itsOkToReturnMoreThanNeededPropsFromMapStateToProps() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2caseAgain() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    //$FlowExpectedError[incompatible-return] boolean [1] is incompatible with number [2]
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+  num: number, ... };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  //$FlowExpectedError[incompatible-type-arg] number [1] is incompatible with string [2] in property `str`
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Com);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testPassingDispatchPropWithoutDispatchFunction() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div />;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {...};
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {}
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testPassingDispatchTypeIsPassedThrough() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: string |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div />;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({});
+
+  // $FlowExpectedError[incompatible-type-arg] dispatch mismatched from type Dispatch
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testNestedComponent() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    fromDispatchToProps: string,
+    ...
+  };
+
+  const Component = ({ passthrough, fromStateToProps, fromDispatchToProps }: Props) => {
+    return <span>{`${passthrough}: ${fromStateToProps}, ${fromDispatchToProps}`}</span>;
+  };
+
+  const Wrapper = ({ children }: { children: React$Element<any>, ... }) => {
+    return <span>{children}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    fromStateToProps: '',
+  });
+
+  const mapDispatchToProps = () => ({
+    fromDispatchToProps: '',
+  });
+
+  const Connected = (connect<Props, OwnProps, _, _, _, _>(
+    mapStateToProps,
+    mapDispatchToProps
+  )(Component): Class<ConnectedComponent<OwnProps, typeof Component>>);
+
+  return (
+    <Wrapper>
+      <Connected passthrough={2} />
+    </Wrapper>
+  );
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectAdvanced.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectAdvanced.js
new file mode 100644
index 0000000000..0339d541d3
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectAdvanced.js
@@ -0,0 +1,128 @@
+// @flow
+import * as React from "react";
+import { connectAdvanced } from "react-redux";
+
+function testConnectAdvanced() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.fromInputProps} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const {
+      getDisplayName,
+      methodName,
+      renderCountProp,
+      shouldHandleStateChanges,
+      storeKey,
+      forwardRef,
+      displayName,
+      wrappedComponentName,
+    }: {
+      getDisplayName: (name: string) => string,
+      methodName: string,
+      renderCountProp: ?string,
+      shouldHandleStateChanges: boolean,
+      storeKey: string,
+      forwardRef: boolean,
+      displayName: string,
+      wrappedComponentName: string,
+      ...
+    } = selectorFactoryOptions;
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connectAdvanced(selectorFactory)('');
+}
+
+function testConnectAdvancedWithStatelessFunctionalComponent() {
+  type Props = {
+    fromStateToProps: string,
+    fromInputProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.fromInputProps} {props.fromStateToProps}</div>;
+
+  type State = { a: number, ... };
+  type InputProps = { fromInputProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromInputProps: 'str' + props.fromInputProps,
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    return mapStateToProps;
+  }
+
+  const Connected = connectAdvanced(selectorFactory)(Com);
+  <Connected fromInputProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] expects props to match second argument of mapStateToProps
+  <Connected fromInputProps={123}/>;
+}
+
+function testConnectAdvancedConnectOptions() {
+  const selectorFactory = () => () => ({});
+  connectAdvanced(selectorFactory, {
+    getDisplayName: (name: string) => name + name,
+    methodName: 'methodName',
+    renderCountProp: 'renderCount',
+    shouldHandleStateChanges: false,
+    storeKey: 'storeKey',
+    forwardRef: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must take a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: number) => name + name});
+
+  //$FlowExpectedError[incompatible-call] getDisplayName must return a string
+  connectAdvanced(selectorFactory, {getDisplayName: (name: string) => name.length});
+
+  //$FlowExpectedError[incompatible-call] methodName must be a string
+  connectAdvanced(selectorFactory, {methodName: 5});
+
+  //$FlowExpectedError[incompatible-call] renderCountProp must be a string
+  connectAdvanced(selectorFactory, {renderCountProp: 5});
+
+  //$FlowExpectedError[incompatible-call] shouldHandleStateChanges must be defined if passed in
+  connectAdvanced(selectorFactory, {shouldHandleStateChanges: null});
+
+  //$FlowExpectedError[incompatible-call] storeKey must be a string
+  connectAdvanced(selectorFactory, {storeKey: 5});
+
+  //$FlowExpectedError[incompatible-call] forwardRef must be defined if passed in
+  connectAdvanced(selectorFactory, {forwardRef: null});
+
+  connectAdvanced(selectorFactory, {otherOption: "other options are allowed"});
+}
+
+function testConnectAdvancedExtraOptions() {
+  const selectorFactory = (dispatch: any, selectorFactoryOptions: any) => {
+    const { otherOption }: { otherOption: string, ... } = selectorFactoryOptions;
+    return () => ({});
+  }
+
+  connectAdvanced(selectorFactory, {otherOption: "other options typecheck too"});
+  connectAdvanced(selectorFactory, {otherOption: 5});
+}
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectDispatch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectDispatch.js
new file mode 100644
index 0000000000..ab8707645a
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectDispatch.js
@@ -0,0 +1,105 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function object_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function object_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[invalid-obj-map] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,_,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
+
+function function_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function function_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[incompatible-call] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,DispatchProps,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectHOC.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectHOC.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectHOC.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectHOC.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectInfer.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectInfer.js
new file mode 100644
index 0000000000..d961c335ee
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectInfer.js
@@ -0,0 +1,588 @@
+/*
+  Keep here examples which still work without type parameters specified,
+  even if the current Flow verion still reports misleading errors.
+  This helps keep the usage of Flow amazing type inferent on the good level.
+*/
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  // Flow also erroneously complains about fromStateToProps
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  connect(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the wrong type for passthroug,
+  // giving passthrough a number fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type Props = {
+    passthrough: number,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected />;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  const Connected2 = connect(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // giving the `mapDispatchToProps` to connect above
+  // fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  const Connected3 = connect(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the wrong type of `dispatch1`,
+  // giving `num` the correct type fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] dispatch1 should be number
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234}/>;
+  // Here Flow reports that `forMapStateToProps` is missing from props,
+  // while the real error is still the missing `passthrough`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  connect(null, null, null, {pure: true})(Com);
+  connect(null, null, null, {forwardRef: true})(Com);
+  connect(null, null, null, {pure: false, forwardRef: false})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {pure: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {ref: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong key
+  connect(null, null, null, {wrongKey: true})(Com);
+}
+
+function testHoistConnectedComponent() {
+  type Props = {
+    passthrough: number,
+    passthroughWithDefaultProp: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+  //$FlowExpectedError[incompatible-use] property `notStatic` is missing in statics
+  Connected.notStatic;
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return { // no error
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+
+
+function testAllowsKnownPropInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.str
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected />;
+}
+
+function testForbidsLiteralOfInvalidTypeInMapStateToProps() {
+  type Props = {
+  str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithLiteralOfInvalidType = (state: State) => {
+    return {
+      str: 123
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithLiteralOfInvalidType)(Com);
+  //$FlowExpectedError[incompatible-use] string is incompatible with number
+  <Connected />
+}
+
+function testForbidsStateProperyOfInvalidTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithStatePropertyOfInvalidType = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithStatePropertyOfInvalidType)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+function testForbidsSelectorWithInvalidReturnTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  function selectorReturningNumber(state: State) {
+    return state.num
+  }
+
+  const mapStateToPropsWithSelectorWithInvalidTypeReturnValue = (state: State) => {
+    return {
+      str: selectorReturningNumber(state)
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithSelectorWithInvalidTypeReturnValue)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectMergeProps.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectMergeProps.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectMergeProps.js
diff --git a/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectState.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectState.js
new file mode 100644
index 0000000000..c222ba4960
--- /dev/null
+++ b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectState.js
@@ -0,0 +1,41 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function sameStateIsOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+
+  const Connected = connect<Props, {||}, _,_,State,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function differentStatesAreNotOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+  type OtherState = {|
+    b: number
+  |};
+
+  //$FlowExpectedError[incompatible-call] property `b` is missing in `State` but exists in `OtherState`
+  const Connected = connect<Props, {||}, _,_,OtherState,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectThunk.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectThunk.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectThunk.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_connectThunk.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_shallowEqual.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_shallowEqual.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_shallowEqual.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_shallowEqual.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useDispatch.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useDispatch.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useDispatch.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useDispatch.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useSelector.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useSelector.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useSelector.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useSelector.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useStore.js b/definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useStore.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_useStore.js
rename to definitions/npm/react-redux_v7.x.x/flow_v0.201.x-/test_useStore.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/react-redux_v8.x.x.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/react-redux_v8.x.x.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/react-redux_v8.x.x.js
rename to definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/react-redux_v8.x.x.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_Provider.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_Provider.js
new file mode 100644
index 0000000000..381e042bc4
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_Provider.js
@@ -0,0 +1,55 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+
+import React from "react";
+import { Provider, createProvider } from "react-redux";
+
+describe('Provider', () => {
+  it('should give an error when the store is missing', () => {
+    // $FlowExpectedError[prop-missing]
+    <Provider />;
+
+    // Also for custom providers
+    const CustomProvider: Class<Provider<any>> = createProvider("ikea");
+
+    // $FlowExpectedError[prop-missing]
+    <CustomProvider />;
+  });
+});
+
+describe('Custom Store (eg for ThunkActions)', () => {
+
+  // This represents a common typing for Thunk Actions.
+
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  // R = Result of a thunk action
+  type ThunkDispatch = <R>(action: ThunkAction<R>) => R;
+  type PlainDispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type ThunkAction<R> = (dispatch: Dispatch, GetState) => R;
+  // The `dispatch` function can accept either a plain action or a thunk action.
+  // This is similar to a type `(action: Action | ThunkAction) => any` except this
+  // allows to type the return value as well.
+  type Dispatch = PlainDispatch & ThunkDispatch;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('accepts a custom store', () => {
+    declare var store: Store;
+    <Provider store={store} />;
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_batch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_batch.js
new file mode 100644
index 0000000000..25b575aa17
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_batch.js
@@ -0,0 +1,27 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { batch } from 'react-redux';
+
+describe('batch', () => {
+  it('should accept a function as an argument', () => {
+    batch(() => {
+      // ...
+    })
+  });
+
+  it('should not allow a values that is not a function as an argument', () => {
+    //$FlowExpectedError[incompatible-call] - only a function is allowed
+    batch(true)
+  });
+
+  it('returns void', () => {
+    (batch(() => {
+      // ...
+    }): void)
+
+    batch(() => {
+      //$FlowExpectedError[incompatible-call] - function must return void
+      return true;
+    })
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connect.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connect.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connect.js
rename to definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connect.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
new file mode 100644
index 0000000000..ab8707645a
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectDispatch.js
@@ -0,0 +1,105 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function object_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function object_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[invalid-obj-map] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,_,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
+
+function function_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function function_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[incompatible-call] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,DispatchProps,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
new file mode 100644
index 0000000000..bab5729070
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectHOC.js
@@ -0,0 +1,171 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = [];
+
+function checkSimplePropertyInjection() {
+  type OwnProps = {
+    foo: number,
+    bar: string,
+    ...
+  };
+  type Props = {
+    ...OwnProps,
+    foo: number,
+    ...
+  };
+  const mapStateToProps = () => ({ foo: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, OwnProps, _, _, _, _>(mapStateToProps)(Com);
+
+  <Connected foo={42} bar="str" />;
+  //$FlowExpectedError[incompatible-use] property `foo` is missing in props [1] but exists in `OwnProps`
+  <Connected bar="str" />;
+  e.push(Connected);
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { foo: number | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { foo?: number, ... }>,
+    ) {
+      return <Component {...props} foo={42} />;
+    };
+  }
+
+  const Decorated = injectProp(Connected);
+  // OK without `foo`
+  <Decorated bar="str" />;
+  // OK with a not needed `foo`
+  <Decorated foo={42} bar="str" />;
+  //$FlowExpectedError[prop-missing] property `bar` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_OK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  // OK with a not needed `injected1`
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_exactOK() {
+  type OwnProps = {|
+    own1: number,
+    injected1: string,
+  |};
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  //$FlowExpectedError[prop-missing] property `injected1` is missing in `OwnProps` [1] but exists in props
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [1] but exists in `OwnProps` [2]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_wrongOrder() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  // injectProp must go before connect()
+  const composedDecorators = compose(
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+    injectProp,
+  );
+
+  const Decorated = composedDecorators(Com);
+  //$FlowExpectedError[incompatible-use] property `injected1` is missing in props
+  <Decorated own1={1} />;
+  // OK with an explicitly provided `injected1`
+  <Decorated own1={1} injected1="str" />;
+  e.push(Decorated);
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectInfer.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
similarity index 100%
rename from definitions/npm/react-redux_v8.x.x/flow_v0.142.x-/test_connectInfer.js
rename to definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectInfer.js
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
new file mode 100644
index 0000000000..ddc392ccca
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectMergeProps.js
@@ -0,0 +1,608 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyOwnProps_ok() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_wrongDispatch() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_noPassthrough() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      a: 1
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    //$FlowExpectedError[prop-missing] property `passthrough` is missing in object literal [1] but exists in `OwnProps` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({state1: state.state1})
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(undefined, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_wrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: { wrong: boolean, ... }, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in object type [1] but exists in object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    undefined,
+    mapDispatchToProps,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_WrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  type MapDispatchToPropsFn = Dispatch => DispatchProps
+  const mapDispatchToPropsFn: MapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {|wrong:boolean|}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in  object type [1] but exists in  object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_wrongDispatchProp() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with  string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (
+    stateProps: {|wrong:boolean|},
+    dispatchProps: DispatchProps,
+    ownProps: OwnProps
+  ) => {
+    return {
+      ...ownProps,
+      state1: 'state1',
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    // yes, a bit cryptic
+    //$FlowExpectedError[prop-missing] property `state1` is missing in  object type [1] but exists in  object literal [2]
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentProps() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentPropsWithError() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    //$FlowExpectedError[prop-missing] property `c` is missing in object literal [1] but exists in  `Props` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectState.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectState.js
new file mode 100644
index 0000000000..c222ba4960
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectState.js
@@ -0,0 +1,41 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function sameStateIsOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+
+  const Connected = connect<Props, {||}, _,_,State,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function differentStatesAreNotOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+  type OtherState = {|
+    b: number
+  |};
+
+  //$FlowExpectedError[incompatible-call] property `b` is missing in `State` but exists in `OtherState`
+  const Connected = connect<Props, {||}, _,_,OtherState,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
new file mode 100644
index 0000000000..c20f65d2c2
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_connectThunk.js
@@ -0,0 +1,199 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyDispatchFunction_samePropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Promise<number>,
+  |};
+  type MapDispatchToPropsFn = Dispatch => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch) => ({
+    action: () => dispatch(action()),
+    thunk: () => dispatch(thunk())
+  });
+
+  type Props = { // in the case of a function passed to `connect()` Flow infers
+  // the same type of function is both the Props and DispatchProps objects
+  // (see the testDispatchThunk() to get the difference)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_differentDispatchPropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = { // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-type-arg]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_differentDispatchPropsAreOK() {
+  type State = {|
+    state1: 'state1'
+  |}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = (state: State) => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-call]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_shallowEqual.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_shallowEqual.js
new file mode 100644
index 0000000000..bfb801b0a1
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_shallowEqual.js
@@ -0,0 +1,29 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { shallowEqual } from 'react-redux';
+
+describe('shallowEqual', () => {
+  it('returns a boolean', () => {
+    const x: boolean = shallowEqual('a', 'a');
+
+    //$FlowExpectedError[incompatible-type]
+    const y: number = shallowEqual('a', 'a');
+  });
+
+  it('can be called with any argument types', () => {
+    shallowEqual('a', 'a');
+    shallowEqual({ test: 'test' }, { test: 'test' });
+    shallowEqual({ test: 'test' }, 'a');
+  });
+
+  it('should be called with two arguments', () => {
+    // Flow considers these compatible with shallowEqual<T>(a: T, b: any).
+
+    // The same is seen in tests for _.isEqual and the comment below is copied from those tests
+    // Reasonable people disagree about whether these should be considered legal calls.
+    // See https://github.com/splodingsocks/FlowTyped/pull/1#issuecomment-149345275
+    // and https://github.com/facebook/flow/issues/956
+    shallowEqual();
+    shallowEqual('a');
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useDispatch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useDispatch.js
new file mode 100644
index 0000000000..7aaac950ed
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useDispatch.js
@@ -0,0 +1,155 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useDispatch } from 'react-redux';
+
+type Action = {|
+  type: 'action',
+|};
+type Dispatch = Action => Action;
+
+describe('useDispatch', () => {
+  it('returns type `Dispatch` which accepts only type `Action` as param', () => {
+    const dispatch = useDispatch<Dispatch>();
+
+    const action = dispatch({ type: 'action' });
+    (action.type: string);
+    // $FlowExpectedError[incompatible-cast] will be string because of passed generic
+    (action.type: number);
+  });
+
+  it('errors if returned type is passed invalid Action', () => {
+    const dispatch = useDispatch<Dispatch>();
+
+    // $FlowExpectedError[incompatible-call]: return value of `useDispatch` should make `Dispatch` and expect an `Action`.
+    dispatch();
+  });
+
+  it('errors if given invalid type argument', () => {
+    // $FlowExpectedError[incompatible-call]: string incompatible with Dispatch
+    useDispatch<string>()
+  });
+
+  it('handles action creator passed in and is typed', () => {
+    const dispatch = useDispatch();
+
+    const action = dispatch({ anything: 'string' });
+    (action.anything: string);
+    // $FlowExpectedError[incompatible-cast] will be string because of passed action
+    (action.anything: number);
+  });
+
+  it('handles thunks being passed to return the right value', () => {
+    const thunkAction = () => (dispatch: Dispatch) => {
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a promise to keep their type', () => {
+    const thunkPromiseAction = () => (dispatch: Dispatch) => new Promise((resolve) => {
+      resolve('');
+    });
+    const dispatch = useDispatch();
+
+    const dispatched = dispatch(thunkPromiseAction());
+    (dispatched: Promise<string>);
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (dispatched: Promise<number>);
+  });
+
+  it('handles thunks defined as a 1 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch) => {
+      dispatch();
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a 2 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+      () => { [key: string]: any },
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState) => {
+      dispatch();
+      getState().property1.property2;
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a 3 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+      () => { [key: string]: any },
+      {| test: number |},
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch();
+      getState().property1.property2;
+      extraArg.test.toFixed(2);
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as each arg', () => {
+    type ThunkAction = () => ((
+      dispatch: () => void,
+      getState: () => { [key: string]: any },
+      extraArg: {| test: number |},
+    ) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch();
+      getState().property1.property2;
+      extraArg.test.toFixed(2);
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks without a clear args', () => {
+    type ThunkAction = () => ((...args: Array<any>) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch.test.a();
+      getState.test.a();
+      extraArg.test.a();
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useSelector.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useSelector.js
new file mode 100644
index 0000000000..268e2ba2c3
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useSelector.js
@@ -0,0 +1,51 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useSelector, shallowEqual } from 'react-redux';
+
+type State = {|
+  a: number,
+|};
+
+describe('useSelector', () => {
+  it('passes State as first parameter', () => {
+    function Com() {
+      // $FlowExpectedError[incompatible-call]
+      const count = useSelector<State, number>(state => {
+        // $FlowExpectedError[prop-missing]: the state has no `b`
+        state.b
+      });
+      return <div>{count}</div>;
+    }
+  });
+
+  it('passes type of second parameter as params to `equalityFn`', () => {
+    function Com2() {
+      const count = useSelector<State, number>(
+        state => state.a,
+        // $FlowExpectedError[prop-missing]: `equalityFn` is passed params of the second type, do not have `.size`
+        (a, b) => a.size === b.size
+      );
+      return <div>{count}</div>;
+    }
+  });
+
+  it('returns type of second parameter', () => {
+    function Com3() {
+      const count = useSelector<State, number>(
+        state => state.a,
+        (a, b) => a === b
+      );
+      // `count` is type `number` and allows addition
+      return <div>{count + 5}</div>;
+    }
+  });
+
+  it('can use shallowEqual as the `equalityFn`', () => {
+    function Com4() {
+      const count = useSelector<State, number>(state => state.a, shallowEqual);
+      return <div>{count}</div>;
+    }
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useStore.js b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useStore.js
new file mode 100644
index 0000000000..6efe31b2c2
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.142.x-v.200.x/test_useStore.js
@@ -0,0 +1,42 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useStore } from 'react-redux';
+
+describe('useStore', () => {
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  type Dispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('returns instance of Store', () => {
+    function Com() {
+      const store = useStore<Store>();
+      return <div>{store.getState().state}</div>;
+    }
+  });
+
+  it('returns instance of Store, no extra keys', () => {
+    function Com() {
+      const store = useStore<Store>();
+      // $FlowExpectedError[prop-missing]: `foobar` is not a member of the Store instance
+      return <div>{store.getState().foobar}</div>;
+    }
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/react-redux_v8.x.x.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/react-redux_v8.x.x.js
new file mode 100644
index 0000000000..0edbf6c245
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/react-redux_v8.x.x.js
@@ -0,0 +1,272 @@
+/**
+The order of type arguments for connect() is as follows:
+
+connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(…)
+
+In Flow v0.89 only the first two are mandatory to specify. Other 4 can be repaced with the new awesome type placeholder:
+
+connect<Props, OwnProps, _, _, _, _>(…)
+
+But beware, in case of weird type errors somewhere in random places
+just type everything and get to a green field and only then try to
+remove the definitions you see bogus.
+
+Decrypting the abbreviations:
+  WC = Component being wrapped
+  S = State
+  D = Dispatch
+  OP = OwnProps
+  SP = StateProps
+  DP = DispatchProps
+  MP = Merge props
+  RSP = Returned state props
+  RDP = Returned dispatch props
+  RMP = Returned merge props
+  CP = Props for returned component
+  Com = React Component
+  SS = Selected state
+  ST = Static properties of Com
+*/
+
+declare module "react-redux" {
+  // ------------------------------------------------------------
+  // Typings for connect()
+  // ------------------------------------------------------------
+
+  declare export type Options<S, OP, SP, MP> = {|
+    forwardRef?: boolean,
+    areStatesEqual?: (next: S, prev: S) => boolean,
+    areOwnPropsEqual?: (next: OP, prev: OP) => boolean,
+    areStatePropsEqual?: (next: SP, prev: SP) => boolean,
+    areMergedPropsEqual?: (next: MP, prev: MP) => boolean,
+    storeKey?: string,
+  |};
+
+  declare type MapStateToProps<-S, -OP, +SP> =
+    | ((state: S, ownProps: OP) => SP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (State, OwnProps) => (State, OwnProps) => StateProps
+    // and provide the StateProps type to the SP type parameter.
+    | ((state: S, ownProps: OP) => (state: S, ownProps: OP) => SP);
+
+  declare type Bind<D> = <A, R>((...A) => R) => (...A) => $Call<D, R>;
+
+  declare type MapDispatchToPropsFn<D, -OP, +DP> =
+    | ((dispatch: D, ownProps: OP) => DP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (Dispatch, OwnProps) => (Dispatch, OwnProps) => DispatchProps
+    // and provide the DispatchProps type to the DP type parameter.
+    | ((dispatch: D, ownProps: OP) => (dispatch: D, ownProps: OP) => DP);
+
+  declare class ConnectedComponentClass<OP, +WC> extends React$Component<OP> {
+    static +WrappedComponent: WC;
+    getWrappedInstance(): React$ElementRef<WC>;
+  }
+
+  declare export type ConnectedComponent<OP, +WC> = ConnectedComponentClass<OP, WC>;
+
+  // The connection of the Wrapped Component and the Connected Component
+  // happens here in `MP: P`. It means that type wise MP belongs to P,
+  // so to say MP >= P.
+  declare type Connector<P, OP, MP: P> = <WC: React$ComponentType<P>>(
+    WC,
+  ) => Class<ConnectedComponentClass<OP, WC>> & WC;
+
+  // No `mergeProps` argument
+
+  // Got error like inexact OwnProps is incompatible with exact object type?
+  // Just make the OP parameter for `connect()` an exact object.
+  declare type MergeOP<OP, D> = {| ...$Exact<OP>, dispatch: D |};
+  declare type MergeOPSP<OP, SP, D> = {| ...$Exact<OP>, ...SP, dispatch: D |};
+  declare type MergeOPDP<OP, DP> = {| ...$Exact<OP>, ...DP |};
+  declare type MergeOPSPDP<OP, SP, DP> = {| ...$Exact<OP>, ...SP, ...DP |};
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    mapStateToProps?: null | void,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOP<OP, D>>,
+  ): Connector<P, OP, MergeOP<OP, D>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSP<OP, SP, D>>,
+  ): Connector<P, OP, MergeOPSP<OP, SP, D>>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, DP>>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, MergeOPDP<OP, DP>>,
+  ): Connector<P, OP, MergeOPDP<OP, $ObjMap<DP, Bind<D>>>>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+  ): Connector<P, OP, {| ...OP, ...SP, ...DP |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, MergeOPSPDP<OP, SP, DP>>,
+  ): Connector<P, OP, MergeOPSPDP<OP, SP, $ObjMap<DP, Bind<D>>>>;
+
+  // With `mergeProps` argument
+
+  declare type MergeProps<+P, -OP, -SP, -DP> = (
+    stateProps: SP,
+    dispatchProps: DP,
+    ownProps: OP,
+  ) => P;
+
+  declare export function connect<-P, -OP, -SP: {||}, -DP: {||}, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, {||}, {| dispatch: D |}>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  declare export function connect<-P, -OP, -SP, -DP: {||}, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, SP, {| dispatch: D |}>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, {||}, DP>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, {||}, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, SP, DP>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, SP, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
+
+  // ------------------------------------------------------------
+  // Typings for Hooks
+  // ------------------------------------------------------------
+
+  /* Action and AnyAction are taken from the redux TypeScript types defined here:
+    * https://github.com/reduxjs/redux/blob/d794c56f78eccb56ba3c67971c26df8ee34dacc1/src/types/actions.ts
+    *
+    * We turn them into objects so that they can be spread.
+    *
+    * We use AnyAction as the default for useDispatch as DefinitelyTyped does:
+    * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/f7ec78508c6797e42f87a4390735bc2c650a1bfd/types/react-redux/index.d.ts#L540
+    */
+  declare export type Action<T> = {
+    type: T,
+    ...
+  }
+
+  declare export type AnyAction = {
+    ...Action<any>,
+    [string]: any
+  }
+
+  declare export type Dispatch<-A: Action<any>> = (action: A, ...extraArgs: any[]) => mixed
+
+  // Since A is contravariant in Dispatch, empty is a reasonable bound here. This is equivalent
+  // to using mixed as a default in a read-only position.
+  declare export function useDispatch<D: Dispatch<empty> = Dispatch<AnyAction>>(): (
+    & (<T: { [key: string]: any }>(T) => T)
+    // Supports thunks at their various lengths and use cases depending if user has typed them as tuple vs array
+    & (<T>((...args: [any]) => T) => T)
+    & (<T>((...args: [any, any]) => T) => T)
+    & (<T>((...args: [any, any, any]) => T) => T)
+    & (<T>((...args: Array<any>) => T) => T)
+    & D
+  );
+
+  declare export function useSelector<S, SS>(
+    selector: (state: S) => SS,
+    equalityFn?: (a: SS, b: SS) => boolean,
+  ): SS;
+
+  declare export function useStore<Store>(): Store;
+
+  // ------------------------------------------------------------
+  // Typings for Provider
+  // ------------------------------------------------------------
+
+  declare export class Provider<Store> extends React$Component<{
+    store: Store,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export function createProvider(
+    storeKey?: string,
+    subKey?: string,
+  ): Class<Provider<any>>;
+
+  declare export function batch(() => void): void
+
+  declare export function shallowEqual<T>(left: T, right: any): boolean
+
+  declare export default {
+    Provider: typeof Provider,
+    createProvider: typeof createProvider,
+    connect: typeof connect,
+    useDispatch: typeof useDispatch,
+    useSelector: typeof useSelector,
+    useStore: typeof useStore,
+    batch: typeof batch,
+    ...
+  };
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_Provider.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_Provider.js
new file mode 100644
index 0000000000..381e042bc4
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_Provider.js
@@ -0,0 +1,55 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+
+import React from "react";
+import { Provider, createProvider } from "react-redux";
+
+describe('Provider', () => {
+  it('should give an error when the store is missing', () => {
+    // $FlowExpectedError[prop-missing]
+    <Provider />;
+
+    // Also for custom providers
+    const CustomProvider: Class<Provider<any>> = createProvider("ikea");
+
+    // $FlowExpectedError[prop-missing]
+    <CustomProvider />;
+  });
+});
+
+describe('Custom Store (eg for ThunkActions)', () => {
+
+  // This represents a common typing for Thunk Actions.
+
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  // R = Result of a thunk action
+  type ThunkDispatch = <R>(action: ThunkAction<R>) => R;
+  type PlainDispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type ThunkAction<R> = (dispatch: Dispatch, GetState) => R;
+  // The `dispatch` function can accept either a plain action or a thunk action.
+  // This is similar to a type `(action: Action | ThunkAction) => any` except this
+  // allows to type the return value as well.
+  type Dispatch = PlainDispatch & ThunkDispatch;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('accepts a custom store', () => {
+    declare var store: Store;
+    <Provider store={store} />;
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_batch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_batch.js
new file mode 100644
index 0000000000..25b575aa17
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_batch.js
@@ -0,0 +1,27 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { batch } from 'react-redux';
+
+describe('batch', () => {
+  it('should accept a function as an argument', () => {
+    batch(() => {
+      // ...
+    })
+  });
+
+  it('should not allow a values that is not a function as an argument', () => {
+    //$FlowExpectedError[incompatible-call] - only a function is allowed
+    batch(true)
+  });
+
+  it('returns void', () => {
+    (batch(() => {
+      // ...
+    }): void)
+
+    batch(() => {
+      //$FlowExpectedError[incompatible-call] - function must return void
+      return true;
+    })
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connect.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connect.js
new file mode 100644
index 0000000000..5e69417d17
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connect.js
@@ -0,0 +1,823 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+import type { ConnectedComponent } from "react-redux";
+
+export let e: Array<any> = []
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck1case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2case() {
+  type Props = { numProp: string, ... };
+
+  const Component = ({ numProp }: Props) => {
+    return <span>{numProp}</span>;
+  };
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-type-arg] wrong type for numProp
+  const Connected = connect<Props, {||}, _,_,_,_>(null, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck3case() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  const mapDispatchToProps = () => ({
+    numProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck4case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    stringProp: false,
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, {})(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testExactProps() {
+  type Dispatch = () => void;
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {|
+    ...OwnProps,
+    fromStateToProps: string,
+    dispatch: Dispatch,
+  |};
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {|
+    forMapStateToProps: string,
+    passthrough: number,
+  |};
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testInexactOwnProps() {
+  type OwnProps = {
+    passthrough: number,
+    forMapStateToProps: string,
+    ...
+  };
+  type Props = {
+    // to eliminate the cripy `undefined`
+    ...$Exact<OwnProps>,
+    fromStateToProps: string,
+    ...
+  };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {
+    forMapStateToProps: string,
+    passthrough: number,
+    ...
+  };
+
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] extraProp what exact props does not allow
+  <Connected passthrough={123} forMapStateToProps={321} extraProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321}/>;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  const Connected2 = connect(mapStateToProps)('');
+  e.push(Connected2);
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsDoesNotPassDispatch() {
+  type Dispatch = () => void;
+  type OwnProps = {||};
+  type Props = {| ...OwnProps, fromMapDispatchToProps: string, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.fromMapDispatchToProps}</div>;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({})
+  const mapDispatchToProps = (dispatch: any, ownProps: any) => {
+    return {fromMapDispatchToProps: 'yo'}
+  }
+  // $FlowExpectedError[prop-missing] dispatch should not be provided in Props when mapDispatchToProps is present
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+  |};
+  type Props = {
+    ...OwnProps,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type OwnProps = {|
+    passthrough: number,
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  //$FlowExpectedError[invalid-obj-map] dispatch1 should be number
+  const Connected3 = connect<Props, OwnProps, _,_,_,_>(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  e.push(Connected3);
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type OwnProps = {|
+    passthrough: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type OwnProps1 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+    forMergeProps: number
+  |};
+  type OwnProps2 = {|
+    passthrough: number,
+    forMapStateToProps: string,
+  |};
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (
+    stateProps: { ... },
+    dispatchProps: { ... },
+    ownProps: { forMergeProps: number, ... },
+  ) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect<Props, OwnProps1, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected forMapStateToProps="str" forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  //$FlowExpectedError[prop-missing] no dispatch2
+  const Connected2 = connect<Props, OwnProps2, _,_,_,_>(mapStateToProps, mapDispatchToProps2)(Com);
+  e.push(Connected2);
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type OwnProps = {|
+    forMapStateToProps: string,
+    forMapDispatchToProps: string,
+    forMergeProps: number
+  |};
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  // here in Props comes dispatch property
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {storeKey: 'test'})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {forwardRef: true})(Com));
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {storeKey: 'test', forwardRef: false})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {storeKey: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong type
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {ref: 123})(Com));
+  // $FlowExpectedError[incompatible-call] wrong key
+  e.push(connect<{...}, {||}, _,_,_,_>(null, null, null, {wrongKey: true})(Com));
+}
+
+function testDispatch() {
+  type Props = { dispatch: empty => empty, ... }
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+function testNoDispatch() {
+  type Props = {||}
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  // $FlowExpectedError[prop-missing] property `dispatch` is missing in `Props`
+  e.push(connect<Props, {||}, _,_,_,_>()(Com));
+}
+
+function testHoistConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect<Props, OwnProps, _,_,_,_>(mapStateToProps)(Com);
+  e.push(Connected);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+}
+
+function itsOkToReturnMoreThanNeededPropsFromMapStateToProps() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function doesNotRequireDefinedComponentToTypeCheck2caseAgain() {
+  type Props = {
+    stringProp: string,
+    numProp: number,
+    ...
+  };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  // This is actually required to reproduce an issue with Flow and the `*` type.
+  function getBoolean() {
+    //$FlowExpectedError[incompatible-return] boolean [1] is incompatible with number [2]
+    return false;
+  }
+
+  const mapStateToProps = () => ({
+    stringProp: 'foo',
+    numProp: getBoolean()
+  });
+
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Component);
+  <Connected />;
+  e.push(Connected)
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+  num: number, ... };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  //$FlowExpectedError[incompatible-type-arg] number [1] is incompatible with string [2] in property `str`
+  const Connected = connect<Props, {||}, _,_,_,_>(mapStateToProps)(Com);
+  <Connected />;
+  e.push(Connected);
+}
+
+function testPassingDispatchPropWithoutDispatchFunction() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: Dispatch |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div />;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = {...};
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {}
+  };
+
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testPassingDispatchTypeIsPassedThrough() {
+  type Dispatch = () => void;
+  type OwnProps = {||}
+  type Props = {| ...OwnProps, dispatch: string |};
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div />;
+    }
+  }
+
+  const mapStateToProps = (state: any, props: any) => ({});
+
+  // $FlowExpectedError[incompatible-type-arg] dispatch mismatched from type Dispatch
+  const Connected = connect<Props, OwnProps,_,_,_,Dispatch>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function testNestedComponent() {
+  type OwnProps = {|
+    passthrough: number
+  |};
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    fromDispatchToProps: string,
+    ...
+  };
+
+  const Component = ({ passthrough, fromStateToProps, fromDispatchToProps }: Props) => {
+    return <span>{`${passthrough}: ${fromStateToProps}, ${fromDispatchToProps}`}</span>;
+  };
+
+  const Wrapper = ({ children }: { children: React$Element<any>, ... }) => {
+    return <span>{children}</span>;
+  };
+
+  const mapStateToProps = (state: {...}) => ({
+    fromStateToProps: '',
+  });
+
+  const mapDispatchToProps = () => ({
+    fromDispatchToProps: '',
+  });
+
+  const Connected = (connect<Props, OwnProps, _, _, _, _>(
+    mapStateToProps,
+    mapDispatchToProps
+  )(Component): Class<ConnectedComponent<OwnProps, typeof Component>>);
+
+  return (
+    <Wrapper>
+      <Connected passthrough={2} />
+    </Wrapper>
+  );
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectDispatch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectDispatch.js
new file mode 100644
index 0000000000..ab8707645a
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectDispatch.js
@@ -0,0 +1,105 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function object_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function object_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' })
+  const mapDispatchToProps = {
+    action1
+  };
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,_,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[invalid-obj-map] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,_,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
+
+function function_sameDispatchIsOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+}
+
+function function_differentDispatchesAreNotOK() {
+  type Action1 = {|
+    type: string
+  |};
+  type Dispatch1 = Action1 => Action1;
+  const action1 = (): Action1 => ({ type: 'str' });
+  type DispatchProps = {|
+    action1: () => Action1
+  |};
+  type MapDispatchToPropsFn = Dispatch1 => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch: Dispatch1) => ({
+    action1: (...args) => dispatch(action1(...args))
+  });
+
+  type Action2 = {|
+    type: number
+  |};
+  type Dispatch2 = Action2 => Action2;
+
+  type Props = { action1: typeof action1, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected1 = connect<Props, {||}, _,DispatchProps,_,Dispatch1>(null, mapDispatchToProps)(Com);
+  e.push(Connected1);
+  <Connected1 />;
+
+  //$FlowExpectedError[incompatible-call] `string` is incompatible with `number` in property `type`
+  const Connected2 = connect<Props, {||}, _,DispatchProps,_,Dispatch2>(null, mapDispatchToProps)(Com);
+  e.push(Connected2);
+  <Connected2 />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectHOC.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectHOC.js
new file mode 100644
index 0000000000..bab5729070
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectHOC.js
@@ -0,0 +1,171 @@
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = [];
+
+function checkSimplePropertyInjection() {
+  type OwnProps = {
+    foo: number,
+    bar: string,
+    ...
+  };
+  type Props = {
+    ...OwnProps,
+    foo: number,
+    ...
+  };
+  const mapStateToProps = () => ({ foo: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, OwnProps, _, _, _, _>(mapStateToProps)(Com);
+
+  <Connected foo={42} bar="str" />;
+  //$FlowExpectedError[incompatible-use] property `foo` is missing in props [1] but exists in `OwnProps`
+  <Connected bar="str" />;
+  e.push(Connected);
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { foo: number | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { foo?: number, ... }>,
+    ) {
+      return <Component {...props} foo={42} />;
+    };
+  }
+
+  const Decorated = injectProp(Connected);
+  // OK without `foo`
+  <Decorated bar="str" />;
+  // OK with a not needed `foo`
+  <Decorated foo={42} bar="str" />;
+  //$FlowExpectedError[prop-missing] property `bar` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_OK() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  // OK with a not needed `injected1`
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [3] but exists in `Props` [4]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_exactOK() {
+  type OwnProps = {|
+    own1: number,
+    injected1: string,
+  |};
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  const composedDecorators = compose(
+    injectProp,
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+  );
+
+  const Decorated = composedDecorators(Com);
+  // OK without `injected1`
+  <Decorated own1={1} />;
+  //$FlowExpectedError[prop-missing] property `injected1` is missing in `OwnProps` [1] but exists in props
+  <Decorated own1={1} injected1="str" />;
+  //$FlowExpectedError[prop-missing] property `own1` is missing in props [1] but exists in `OwnProps` [2]
+  <Decorated />;
+  e.push(Decorated);
+}
+
+function composeWithOtherHOC_wrongOrder() {
+  type OwnProps = {
+    own1: number,
+    injected1: string,
+    ...
+  };
+  type Props = {
+    ...$Exact<OwnProps>,
+    state1: number,
+    ...
+  };
+  const mapStateToProps = () => ({ state1: 5 });
+
+  class Com extends React.Component<Props> {}
+
+  function injectProp<Config: {...}>(
+    Component: React.AbstractComponent<Config>,
+  ): React.AbstractComponent<$Diff<Config, { injected1: string | void, ... }>> {
+    return function WrapperComponent(
+      props: $Diff<Config, { injected1: string | void, ... }>,
+    ) {
+      return <Component {...props} injected1="str" />;
+    };
+  }
+
+  declare var compose: $Compose;
+
+  // injectProp must go before connect()
+  const composedDecorators = compose(
+    connect<Props, OwnProps, _, _, _, _>(mapStateToProps),
+    injectProp,
+  );
+
+  const Decorated = composedDecorators(Com);
+  //$FlowExpectedError[incompatible-use] property `injected1` is missing in props
+  <Decorated own1={1} />;
+  // OK with an explicitly provided `injected1`
+  <Decorated own1={1} injected1="str" />;
+  e.push(Decorated);
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectInfer.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectInfer.js
new file mode 100644
index 0000000000..6c172e0d89
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectInfer.js
@@ -0,0 +1,588 @@
+/*
+  Keep here examples which still work without type parameters specified,
+  even if the current Flow verion still reports misleading errors.
+  This helps keep the usage of Flow amazing type inferent on the good level.
+*/
+// @flow
+import * as React from "react";
+import { connect } from "react-redux";
+
+function testPassingPropsToConnectedComponent() {
+  type OwnProps = {|
+    passthrough: number,
+    passthroughWithDefaultProp?: number,
+    forMapStateToProps: string
+  |}
+  type Props = {
+    ...OwnProps,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  Connected.WrappedComponent;
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'} passthroughWithDefaultProp={123}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} passthroughWithDefaultProp={123}/>;
+  // Flow erroneously complains about `fromStateToProps`
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for  passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'} passthroughWithDefaultProp={''}/>;
+  // Flow also erroneously complains about fromStateToProps
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function doesNotRequireDefinedComponentToTypeCheck5case() {
+  type Props = { stringProp: string, ... };
+
+  const Component = ({ stringProp }: Props) => {
+    return <span>{stringProp}</span>;
+  };
+
+  const mapStateToProps = () => ({});
+  const mapDispatchToProps = () => ({});
+
+  const mergeProps = () => ({
+    stringProp: true
+  });
+
+  //$FlowExpectedError[incompatible-call] wrong type for stringProp
+  connect(mapStateToProps, mapDispatchToProps, mergeProps)(Component);
+}
+
+function testWithStatelessFunctionalComponent() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  const Com = (props: Props) => <div>{props.passthrough} {props.fromStateToProps}</div>
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the wrong type for passthroug,
+  // giving passthrough a number fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] wrong type for passthrough
+  <Connected passthrough={''} forMapStateToProps={'data'}/>;
+  //$FlowExpectedError[incompatible-use] wrong type for forMapStateToProps
+  <Connected passthrough={123} forMapStateToProps={321} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123}/>;
+  //$FlowExpectedError[incompatible-call] takes in only React components
+  connect(mapStateToProps)('');
+}
+
+function testMapStateToPropsDoesNotNeedProps() {
+  type Props = {
+    passthrough: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  type State = { a: string, ... }
+  const mapStateToProps = (state: State) => {
+    return {
+      fromStateToProps: state.a
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] component property passthrough not found
+  <Connected />;
+}
+
+function testMapDispatchToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    fromMapStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+        {this.props.fromMapStateToProps}
+        </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: 'str' + state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected passthrough={123} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsWithoutMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    fromMapDispatchToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.passthrough}
+        {this.props.fromMapDispatchToProps}
+      </div>;
+    }
+  }
+
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... };
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] passthrough missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps missing
+  <Connected passthrough={123} forMapStateToProps={'data'} />;
+}
+
+function testMapDispatchToPropsPassesActionCreators() {
+  type Props = {
+    passthrough: number,
+    dispatch1: (num: number) => void,
+    dispatch2: () => void,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+
+  const mapDispatchToProps = {
+    dispatch1: (num: number) => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(null, mapDispatchToProps)(Com);
+  <Connected passthrough={123}/>;
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected />;
+
+  const mapDispatchToPropsWithoutDispatch2 = {
+    dispatch1: (num: number) => {}
+  };
+  const Connected2 = connect(null, mapDispatchToPropsWithoutDispatch2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // giving the `mapDispatchToProps` to connect above
+  // fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123}/>;
+
+  const mapDispatchToPropsWithWrongDispatch1 = {
+    dispatch1: (num: string) => {},
+    dispatch2: () => {}
+  };
+  const Connected3 = connect(null, mapDispatchToPropsWithWrongDispatch1)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the wrong type of `dispatch1`,
+  // giving `num` the correct type fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] dispatch1 should be number
+  <Connected3 passthrough={123}/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const Connected = connect(mapStateToProps, mapDispatchToProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str"/>;
+  // Here Flow reports that `fromStateToProps` is missing from props,
+  // while the real error is still the missing passthroug property,
+  // giving the passthrough property fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMapDispatchToPropsPassesActionCreatorsWithMapStateToPropsAndMergeProps() {
+  type Props = {
+    passthrough: number,
+    dispatch1: () => void,
+    dispatch2: () => void,
+    fromMapStateToProps: number,
+    fromMergeProps: number,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.passthrough}</div>;
+    }
+  }
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  const mapDispatchToProps = {
+    dispatch1: () => {},
+    dispatch2: () => {}
+  };
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return Object.assign({}, stateProps, dispatchProps, { fromMergeProps: 123 });
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected passthrough={123} forMapStateToProps="str" forMergeProps={1234}/>;
+  // Here Flow reports that `forMapStateToProps` is missing from props,
+  // while the real error is still the missing `passthrough`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no passthrough
+  <Connected/>;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+
+  const mapDispatchToProps2 = {
+    dispatch1: () => {}
+  };
+  const Connected2 = connect(mapStateToProps, mapDispatchToProps2)(Com);
+  // Here Flow reports that `dispatch1` is missing from props,
+  // while the real error is still the missing `dispatch2`,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use] no dispatch2
+  <Connected2 passthrough={123} forMapStateToProps="str"/>;
+}
+
+function testMergeProps() {
+  type Props = { fromMergeProps: number, ... };
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>
+        {this.props.fromMergeProps}
+      </div>;
+    }
+  }
+
+  type State = { a: number, ... }
+  type MapStateToPropsProps = { forMapStateToProps: string, ... }
+  const mapStateToProps = (state: State, props: MapStateToPropsProps) => {
+    return {
+      fromMapStateToProps: state.a
+    }
+  }
+  type MapDispatchToPropsProps = { forMapDispatchToProps: string, ... }
+  const mapDispatchToProps = (dispatch: any, ownProps: MapDispatchToPropsProps) => {
+    return {fromMapDispatchToProps: ownProps.forMapDispatchToProps}
+  }
+  const mergeProps = (stateProps: { ... }, dispatchProps: { ... }, ownProps: { forMergeProps: number, ... }) => {
+    return {fromMergeProps: 123};
+  }
+  const Connected = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Com);
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapStateToProps missing
+  <Connected forMapDispatchToProps={'more data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMergeProps is missing
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is missing
+  <Connected forMapStateToProps={'data'} forMergeProps={1234} />;
+  //$FlowExpectedError[incompatible-use] forMapDispatchToProps is wrong type
+  <Connected forMapStateToProps={'data'} forMapDispatchToProps={'more data'} forMergeProps={'not number'} />;
+}
+
+function testOptions() {
+  class Com extends React.Component<{...}> {
+    render(): React.Node {
+      return <div></div>;
+    }
+  }
+  connect(null, null, null, {storeKey: 'test'})(Com);
+  connect(null, null, null, {forwardRef: true})(Com);
+  connect(null, null, null, {storeKey: 'test', forwardRef: false})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {storeKey: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong type
+  connect(null, null, null, {ref: 123})(Com);
+  // $FlowExpectedError[incompatible-call] wrong key
+  connect(null, null, null, {wrongKey: true})(Com);
+}
+
+function testHoistConnectedComponent() {
+  type Props = {
+    passthrough: number,
+    passthroughWithDefaultProp: number,
+    fromStateToProps: string,
+    ...
+  };
+  class Com extends React.Component<Props> {
+    static defaultProps: { passthroughWithDefaultProp: number, ... } = { passthroughWithDefaultProp: 123 };
+    static myStatic = 1;
+
+    render(): React.Node {
+      return <div>{this.props.passthrough} {this.props.fromStateToProps}</div>;
+    }
+  }
+
+  type State = { a: number, ... };
+  type InputProps = { forMapStateToProps: string, ... };
+  const mapStateToProps = (state: State, props: InputProps) => {
+    return {
+      fromStateToProps: 'str' + state.a
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  // OK without passthroughWithDefaultProp
+  <Connected passthrough={123} forMapStateToProps={'data'}/>;
+  // OK with passthroughWithDefaultProp
+  <Connected passthrough={123} passthroughWithDefaultProp={456} forMapStateToProps={'data'}/>;
+  // OK with declared static property
+  Connected.myStatic;
+  //$FlowExpectedError[incompatible-use] property `notStatic` is missing in statics
+  Connected.notStatic;
+}
+
+function checkIfStateTypeIsRespectedAgain() {
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return { // no error
+      str: state.num
+    }
+  };
+
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  const Connected = connect(mapStateToProps)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+
+
+function testAllowsKnownPropInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToProps = (state: State) => {
+    return {
+      str: state.str
+    }
+  };
+
+  const Connected = connect(mapStateToProps)(Com);
+  <Connected />;
+}
+
+function testForbidsLiteralOfInvalidTypeInMapStateToProps() {
+  type Props = {
+  str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithLiteralOfInvalidType = (state: State) => {
+    return {
+      str: 123
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithLiteralOfInvalidType)(Com);
+  //$FlowExpectedError[incompatible-use] string is incompatible with number
+  <Connected />
+}
+
+function testForbidsStateProperyOfInvalidTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  const mapStateToPropsWithStatePropertyOfInvalidType = (state: State) => {
+    return {
+      str: state.num
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithStatePropertyOfInvalidType)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />;
+}
+
+function testForbidsSelectorWithInvalidReturnTypeInMapStateToProps() {
+  type Props = { str: string, ... };
+
+  class Com extends React.Component<Props> {
+    render(): React.Node {
+      return <div>{this.props.str}</div>;
+    }
+  }
+
+  type State = {
+    num: number,
+    str: string,
+    ...
+  };
+
+  function selectorReturningNumber(state: State) {
+    return state.num
+  }
+
+  const mapStateToPropsWithSelectorWithInvalidTypeReturnValue = (state: State) => {
+    return {
+      str: selectorReturningNumber(state)
+    }
+  };
+
+  const Connected = connect(mapStateToPropsWithSelectorWithInvalidTypeReturnValue)(Com);
+  // Here Flow reports that `str` is missing from props,
+  // while the real error is still the type mismatch,
+  // fixing the original issue fixes the wrongly titled error.
+  //$FlowExpectedError[incompatible-use]
+  <Connected />
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectMergeProps.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectMergeProps.js
new file mode 100644
index 0000000000..ddc392ccca
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectMergeProps.js
@@ -0,0 +1,608 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyOwnProps_ok() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_wrongDispatch() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyOwnProps_noPassthrough() {
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type Props = { ...OwnProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const mergeProps = (stateProps: {||}, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      a: 1
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    null,
+    //$FlowExpectedError[prop-missing] property `passthrough` is missing in object literal [1] but exists in `OwnProps` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({state1: state.state1})
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: Dispatch|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(mapStateToProps, null, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyStateProps_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action';
+  type Dispatch = Action => Action;
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: {|dispatch: string|}, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] string [1] is incompatible with  `Dispatch` [2] in property `dispatch`
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    null,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(undefined, mapDispatchToProps, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsObject_wrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToProps = {
+    action1
+  }
+
+  const mergeProps = (stateProps: { wrong: boolean, ... }, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in object type [1] but exists in object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    undefined,
+    mapDispatchToProps,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_WrongExpectedState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  type MapDispatchToPropsFn = Dispatch => DispatchProps
+  const mapDispatchToPropsFn: MapDispatchToPropsFn = dispatch => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: {|wrong:boolean|}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  //$FlowExpectedError[incompatible-call] property `wrong` is missing in  object type [1] but exists in  object type [2]
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(null, mapDispatchToPropsFn, mergeProps)(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function onlyDispatchPropsFunction_wrongDispatchProp() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: {||}, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    null,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with  string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_ok() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongState() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (
+    stateProps: {|wrong:boolean|},
+    dispatchProps: DispatchProps,
+    ownProps: OwnProps
+  ) => {
+    return {
+      ...ownProps,
+      state1: 'state1',
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    // yes, a bit cryptic
+    //$FlowExpectedError[prop-missing] property `state1` is missing in  object type [1] but exists in  object literal [2]
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function stateAndDispatchPropsFunction_wrongDispatch() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    ...OwnProps,
+    ...StateProps,
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => 123
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      ...ownProps,
+      ...stateProps,
+      ...dispatchProps,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    //$FlowExpectedError[incompatible-call] number [1] is incompatible with string literal `action1` [2]
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentProps() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
+
+function returnsTotallyDifferentPropsWithError() {
+  type State = {|
+    +state1: 'state1'
+  |}
+  opaque type Action = 'action1';
+  type Dispatch = Action => Action;
+  const action1 = (): Action => 'action1'
+
+  type OwnProps = {|
+    passthrough: string
+  |}
+  type StateProps = {|
+    state1: 'state1'
+  |}
+  type DispatchProps = {|
+    action1: typeof action1
+  |}
+  type Props = {
+    a: 1,
+    b: 2,
+    c: 3,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  const mapDispatchToPropsFn = (dispatch: Dispatch) => ({
+    action1: () => dispatch(action1())
+  })
+
+  const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => {
+    return {
+      a: 1,
+      b: 2,
+    }
+  }
+
+  const Connected = connect<Props, OwnProps, _,_,_,Dispatch>(
+    mapStateToProps,
+    mapDispatchToPropsFn,
+    //$FlowExpectedError[prop-missing] property `c` is missing in object literal [1] but exists in  `Props` [2]
+    mergeProps
+  )(Com);
+  e.push(Connected);
+  <Connected passthrough="foo" />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectState.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectState.js
new file mode 100644
index 0000000000..c222ba4960
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectState.js
@@ -0,0 +1,41 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function sameStateIsOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+
+  const Connected = connect<Props, {||}, _,_,State,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function differentStatesAreNotOK() {
+  type Props = {...};
+  class Com extends React.Component<Props> {}
+
+  type State = {|
+    a: number
+  |};
+  const mapStateToProps = (state: State) => {
+    return {}
+  };
+  type OtherState = {|
+    b: number
+  |};
+
+  //$FlowExpectedError[incompatible-call] property `b` is missing in `State` but exists in `OtherState`
+  const Connected = connect<Props, {||}, _,_,OtherState,empty>(mapStateToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectThunk.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectThunk.js
new file mode 100644
index 0000000000..c20f65d2c2
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_connectThunk.js
@@ -0,0 +1,199 @@
+// @flow
+import React from "react";
+import { connect } from "react-redux";
+
+export let e: Array<any> = []
+
+function onlyDispatchFunction_samePropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Promise<number>,
+  |};
+  type MapDispatchToPropsFn = Dispatch => DispatchProps;
+  const mapDispatchToProps: MapDispatchToPropsFn = (dispatch) => ({
+    action: () => dispatch(action()),
+    thunk: () => dispatch(thunk())
+  });
+
+  type Props = { // in the case of a function passed to `connect()` Flow infers
+  // the same type of function is both the Props and DispatchProps objects
+  // (see the testDispatchThunk() to get the difference)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_differentDispatchPropsAreOK() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function onlyDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = { // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+  ...DispatchProps, ... };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-type-arg]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(null, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_differentDispatchPropsAreOK() {
+  type State = {|
+    state1: 'state1'
+  |}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = (state: State) => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    // here the property returns a thunk...
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    action: typeof action,
+    // ... and here the property returns a return value of thunk
+    // as dispatch calls it for us with `dispatch` and `getState`
+    thunk: () => Promise<number>,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
+
+function stateAndDispatchObject_sameDispatchPropsAreErroneous() {
+  type State = {||}
+  type Action = {|
+    type: 'action'
+  |};
+  type DispatchAction = Action => Action;
+  type Thunk = (Dispatch, State) => Promise<number>
+  type DispatchThunk = Thunk => Promise<number>
+  type Dispatch = DispatchAction & DispatchThunk
+
+  const action = (): Action => ({ type: 'action' });
+  const thunk = (): Thunk => (d: Dispatch) => Promise.resolve(1);
+
+  type StateProps = {|
+    state1: 'state1',
+  |};
+  const mapStateToProps = (state: StateProps) => ({
+    state1: state.state1
+  })
+
+  type DispatchProps = {|
+    action: typeof action,
+    thunk: () => Thunk,
+  |};
+  const mapDispatchToProps = {
+    action,
+    thunk
+  };
+
+  type Props = {
+    ...StateProps,
+    // trying to pass the not passed to dispatch types (against the redux dispatch monad)
+    ...DispatchProps,
+    ...
+  };
+  class Com extends React.Component<Props> {}
+
+  //$FlowExpectedError[prop-missing] here the property returns a thunk...
+  //$FlowExpectedError[incompatible-call]
+  const Connected = connect<Props, {||}, _,DispatchProps,_,Dispatch>(mapStateToProps, mapDispatchToProps)(Com);
+  e.push(Connected);
+  <Connected />;
+}
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_shallowEqual.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_shallowEqual.js
new file mode 100644
index 0000000000..bfb801b0a1
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_shallowEqual.js
@@ -0,0 +1,29 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import { shallowEqual } from 'react-redux';
+
+describe('shallowEqual', () => {
+  it('returns a boolean', () => {
+    const x: boolean = shallowEqual('a', 'a');
+
+    //$FlowExpectedError[incompatible-type]
+    const y: number = shallowEqual('a', 'a');
+  });
+
+  it('can be called with any argument types', () => {
+    shallowEqual('a', 'a');
+    shallowEqual({ test: 'test' }, { test: 'test' });
+    shallowEqual({ test: 'test' }, 'a');
+  });
+
+  it('should be called with two arguments', () => {
+    // Flow considers these compatible with shallowEqual<T>(a: T, b: any).
+
+    // The same is seen in tests for _.isEqual and the comment below is copied from those tests
+    // Reasonable people disagree about whether these should be considered legal calls.
+    // See https://github.com/splodingsocks/FlowTyped/pull/1#issuecomment-149345275
+    // and https://github.com/facebook/flow/issues/956
+    shallowEqual();
+    shallowEqual('a');
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useDispatch.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useDispatch.js
new file mode 100644
index 0000000000..7aaac950ed
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useDispatch.js
@@ -0,0 +1,155 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useDispatch } from 'react-redux';
+
+type Action = {|
+  type: 'action',
+|};
+type Dispatch = Action => Action;
+
+describe('useDispatch', () => {
+  it('returns type `Dispatch` which accepts only type `Action` as param', () => {
+    const dispatch = useDispatch<Dispatch>();
+
+    const action = dispatch({ type: 'action' });
+    (action.type: string);
+    // $FlowExpectedError[incompatible-cast] will be string because of passed generic
+    (action.type: number);
+  });
+
+  it('errors if returned type is passed invalid Action', () => {
+    const dispatch = useDispatch<Dispatch>();
+
+    // $FlowExpectedError[incompatible-call]: return value of `useDispatch` should make `Dispatch` and expect an `Action`.
+    dispatch();
+  });
+
+  it('errors if given invalid type argument', () => {
+    // $FlowExpectedError[incompatible-call]: string incompatible with Dispatch
+    useDispatch<string>()
+  });
+
+  it('handles action creator passed in and is typed', () => {
+    const dispatch = useDispatch();
+
+    const action = dispatch({ anything: 'string' });
+    (action.anything: string);
+    // $FlowExpectedError[incompatible-cast] will be string because of passed action
+    (action.anything: number);
+  });
+
+  it('handles thunks being passed to return the right value', () => {
+    const thunkAction = () => (dispatch: Dispatch) => {
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a promise to keep their type', () => {
+    const thunkPromiseAction = () => (dispatch: Dispatch) => new Promise((resolve) => {
+      resolve('');
+    });
+    const dispatch = useDispatch();
+
+    const dispatched = dispatch(thunkPromiseAction());
+    (dispatched: Promise<string>);
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (dispatched: Promise<number>);
+  });
+
+  it('handles thunks defined as a 1 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch) => {
+      dispatch();
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a 2 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+      () => { [key: string]: any },
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState) => {
+      dispatch();
+      getState().property1.property2;
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as a 3 arg tuple', () => {
+    type ThunkAction = () => ((...args: [
+      () => void,
+      () => { [key: string]: any },
+      {| test: number |},
+    ]) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch();
+      getState().property1.property2;
+      extraArg.test.toFixed(2);
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks defined as each arg', () => {
+    type ThunkAction = () => ((
+      dispatch: () => void,
+      getState: () => { [key: string]: any },
+      extraArg: {| test: number |},
+    ) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch();
+      getState().property1.property2;
+      extraArg.test.toFixed(2);
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+
+  it('handles thunks without a clear args', () => {
+    type ThunkAction = () => ((...args: Array<any>) => string);
+    const thunkAction: ThunkAction = () => (dispatch, getState, extraArg) => {
+      dispatch.test.a();
+      getState.test.a();
+      extraArg.test.a();
+      return '';
+    }
+    const dispatch = useDispatch();
+
+    const a = dispatch(thunkAction());
+    a.toString();
+    // $FlowExpectedError[incompatible-cast] it will return a string, not any which could be cast to number
+    (a: number)
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useSelector.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useSelector.js
new file mode 100644
index 0000000000..268e2ba2c3
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useSelector.js
@@ -0,0 +1,51 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useSelector, shallowEqual } from 'react-redux';
+
+type State = {|
+  a: number,
+|};
+
+describe('useSelector', () => {
+  it('passes State as first parameter', () => {
+    function Com() {
+      // $FlowExpectedError[incompatible-call]
+      const count = useSelector<State, number>(state => {
+        // $FlowExpectedError[prop-missing]: the state has no `b`
+        state.b
+      });
+      return <div>{count}</div>;
+    }
+  });
+
+  it('passes type of second parameter as params to `equalityFn`', () => {
+    function Com2() {
+      const count = useSelector<State, number>(
+        state => state.a,
+        // $FlowExpectedError[prop-missing]: `equalityFn` is passed params of the second type, do not have `.size`
+        (a, b) => a.size === b.size
+      );
+      return <div>{count}</div>;
+    }
+  });
+
+  it('returns type of second parameter', () => {
+    function Com3() {
+      const count = useSelector<State, number>(
+        state => state.a,
+        (a, b) => a === b
+      );
+      // `count` is type `number` and allows addition
+      return <div>{count + 5}</div>;
+    }
+  });
+
+  it('can use shallowEqual as the `equalityFn`', () => {
+    function Com4() {
+      const count = useSelector<State, number>(state => state.a, shallowEqual);
+      return <div>{count}</div>;
+    }
+  });
+});
diff --git a/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useStore.js b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useStore.js
new file mode 100644
index 0000000000..6efe31b2c2
--- /dev/null
+++ b/definitions/npm/react-redux_v8.x.x/flow_v0.201.x-/test_useStore.js
@@ -0,0 +1,42 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import { useStore } from 'react-redux';
+
+describe('useStore', () => {
+  type Action = { type: 'SOME_ACTION', ... };
+  type State = { state: string, ... };
+
+  // ReduxStore should be imported from 'redux' but we can't do this with this
+  // test environment, so let's copy them once again...
+  declare type Redux$DispatchAPI<A> = (action: A) => A;
+  declare type Redux$Dispatch<A: { type: string, ... }> = Redux$DispatchAPI<A>;
+  declare type Redux$Reducer<S, A> = (state: S | void, action: A) => S;
+  declare type Redux$Store<S, A, D = Redux$Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Redux$Reducer<S, A>): void,
+    ...
+  };
+
+  type Dispatch = (action: Action) => Action;
+  type GetState = () => State;
+  type Store = Redux$Store<State, Action, Dispatch>;
+
+  it('returns instance of Store', () => {
+    function Com() {
+      const store = useStore<Store>();
+      return <div>{store.getState().state}</div>;
+    }
+  });
+
+  it('returns instance of Store, no extra keys', () => {
+    function Com() {
+      const store = useStore<Store>();
+      // $FlowExpectedError[prop-missing]: `foobar` is not a member of the Store instance
+      return <div>{store.getState().foobar}</div>;
+    }
+  });
+});
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/react-relay_v1.x.x.js b/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/react-relay_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/react-relay_v1.x.x.js
rename to definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/react-relay_v1.x.x.js
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_Variables.js b/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_Variables.js
similarity index 100%
rename from definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_Variables.js
rename to definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_Variables.js
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_classic.js b/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_classic.js
similarity index 100%
rename from definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_classic.js
rename to definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_classic.js
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_fragmentContainer.js b/definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_fragmentContainer.js
similarity index 100%
rename from definitions/npm/react-relay_v1.x.x/flow_v0.104.x-/test_fragmentContainer.js
rename to definitions/npm/react-relay_v1.x.x/flow_v0.104.x-v.200.x/test_fragmentContainer.js
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/react-relay_v1.x.x.js b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/react-relay_v1.x.x.js
new file mode 100644
index 0000000000..8272d54a2b
--- /dev/null
+++ b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/react-relay_v1.x.x.js
@@ -0,0 +1,2094 @@
+import * as React from 'react';
+
+declare module "react-relay" {
+  declare export type RecordState = "EXISTENT" | "NONEXISTENT" | "UNKNOWN";
+
+  declare export type onCompleted = (
+    response: ?Object,
+    errors: ?Array<PayloadError>
+  ) => void;
+  declare export type onError = (error: Error) => void;
+
+  declare export type CommitOptions = {
+    onCompleted: onCompleted,
+    onError: onError,
+    ...
+  };
+
+  /**
+   * Ideally this would be a union of Field/Fragment/Mutation/Query/Subscription,
+   * but that causes lots of Flow errors.
+   */
+  declare export type ConcreteBatchCallVariable = {
+    jsonPath: string,
+    kind: "BatchCallVariable",
+    sourceQueryID: string,
+    ...
+  };
+  declare export type ConcreteCall = {
+    kind: "Call",
+    metadata: { type?: ?string, ... },
+    name: string,
+    value: ?ConcreteValue,
+    ...
+  };
+  declare export type ConcreteCallValue = {
+    callValue: mixed,
+    kind: "CallValue",
+    ...
+  };
+  declare export type ConcreteCallVariable = {
+    callVariableName: string,
+    kind: "CallVariable",
+    ...
+  };
+  declare export type ConcreteDirective = {
+    args: Array<ConcreteDirectiveArgument>,
+    kind: "Directive",
+    name: string,
+    ...
+  };
+  declare export type ConcreteDirectiveArgument = {
+    name: string,
+    value: ?ConcreteDirectiveValue,
+    ...
+  };
+  declare export type ConcreteDirectiveValue =
+    | ConcreteCallValue
+    | ConcreteCallVariable
+    | Array<ConcreteCallValue | ConcreteCallVariable>;
+  declare export type ConcreteFieldMetadata = {
+    canHaveSubselections?: ?boolean,
+    inferredPrimaryKey?: ?string,
+    inferredRootCallName?: ?string,
+    isAbstract?: boolean,
+    isConnection?: boolean,
+    isConnectionWithoutNodeID?: boolean,
+    isFindable?: boolean,
+    isGenerated?: boolean,
+    isPlural?: boolean,
+    isRequisite?: boolean,
+    ...
+  };
+  declare export type ConcreteFragmentMetadata = {
+    isAbstract?: boolean,
+    pattern?: boolean,
+    plural?: boolean,
+    ...
+  };
+  declare export type ConcreteMutation = {
+    calls: Array<ConcreteCall>,
+    children?: ?Array<?ConcreteSelection>,
+    directives?: ?Array<ConcreteDirective>,
+    kind: "Mutation",
+    metadata: { inputType?: ?string, ... },
+    name: string,
+    responseType: string,
+    ...
+  };
+  declare export type ConcreteOperationMetadata = { inputType?: ?string, ... };
+  declare export type ConcreteQuery = {
+    calls?: ?Array<ConcreteCall>,
+    children?: ?Array<?ConcreteSelection>,
+    directives?: ?Array<ConcreteDirective>,
+    fieldName: string,
+    isDeferred?: boolean,
+    kind: "Query",
+    metadata: {
+      identifyingArgName?: ?string,
+      identifyingArgType?: ?string,
+      isAbstract?: ?boolean,
+      isPlural?: ?boolean,
+      ...
+    },
+    name: string,
+    type: string,
+    ...
+  };
+  declare export type ConcreteQueryMetadata = {
+    identifyingArgName: ?string,
+    identifyingArgType: ?string,
+    isAbstract: ?boolean,
+    isDeferred: ?boolean,
+    isPlural: ?boolean,
+    ...
+  };
+  declare export type ConcreteSubscription = {
+    calls: Array<ConcreteCall>,
+    children?: ?Array<?ConcreteSelection>,
+    directives?: ?Array<ConcreteDirective>,
+    kind: "Subscription",
+    name: string,
+    responseType: string,
+    metadata: { inputType?: ?string, ... },
+    ...
+  };
+  declare export type ConcreteValue =
+    | ConcreteBatchCallVariable
+    | ConcreteCallValue
+    | ConcreteCallVariable
+    | Array<ConcreteCallValue | ConcreteCallVariable>;
+
+  /**
+   * The output of a graphql-tagged fragment definition.
+   */
+  declare export type ConcreteFragmentDefinition = {
+    kind: "FragmentDefinition",
+    argumentDefinitions: Array<ConcreteArgumentDefinition>,
+    node: ConcreteFragment,
+    ...
+  };
+
+  declare export type ConcreteLocalArgumentDefinition = {
+    kind: "LocalArgument",
+    name: string,
+    defaultValue: mixed,
+    ...
+  };
+
+  declare export type ConcreteRootArgumentDefinition = {
+    kind: "RootArgument",
+    name: string,
+    ...
+  };
+
+  /**
+   * The output of a graphql-tagged operation definition.
+   */
+  declare export type ConcreteOperationDefinition = {
+    kind: "OperationDefinition",
+    argumentDefinitions: Array<ConcreteLocalArgumentDefinition>,
+    name: string,
+    operation: "mutation" | "query" | "subscription",
+    node: ConcreteFragment | ConcreteMutation | ConcreteSubscription,
+    ...
+  };
+
+  declare export type ConcreteArgument = ConcreteLiteral | ConcreteVariable;
+  declare export type ConcreteArgumentDefinition =
+    | ConcreteLocalArgument
+    | ConcreteRootArgument;
+  /**
+   * Represents a single ConcreteRoot along with metadata for processing it at
+   * runtime. The persisted `id` (or `text`) can be used to fetch the query,
+   * the `fragment` can be used to read the root data (masking data from child
+   * fragments), and the `query` can be used to normalize server responses.
+   *
+   * NOTE: The use of "batch" in the name is intentional, as this wrapper around
+   * the ConcreteRoot will provide a place to store multiple concrete nodes that
+   * are part of the same batch, e.g. in the case of deferred nodes or
+   * for streaming connections that are represented as distinct concrete roots but
+   * are still conceptually tied to one source query.
+   */
+  declare export type ConcreteBatch = {
+    kind: "Batch",
+    fragment: ConcreteFragment,
+    id: ?string,
+    metadata: { [key: string]: mixed, ... },
+    name: string,
+    query: ConcreteRoot,
+    text: ?string,
+    ...
+  };
+  declare export type ConcreteCondition = {
+    kind: "Condition",
+    passingValue: boolean,
+    condition: string,
+    selections: Array<ConcreteSelection>,
+    ...
+  };
+  declare export type ConcreteField = ConcreteScalarField | ConcreteLinkedField;
+  declare export type ConcreteFragment = {
+    argumentDefinitions: Array<ConcreteArgumentDefinition>,
+    kind: "Fragment",
+    metadata: ?{ [key: string]: mixed, ... },
+    name: string,
+    selections: Array<ConcreteSelection>,
+    type: string,
+    ...
+  };
+  declare export type ConcreteFragmentSpread = {
+    args: ?Array<ConcreteArgument>,
+    kind: "FragmentSpread",
+    name: string,
+    ...
+  };
+  declare export type ConcreteHandle =
+    | ConcreteScalarHandle
+    | ConcreteLinkedHandle;
+  declare export type ConcreteRootArgument = {
+    kind: "RootArgument",
+    name: string,
+    type: ?string,
+    ...
+  };
+  declare export type ConcreteInlineFragment = {
+    kind: "InlineFragment",
+    selections: Array<ConcreteSelection>,
+    type: string,
+    ...
+  };
+  declare export type ConcreteLinkedField = {
+    alias: ?string,
+    args: ?Array<ConcreteArgument>,
+    concreteType: ?string,
+    kind: "LinkedField",
+    name: string,
+    plural: boolean,
+    selections: Array<ConcreteSelection>,
+    storageKey: ?string,
+    ...
+  };
+  declare export type ConcreteLinkedHandle = {
+    alias: ?string,
+    args: ?Array<ConcreteArgument>,
+    kind: "LinkedHandle",
+    name: string,
+    handle: string,
+    key: string,
+    filters: ?Array<string>,
+    ...
+  };
+  declare export type ConcreteLiteral = {
+    kind: "Literal",
+    name: string,
+    type: ?string,
+    value: mixed,
+    ...
+  };
+  declare export type ConcreteLocalArgument = {
+    defaultValue: mixed,
+    kind: "LocalArgument",
+    name: string,
+    type: string,
+    ...
+  };
+  declare export type ConcreteNode =
+    | ConcreteCondition
+    | ConcreteLinkedField
+    | ConcreteFragment
+    | ConcreteInlineFragment
+    | ConcreteRoot;
+  declare export type ConcreteRoot = {
+    argumentDefinitions: Array<ConcreteLocalArgument>,
+    kind: "Root",
+    name: string,
+    operation: "mutation" | "query" | "subscription",
+    selections: Array<ConcreteSelection>,
+    ...
+  };
+  declare export type ConcreteScalarField = {
+    alias: ?string,
+    args: ?Array<ConcreteArgument>,
+    kind: "ScalarField",
+    name: string,
+    storageKey: ?string,
+    ...
+  };
+  declare export type ConcreteScalarHandle = {
+    alias: ?string,
+    args: ?Array<ConcreteArgument>,
+    kind: "ScalarHandle",
+    name: string,
+    handle: string,
+    key: string,
+    filters: ?Array<string>,
+    ...
+  };
+  declare export type ConcreteSelection =
+    | ConcreteCondition
+    | ConcreteField
+    | ConcreteFragmentSpread
+    | ConcreteHandle
+    | ConcreteInlineFragment;
+  declare export type ConcreteVariable = {
+    kind: "Variable",
+    name: string,
+    type: ?string,
+    variableName: string,
+    ...
+  };
+  declare export type ConcreteSelectableNode = ConcreteFragment | ConcreteRoot;
+  declare export type GeneratedNode = ConcreteBatch | ConcreteFragment;
+
+  // The type of a graphql`...` tagged template expression.
+  declare export type GraphQLTaggedNode =
+    | (() => ConcreteFragment | ConcreteBatch)
+    | {
+    modern: () => ConcreteFragment | ConcreteBatch,
+    classic: () => ConcreteFragmentDefinition | ConcreteOperationDefinition,
+    ...
+  };
+
+  declare export function graphql(strings: Array<string>): GraphQLTaggedNode;
+
+  declare export type GeneratedNodeMap = { [key: string]: GraphQLTaggedNode, ... };
+
+  declare export function createFragmentContainer<
+    TBase: React$ComponentType<any>
+  >(
+    Component: TBase,
+    fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap
+  ): TBase;
+
+  declare export function createRefetchContainer<TBase: React$ComponentType<any>>(
+    Component: TBase,
+    fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap,
+    taggedNode: GraphQLTaggedNode
+  ): TBase;
+
+  declare type FragmentVariablesGetter = (
+    prevVars: Variables,
+    totalCount: number
+  ) => Variables;
+
+  declare export type PageInfo = {
+    endCursor: ?string,
+    hasNextPage: boolean,
+    hasPreviousPage: boolean,
+    startCursor: ?string,
+    ...
+  };
+
+  declare export type ConnectionData = {
+    edges?: ?Array<any>,
+    pageInfo?: ?PageInfo,
+    ...
+  };
+
+  declare export type ConnectionConfig = {
+    direction?: "backward" | "forward",
+    getConnectionFromProps?: (props: Object) => ?ConnectionData,
+    getFragmentVariables?: FragmentVariablesGetter,
+    getVariables: (
+      props: Object,
+      paginationInfo: {
+        count: number,
+        cursor: ?string,
+        ...
+      },
+      fragmentVariables: Variables
+    ) => Variables,
+    query: GraphQLTaggedNode,
+    ...
+  };
+
+  declare export function createPaginationContainer<
+    TBase: React$ComponentType<any>
+  >(
+    Component: TBase,
+    fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap,
+    connectionConfig: ConnectionConfig
+  ): TBase;
+
+  declare type Variable = string | null | boolean | number | Variables | void | Array<Variable>;
+  declare export type Variables = ?{ [string]: Variable, ... };
+  declare export type DataID = string;
+
+  declare type TEnvironment = Environment;
+  declare type TFragment = ConcreteFragment;
+  declare type TGraphQLTaggedNode = GraphQLTaggedNode;
+  declare type TNode = ConcreteSelectableNode;
+  declare export type TOperation = ConcreteBatch;
+  declare type TPayload = RelayResponsePayload;
+
+  declare export type FragmentMap = CFragmentMap<TFragment>;
+  declare export type OperationSelector = COperationSelector<TNode, TOperation>;
+  declare export type RelayContext = CRelayContext<TEnvironment>;
+  declare export type Selector = CSelector<TNode>;
+  declare export type TSnapshot<TRecord> = CSnapshot<TNode, TRecord>;
+  declare export type Snapshot = TSnapshot<Record>;
+  declare export type ProxySnapshot = TSnapshot<RecordProxy>;
+  declare export type UnstableEnvironmentCore = CUnstableEnvironmentCore<
+    TEnvironment,
+    TFragment,
+    TGraphQLTaggedNode,
+    TNode,
+    TOperation
+  >;
+
+  declare export interface IRecordSource<TRecord> {
+    get(dataID: DataID): ?TRecord;
+  }
+
+  /**
+   * A read-only interface for accessing cached graph data.
+   */
+  declare export interface RecordSource extends IRecordSource<Record> {
+    get(dataID: DataID): ?Record;
+
+    getRecordIDs(): Array<DataID>;
+
+    getStatus(dataID: DataID): RecordState;
+
+    has(dataID: DataID): boolean;
+
+    load(
+      dataID: DataID,
+      callback: (error: ?Error, record: ?Record) => void
+    ): void;
+
+    size(): number;
+  }
+
+  /**
+   * A read/write interface for accessing and updating graph data.
+   */
+  declare export interface MutableRecordSource extends RecordSource {
+    clear(): void;
+
+    delete(dataID: DataID): void;
+
+    remove(dataID: DataID): void;
+
+    set(dataID: DataID, record: Record): void;
+  }
+
+  /**
+   * An interface for keeping multiple views of data consistent across an
+   * application.
+   */
+  declare export interface Store {
+    /**
+     * Get a read-only view of the store's internal RecordSource.
+     */
+    getSource(): RecordSource;
+
+    /**
+     * Determine if the selector can be resolved with data in the store (i.e. no
+     * fields are missing).
+     */
+    check(selector: Selector): boolean;
+
+    /**
+     * Read the results of a selector from in-memory records in the store.
+     */
+    lookup(selector: Selector): Snapshot;
+
+    /**
+     * Notify subscribers (see `subscribe`) of any data that was published
+     * (`publish()`) since the last time `notify` was called.
+     */
+    notify(): void;
+
+    /**
+     * Publish new information (e.g. from the network) to the store, updating its
+     * internal record source. Subscribers are not immediately notified - this
+     * occurs when `notify()` is called.
+     */
+    publish(source: RecordSource): void;
+
+    /**
+     * Attempts to load all the records necessary to fulfill the selector into the
+     * target record source.
+     */
+    resolve(
+      target: MutableRecordSource,
+      selector: Selector,
+      callback: AsyncLoadCallback
+    ): void;
+
+    /**
+     * Ensure that all the records necessary to fulfill the given selector are
+     * retained in-memory. The records will not be eligible for garbage collection
+     * until the returned reference is disposed.
+     */
+    retain(selector: Selector): Disposable;
+
+    /**
+     * Subscribe to changes to the results of a selector. The callback is called
+     * when `notify()` is called *and* records have been published that affect the
+     * selector results relative to the last `notify()`.
+     */
+    subscribe(
+      snapshot: Snapshot,
+      callback: (snapshot: Snapshot) => void
+    ): Disposable;
+  }
+
+  /**
+   * An interface for imperatively getting/setting properties of a `Record`. This interface
+   * is designed to allow the appearance of direct Record manipulation while
+   * allowing different implementations that may e.g. create a changeset of
+   * the modifications.
+   */
+  declare export interface RecordProxy {
+    copyFieldsFrom(source: RecordProxy): void;
+
+    getDataID(): DataID;
+
+    getLinkedRecord(name: string, args?: ?Variables): RecordProxy;
+
+    getLinkedRecords(name: string, args?: ?Variables): ?Array<?RecordProxy>;
+
+    getOrCreateLinkedRecord(
+      name: string,
+      typeName: string,
+      args?: ?Variables
+    ): RecordProxy;
+
+    getType(): string;
+
+    getValue(name: string, args?: ?Variables): mixed;
+
+    setLinkedRecord(
+      record: RecordProxy,
+      name: string,
+      args?: ?Variables
+    ): RecordProxy;
+
+    setLinkedRecords(
+      records: Array<?RecordProxy>,
+      name: string,
+      args?: ?Variables
+    ): RecordProxy;
+
+    setValue(value: mixed, name: string, args?: ?Variables): RecordProxy;
+  }
+
+  /**
+   * An interface for imperatively getting/setting properties of a `RecordSource`. This interface
+   * is designed to allow the appearance of direct RecordSource manipulation while
+   * allowing different implementations that may e.g. create a changeset of
+   * the modifications.
+   */
+  declare export interface RecordSourceProxy
+    extends IRecordSource<RecordProxy> {
+    create(dataID: DataID, typeName: string): RecordProxy;
+
+    delete(dataID: DataID): void;
+
+    get(dataID: DataID): ?RecordProxy;
+
+    getRoot(): RecordProxy;
+  }
+
+  /**
+   * Extends the RecordSourceProxy interface with methods for accessing the root
+   * fields of a Selector.
+   */
+  declare export interface RecordSourceSelectorProxy
+    extends IRecordSource<RecordProxy> {
+    create(dataID: DataID, typeName: string): RecordProxy;
+
+    delete(dataID: DataID): void;
+
+    get(dataID: DataID): ?RecordProxy;
+
+    getRoot(): RecordProxy;
+
+    getRootField(fieldName: string): RecordProxy;
+
+    getPluralRootField(fieldName: string): ?Array<?RecordProxy>;
+
+    getResponse(): ?Object;
+  }
+
+  declare export interface IRecordReader<TRecord> {
+    getDataID(record: TRecord): DataID;
+
+    getType(record: TRecord): string;
+
+    getValue(record: TRecord, name: string, args?: ?Variables): mixed;
+
+    getLinkedRecordID(
+      record: TRecord,
+      name: string,
+      args?: ?Variables
+    ): ?DataID;
+
+    getLinkedRecordIDs(
+      record: TRecord,
+      name: string,
+      args?: ?Variables
+    ): ?Array<?DataID>;
+  }
+
+  /**
+   * Settings for how a query response may be cached.
+   *
+   * - `force`: causes a query to be issued unconditionally, irrespective of the
+   *   state of any configured response cache.
+   * - `poll`: causes a query to live update by polling at the specified interval
+   in milliseconds. (This value will be passed to setTimeout.)
+   */
+  declare export type CacheConfig = {
+    force?: ?boolean,
+    poll?: ?number,
+    ...
+  };
+
+  /**
+   * Represents any resource that must be explicitly disposed of. The most common
+   * use-case is as a return value for subscriptions, where calling `dispose()`
+   * would cancel the subscription.
+   */
+  declare export type Disposable = { dispose(): void, ... };
+
+  /**
+   * Arbitrary data e.g. received by a container as props.
+   */
+  declare export type Props = { [key: string]: mixed, ... };
+
+  /*
+   * An individual cached graph object.
+   */
+  declare export type Record = { [key: string]: mixed, ... };
+
+  /**
+   * A collection of records keyed by id.
+   */
+  declare export type RecordMap<T> = { [dataID: DataID]: ?T, ... };
+
+  /**
+   * A selector defines the starting point for a traversal into the graph for the
+   * purposes of targeting a subgraph.
+   */
+  declare export type CSelector<TNode> = {
+    dataID: DataID,
+    node: TNode,
+    variables: Variables,
+    ...
+  };
+
+  /**
+   * A representation of a selector and its results at a particular point in time.
+   */
+  declare export type CSnapshot<TNode, TRecord> = CSelector<TNode> & {
+    data: ?SelectorData,
+    seenRecords: RecordMap<TRecord>,
+    ...
+  };
+
+  /**
+   * The results of a selector given a store/RecordSource.
+   */
+  declare export type SelectorData = { [key: string]: mixed, ... };
+
+  /**
+   * The results of reading the results of a FragmentMap given some input
+   * `Props`.
+   */
+  declare export type FragmentSpecResults = { [key: string]: mixed, ... };
+
+  /**
+   * A utility for resolving and subscribing to the results of a fragment spec
+   * (key -> fragment mapping) given some "props" that determine the root ID
+   * and variables to use when reading each fragment. When props are changed via
+   * `setProps()`, the resolver will update its results and subscriptions
+   * accordingly. Internally, the resolver:
+   * - Converts the fragment map & props map into a map of `Selector`s.
+   * - Removes any resolvers for any props that became null.
+   * - Creates resolvers for any props that became non-null.
+   * - Updates resolvers with the latest props.
+   */
+  declare export interface FragmentSpecResolver {
+    /**
+     * Stop watching for changes to the results of the fragments.
+     */
+    dispose(): void;
+
+    /**
+     * Get the current results.
+     */
+    resolve(): FragmentSpecResults;
+
+    /**
+     * Update the resolver with new inputs. Call `resolve()` to get the updated
+     * results.
+     */
+    setProps(props: Props): void;
+
+    /**
+     * Override the variables used to read the results of the fragments. Call
+     * `resolve()` to get the updated results.
+     */
+    setVariables(variables: Variables): void;
+  }
+
+  declare export type CFragmentMap<TFragment> = { [key: string]: TFragment, ... };
+
+  /**
+   * An operation selector describes a specific instance of a GraphQL operation
+   * with variables applied.
+   *
+   * - `root`: a selector intended for processing server results or retaining
+   *   response data in the store.
+   * - `fragment`: a selector intended for use in reading or subscribing to
+   *   the results of the the operation.
+   */
+  declare export type COperationSelector<TNode, TOperation> = {
+    fragment: CSelector<TNode>,
+    node: TOperation,
+    root: CSelector<TNode>,
+    variables: Variables,
+    ...
+  };
+
+  /**
+   * The public API of Relay core. Represents an encapsulated environment with its
+   * own in-memory cache.
+   */
+  declare export interface CEnvironment<
+    TEnvironment,
+    TFragment,
+    TGraphQLTaggedNode,
+    TNode,
+    TOperation,
+    TPayload
+  > {
+    /**
+     * Read the results of a selector from in-memory records in the store.
+     */
+    lookup(selector: CSelector<TNode>): CSnapshot<TNode>;
+
+    /**
+     * Subscribe to changes to the results of a selector. The callback is called
+     * when data has been committed to the store that would cause the results of
+     * the snapshot's selector to change.
+     */
+    subscribe(
+      snapshot: CSnapshot<TNode>,
+      callback: (snapshot: CSnapshot<TNode>) => void
+    ): Disposable;
+
+    /**
+     * Ensure that all the records necessary to fulfill the given selector are
+     * retained in-memory. The records will not be eligible for garbage collection
+     * until the returned reference is disposed.
+     *
+     * Note: This is a no-op in the classic core.
+     */
+    retain(selector: CSelector<TNode>): Disposable;
+
+    /**
+     * Send a query to the server with request/response semantics: the query will
+     * either complete successfully (calling `onNext` and `onCompleted`) or fail
+     * (calling `onError`).
+     *
+     * Note: Most applications should use `streamQuery` in order to
+     * optionally receive updated information over time, should that feature be
+     * supported by the network/server. A good rule of thumb is to use this method
+     * if you would otherwise immediately dispose the `streamQuery()`
+     * after receving the first `onNext` result.
+     */
+    sendQuery(config: {|
+      cacheConfig?: ?CacheConfig,
+      onCompleted?: ?() => void,
+      onError?: ?(error: Error) => void,
+      onNext?: ?(payload: TPayload) => void,
+      operation: COperationSelector<TNode, TOperation>
+    |}): Disposable;
+
+    /**
+     * Send a query to the server with request/subscription semantics: one or more
+     * responses may be returned (via `onNext`) over time followed by either
+     * the request completing (`onCompleted`) or an error (`onError`).
+     *
+     * Networks/servers that support subscriptions may choose to hold the
+     * subscription open indefinitely such that `onCompleted` is not called.
+     */
+    streamQuery(config: {|
+      cacheConfig?: ?CacheConfig,
+      onCompleted?: ?() => void,
+      onError?: ?(error: Error) => void,
+      onNext?: ?(payload: TPayload) => void,
+      operation: COperationSelector<TNode, TOperation>
+    |}): Disposable;
+
+    unstable_internal: CUnstableEnvironmentCore<
+      TEnvironment,
+      TFragment,
+      TGraphQLTaggedNode,
+      TNode,
+      TOperation
+    >;
+  }
+
+  declare export interface CUnstableEnvironmentCore<
+    TEnvironment,
+    TFragment,
+    TGraphQLTaggedNode,
+    TNode,
+    TOperation
+  > {
+    /**
+     * Create an instance of a FragmentSpecResolver.
+     *
+     * TODO: The FragmentSpecResolver *can* be implemented via the other methods
+     * defined here, so this could be moved out of core. It's convenient to have
+     * separate implementations until the experimental core is in OSS.
+     */
+    createFragmentSpecResolver: (
+      context: CRelayContext<TEnvironment>,
+      containerName: string,
+      fragments: CFragmentMap<TFragment>,
+      props: Props,
+      callback: () => void
+    ) => FragmentSpecResolver;
+
+    /**
+     * Creates an instance of an OperationSelector given an operation definition
+     * (see `getOperation`) and the variables to apply. The input variables are
+     * filtered to exclude variables that do not matche defined arguments on the
+     * operation, and default values are populated for null values.
+     */
+    createOperationSelector: (
+      operation: TOperation,
+      variables: Variables
+    ) => COperationSelector<TNode, TOperation>;
+
+    /**
+     * Given a graphql`...` tagged template, extract a fragment definition usable
+     * by this version of Relay core. Throws if the value is not a fragment.
+     */
+    getFragment: (node: TGraphQLTaggedNode) => TFragment;
+
+    /**
+     * Given a graphql`...` tagged template, extract an operation definition
+     * usable by this version of Relay core. Throws if the value is not an
+     * operation.
+     */
+    getOperation: (node: TGraphQLTaggedNode) => TOperation;
+
+    /**
+     * Determine if two selectors are equal (represent the same selection). Note
+     * that this function returns `false` when the two queries/fragments are
+     * different objects, even if they select the same fields.
+     */
+    areEqualSelectors: (a: CSelector<TNode>, b: CSelector<TNode>) => boolean;
+
+    /**
+     * Given the result `item` from a parent that fetched `fragment`, creates a
+     * selector that can be used to read the results of that fragment for that item.
+     *
+     * Example:
+     *
+     * Given two fragments as follows:
+     *
+     * ```
+     * fragment Parent on User {
+   *   id
+   *   ...Child
+   * }
+     * fragment Child on User {
+   *   name
+   * }
+     * ```
+     *
+     * And given some object `parent` that is the results of `Parent` for id "4",
+     * the results of `Child` can be accessed by first getting a selector and then
+     * using that selector to `lookup()` the results against the environment:
+     *
+     * ```
+     * const childSelector = getSelector(queryVariables, Child, parent);
+     * const childData = environment.lookup(childSelector).data;
+     * ```
+     */
+    getSelector: (
+      operationVariables: Variables,
+      fragment: TFragment,
+      prop: mixed
+    ) => ?CSelector<TNode>;
+
+    /**
+     * Given the result `items` from a parent that fetched `fragment`, creates a
+     * selector that can be used to read the results of that fragment on those
+     * items. This is similar to `getSelector` but for "plural" fragments that
+     * expect an array of results and therefore return an array of selectors.
+     */
+    getSelectorList: (
+      operationVariables: Variables,
+      fragment: TFragment,
+      props: Array<mixed>
+    ) => ?Array<CSelector<TNode>>;
+
+    /**
+     * Given a mapping of keys -> results and a mapping of keys -> fragments,
+     * extracts the selectors for those fragments from the results.
+     *
+     * The canonical use-case for this function are Relay Containers, which
+     * use this function to convert (props, fragments) into selectors so that they
+     * can read the results to pass to the inner component.
+     */
+    getSelectorsFromObject: (
+      operationVariables: Variables,
+      fragments: CFragmentMap<TFragment>,
+      props: Props
+    ) => { [key: string]: ?(CSelector<TNode> | Array<CSelector<TNode>>), ... };
+
+    /**
+     * Given a mapping of keys -> results and a mapping of keys -> fragments,
+     * extracts a mapping of keys -> id(s) of the results.
+     *
+     * Similar to `getSelectorsFromObject()`, this function can be useful in
+     * determining the "identity" of the props passed to a component.
+     */
+    getDataIDsFromObject: (
+      fragments: CFragmentMap<TFragment>,
+      props: Props
+    ) => { [key: string]: ?(DataID | Array<DataID>), ... };
+
+    /**
+     * Given a mapping of keys -> results and a mapping of keys -> fragments,
+     * extracts the merged variables that would be in scope for those
+     * fragments/results.
+     *
+     * This can be useful in determing what varaibles were used to fetch the data
+     * for a Relay container, for example.
+     */
+    getVariablesFromObject: (
+      operationVariables: Variables,
+      fragments: CFragmentMap<TFragment>,
+      props: Props
+    ) => Variables;
+  }
+
+  /**
+   * The type of the `relay` property set on React context by the React/Relay
+   * integration layer (e.g. QueryRenderer, FragmentContainer, etc).
+   */
+  declare export type CRelayContext<TEnvironment> = {
+    environment: TEnvironment,
+    variables: Variables,
+    ...
+  };
+
+  /**
+   * The public API of Relay core. Represents an encapsulated environment with its
+   * own in-memory cache.
+   */
+  declare export interface Environment
+    extends CEnvironment<
+      TEnvironment,
+      TFragment,
+      TGraphQLTaggedNode,
+      TNode,
+      TOperation,
+      TPayload
+    > {
+    /**
+     * Applies an optimistic mutation to the store without committing it to the
+     * server. The returned Disposable can be used to revert this change at a
+     * later time.
+     */
+    applyMutation(config: {|
+      configs: Array<RelayMutationConfig>,
+      operation: ConcreteOperationDefinition,
+      optimisticResponse: Object,
+      variables: Variables
+    |}): Disposable;
+
+    /**
+     * Applies an optimistic mutation if provided and commits the mutation to the
+     * server. The returned Disposable can be used to bypass the `onCompleted`
+     * and `onError` callbacks when the server response is returned.
+     */
+    sendMutation<ResponseType>(config: {|
+      configs: Array<RelayMutationConfig>,
+      onCompleted?: ?(response: ResponseType) => void,
+      onError?: ?(error: Error) => void,
+      operation: ConcreteOperationDefinition,
+      optimisticOperation?: ?ConcreteOperationDefinition,
+      optimisticResponse?: ?Object,
+      variables: Variables,
+      uploadables?: UploadableMap
+    |}): Disposable;
+  }
+
+  declare export type Observer<T> = {
+    onCompleted?: ?() => void,
+    onError?: ?(error: Error) => void,
+    onNext?: ?(data: T) => void,
+    ...
+  };
+
+  /**
+   * The results of reading data for a fragment. This is similar to a `Selector`,
+   * but references the (fragment) node by name rather than by value.
+   */
+  declare export type FragmentPointer = {
+    __id: DataID,
+    __fragments: { [fragmentName: string]: Variables, ... },
+    ...
+  };
+
+  /**
+   * A callback for resolving a Selector from a source.
+   */
+  declare export type AsyncLoadCallback = (loadingState: LoadingState) => void;
+  declare export type LoadingState = $Exact<{
+    status: "aborted" | "complete" | "error" | "missing",
+    error?: Error,
+    ...
+  }>;
+
+  /**
+   * A map of records affected by an update operation.
+   */
+  declare export type UpdatedRecords = { [dataID: DataID]: boolean, ... };
+
+  /**
+   * A function that updates a store (via a proxy) given the results of a "handle"
+   * field payload.
+   */
+  declare export type Handler = { update: (store: RecordSourceProxy, fieldPayload: HandleFieldPayload) => void, ... };
+
+  /**
+   * A payload that is used to initialize or update a "handle" field with
+   * information from the server.
+   */
+  declare export type HandleFieldPayload = $Exact<{
+    // The arguments that were fetched.
+    args: Variables,
+    // The __id of the record containing the source/handle field.
+    dataID: DataID,
+    // The (storage) key at which the original server data was written.
+    fieldKey: string,
+    // The name of the handle.
+    handle: string,
+    // The (storage) key at which the handle's data should be written by the
+    // handler.
+    handleKey: string,
+    ...
+  }>;
+
+  /**
+   * A function that receives a proxy over the store and may trigger side-effects
+   * (indirectly) by calling `set*` methods on the store or its record proxies.
+   */
+  declare export type StoreUpdater = (store: RecordSourceProxy) => void;
+
+  /**
+   * Similar to StoreUpdater, but accepts a proxy tied to a specific selector in
+   * order to easily access the root fields of a query/mutation.
+   */
+  declare export type SelectorStoreUpdater = (
+    store: RecordSourceSelectorProxy
+  ) => void;
+
+  declare export type CallValue = ?(
+    | (boolean | number | string | { [key: string]: CallValue, ... } | Array<CallValue>));
+
+  declare export type RangeBehaviorsFunction = (connectionArgs: { [argName: string]: CallValue, ... }) =>
+    | "APPEND"
+    | "IGNORE"
+    | "PREPEND"
+    | "REFETCH"
+    | "REMOVE"
+    | "NODE_DELETE_HANDLER"
+    | "RANGE_ADD_HANDLER"
+    | "RANGE_DELETE_HANDLER"
+    | "HANDLER_TYPES"
+    | "OPTIMISTIC_UPDATE"
+    | "SERVER_UPDATE"
+    | "POLLER_UPDATE"
+    | "UPDATE_TYPES"
+    | "RANGE_OPERATIONS";
+
+  declare export type RangeBehaviorsObject = { [key: string]: "APPEND" | "IGNORE" | "PREPEND" | "REFETCH" | "REMOVE", ... };
+
+  declare export type RangeBehaviors =
+    | RangeBehaviorsFunction
+    | RangeBehaviorsObject;
+
+  declare export type RelayConcreteNode = mixed;
+
+  declare export type RelayMutationConfig =
+    | {
+    type: "FIELDS_CHANGE",
+    fieldIDs: { [fieldName: string]: DataID | Array<DataID>, ... },
+    ...
+  }
+    | {
+    type: "RANGE_ADD",
+    parentName?: string,
+    parentID?: string,
+    connectionInfo?: Array<{
+      key: string,
+      filters?: Variables,
+      rangeBehavior: string,
+      ...
+    }>,
+    connectionName?: string,
+    edgeName: string,
+    rangeBehaviors?: RangeBehaviors,
+    ...
+  }
+    | {
+    type: "NODE_DELETE",
+    parentName?: string,
+    parentID?: string,
+    connectionName?: string,
+    deletedIDFieldName: string,
+    ...
+  }
+    | {
+    type: "RANGE_DELETE",
+    parentName?: string,
+    parentID?: string,
+    connectionKeys?: Array<{
+      key: string,
+      filters?: Variables,
+      ...
+    }>,
+    connectionName?: string,
+    deletedIDFieldName: string | Array<string>,
+    pathToConnection: Array<string>,
+    ...
+  }
+    | {
+    type: "REQUIRED_CHILDREN",
+    children: Array<RelayConcreteNode>,
+    ...
+  };
+
+  declare export type MutationConfig<T> = {|
+    configs?: Array<RelayMutationConfig>,
+    mutation: GraphQLTaggedNode,
+    variables: Variables,
+    uploadables?: UploadableMap,
+    onCompleted?: ?(response: T, errors: ?Array<PayloadError>) => void,
+    onError?: ?(error: Error) => void,
+    optimisticUpdater?: ?SelectorStoreUpdater,
+    optimisticResponse?: Object,
+    updater?: ?SelectorStoreUpdater
+  |};
+
+  // a.k.a commitRelayModernMutation
+  declare export function commitMutation<T>(
+    environment: Environment,
+    config: MutationConfig<T>
+  ): Disposable;
+
+  declare export type ReadyState = {
+    error: ?Error,
+    props: ?Object,
+    retry: ?() => void,
+    ...
+  };
+
+  /**
+   * Classic environment below here
+   */
+  declare export class RelayQueryFragment {
+    // stub
+  }
+
+  declare export class RelayQueryNode {
+    // stub
+  }
+
+  declare export class RelayQueryRoot {
+    // stub
+  }
+
+  declare export class RelayStoreData {
+    // stub
+  }
+
+  declare export type RelayQuerySet = { [queryName: string]: ?RelayQueryRoot, ... };
+  declare export type ReadyStateChangeCallback = (
+    readyState: ReadyState
+  ) => void;
+  declare export type Abortable = { abort(): void, ... };
+  declare export type StoreReaderData = Object;
+  declare export type StoreReaderOptions = {
+    traverseFragmentReferences?: boolean,
+    traverseGeneratedFields?: boolean,
+    ...
+  };
+  declare export type FragmentResolver = {
+    dispose(): void,
+    resolve(
+      fragment: RelayQueryFragment,
+      dataIDs: DataID | Array<DataID>
+    ): ?(StoreReaderData | Array<?StoreReaderData>),
+    ...
+  };
+
+  declare export interface RelayEnvironmentInterface {
+    forceFetch(
+      querySet: RelayQuerySet,
+      onReadyStateChange: ReadyStateChangeCallback
+    ): Abortable;
+    getFragmentResolver(
+      fragment: RelayQueryFragment,
+      onNext: () => void
+    ): FragmentResolver;
+    getStoreData(): RelayStoreData;
+    primeCache(
+      querySet: RelayQuerySet,
+      onReadyStateChange: ReadyStateChangeCallback
+    ): Abortable;
+    read(
+      node: RelayQueryNode,
+      dataID: DataID,
+      options?: StoreReaderOptions
+    ): ?StoreReaderData;
+    readQuery(
+      root: RelayQueryRoot,
+      options?: StoreReaderOptions
+    ): Array<?StoreReaderData>;
+  }
+
+  declare export type ClassicEnvironment = RelayEnvironmentInterface;
+
+  declare export type QueryRendererPropType = {
+    cacheConfig?: ?CacheConfig,
+    dataFrom?: $Keys<{
+      NETWORK_ONLY: 'NETWORK_ONLY',
+      STORE_THEN_NETWORK: 'STORE_THEN_NETWORK',
+      ...
+    }>,
+    environment: Environment | ClassicEnvironment,
+    query: ?GraphQLTaggedNode,
+    render: (readyState: ReadyState) => ?React$Element<any>,
+    variables: Variables,
+    ...
+  };
+
+  declare export class QueryRenderer extends React$Component<QueryRendererPropType> {}
+
+  // https://github.com/facebook/relay/blob/master/packages/relay-runtime/network/RelayNetworkTypes.js
+  /**
+   * A cache for saving respones to queries (by id) and variables.
+   */
+  declare export interface ResponseCache {
+    get(id: string, variables: Variables): ?QueryPayload;
+    set(id: string, variables: Variables, payload: QueryPayload): void;
+  }
+
+  /**
+   * An interface for fetching the data for one or more (possibly interdependent)
+   * queries.
+   */
+  declare export interface Network {
+    fetch: FetchFunction;
+    request: RequestResponseFunction;
+    requestStream: RequestStreamFunction;
+  }
+
+  declare export type PayloadData = { [key: string]: mixed, ... };
+
+  declare export type PayloadError = {
+    message: string,
+    locations?: Array<{
+      line: number,
+      column: number,
+      ...
+    }>,
+    ...
+  };
+
+  /**
+   * The shape of a GraphQL response as dictated by the
+   * [spec](http://facebook.github.io/graphql/#sec-Response)
+   */
+  declare export type QueryPayload = {|
+    data?: ?PayloadData,
+    errors?: Array<PayloadError>,
+    rerunVariables?: Variables
+  |};
+
+  /**
+   * The shape of data that is returned by the Relay network layer for a given
+   * query.
+   */
+  declare export type RelayResponsePayload = {|
+    fieldPayloads?: ?Array<HandleFieldPayload>,
+    source: MutableRecordSource,
+    errors: ?Array<PayloadError>
+  |};
+
+  declare export type PromiseOrValue<T> = Promise<T> | T | Error;
+
+  /**
+   * A function that executes a GraphQL operation with request/response semantics,
+   * with exactly one raw server response returned
+   */
+  declare export type FetchFunction = (
+    operation: ConcreteBatch,
+    variables: Variables,
+    cacheConfig: ?CacheConfig,
+    uploadables?: UploadableMap
+  ) => PromiseOrValue<QueryPayload>;
+
+  /**
+   * A function that executes a GraphQL operation with request/subscription
+   * semantics, returning one or more raw server responses over time.
+   */
+  declare export type SubscribeFunction = (
+    operation: ConcreteBatch,
+    variables: Variables,
+    cacheConfig: ?CacheConfig,
+    observer: Observer<QueryPayload>
+  ) => Disposable;
+
+  /**
+   * A function that executes a GraphQL operation with request/subscription
+   * semantics, returning one or more responses over time that include the
+   * initial result and optional updates e.g. as the results of the operation
+   * change.
+   */
+  declare export type RequestStreamFunction = (
+    operation: ConcreteBatch,
+    variables: Variables,
+    cacheConfig: ?CacheConfig,
+    observer: Observer<RelayResponsePayload>
+  ) => Disposable;
+
+  /**
+   * A function that executes a GraphQL operation with request/response semantics,
+   * with exactly one response returned.
+   */
+  declare export type RequestResponseFunction = (
+    operation: ConcreteBatch,
+    variables: Variables,
+    cacheConfig?: ?CacheConfig,
+    uploadables?: UploadableMap
+  ) => PromiseOrValue<RelayResponsePayload>;
+
+  declare export type Uploadable = File | Blob;
+  declare export type UploadableMap = { [key: string]: Uploadable, ... };
+
+  declare export type RerunParam = {
+    param: string,
+    import: string,
+    max_runs: number,
+    ...
+  };
+
+  declare export type RelayProp = { environment: Environment, ... };
+
+  declare export type RelayPaginationProp = RelayProp & {
+    hasMore: () => boolean,
+    isLoading: () => boolean,
+    loadMore: (
+      pageSize: number,
+      callback: (error: ?Error) => void,
+      options?: RefetchOptions
+    ) => ?Disposable,
+    refetchConnection: (
+      totalCount: number,
+      callback: (error: ?Error) => void,
+      refetchVariables: ?Variables
+    ) => ?Disposable,
+    ...
+  };
+
+  declare export type RelayRefetchProp = RelayProp & { refetch: (
+    refetchVariables:
+      | Variables
+      | ((fragmentVariables: Variables) => Variables),
+    renderVariables: ?Variables,
+    callback: ?(error: ?Error) => void,
+    options?: RefetchOptions
+  ) => Disposable, ... };
+
+  declare export type RefetchOptions = {
+    force?: boolean,
+    rerunParamExperimental?: RerunParam,
+    ...
+  };
+}
+
+declare module "react-relay/compat" {
+  declare module.exports: any;
+}
+
+declare module "react-relay/classic" {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/assertFragmentMap' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/buildReactRelayContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/buildRQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/callsFromGraphQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/callsToGraphQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/checkRelayQueryData' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ConcreteQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/containsRelayQueryRootCall' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/createRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/dedent' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/deepFreeze' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/diffRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/directivesToGraphQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/filterExclusiveKeys' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/filterRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/findRelayQueryLeaves' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/flattenRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/flattenSplitRelayQueries' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ForceRelayClassicContext' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/forEachRootCallArg' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/formatStorageKey' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/fromGraphQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/generateClientEdgeID' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/generateClientID' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/generateConcreteFragmentID' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/generateForceIndex' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/generateRQLFieldAlias' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/getRangeBehavior' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/getRelayHandleKey' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/getRelayQueries' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLMutatorConstants' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLQueryRunner' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLRange' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLSegment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLStoreChangeEmitter' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLStoreQueryResolver' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/GraphQLStoreRangeUtils' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/intersectRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isClassicRelayContext' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isClassicRelayEnvironment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isCompatibleRelayFragmentType' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isRelayContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isRelayContext' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isRelayEnvironment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isRelayModernContext' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isRelayVariables' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/isScalarAndEqual' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/prettyStringify' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/printRelayOSSQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/printRelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/QueryBuilder' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/rangeOperationToMetadataKey' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayClassicExports' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayCompatContainerBuilder' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayCompatPublic' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayContainerProfiler' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayFragmentContainer-flowtest' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayFragmentContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayFragmentMockRenderer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayPaginationContainer-flowtest' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayPaginationContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayPropTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayPublic' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayQueryRenderer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayRefetchContainer-flowtest' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayRefetchContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/ReactRelayTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/readRelayQueryData' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/recycleNodesInto' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCacheProcessor' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayChangeTracker' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayClassicCore' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayClassicRecordState' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCombinedEnvironmentTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatEnvironment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatMutations' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatPaginationContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatRefetchContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayCompatTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayConcreteNode' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayConnectionInterface' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayContainerComparators' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayContainerProxy' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayContainerUtils' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayDefaultHandleKey' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayDefaultNetworkLayer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayEnvironment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayEnvironmentSerializer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayEnvironmentTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayError' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayEventStatus' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayFetchMode' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayFragmentPointer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayFragmentReference' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayFragmentSpecResolver' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayGarbageCollection' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayGarbageCollector' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayGraphQLMutation' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayGraphQLTag' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayInternals' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayInternalTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMetaRoute' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMetricsRecorder' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMockRenderer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutation' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationDebugPrinter' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationQueue' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationRequest' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationTracker' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationTransaction' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationTransactionStatus' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayMutationType' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayNetworkDebug' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayNetworkLayer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayNodeInterface' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayOperationSelector' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayOptimisticMutationUtils' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayOSSConnectionInterface' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayPendingQueryTracker' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayProfiler' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayPropTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayPublic' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQL_GENERATED' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryCaching' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryConfig' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryPath' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryRequest' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryResultObservable' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryTracker' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryTransform' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryVisitor' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayQueryWriter' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayReadyState' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayReadyStateRenderer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRecord' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRecordStatusMap' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRecordStore' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRecordWriter' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRefQueryDescriptor' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRenderer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRootContainer' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRoute' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayRouteFragment' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelaySelector' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayShallowMock' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayStore' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayStoreConstants' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayStoreData' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayTaskQueue' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayTypes' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/relayUnstableBatchedUpdates' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/relayUnstableBatchedUpdates.native' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayVariable' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/RelayVariables' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/restoreRelayCacheData' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/serializeRelayQueryCall' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/simpleClone' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/splitDeferredRelayQueries' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/stableJSONStringify' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/stableStringify' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/testEditDistance' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/throwFailedPromise' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/toGraphQL' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/transformRelayQueryPayload' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/validateMutationConfig' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/validateRelayReadQuery' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/writeRelayQueryPayload' {
+  declare module.exports: any;
+}
+
+declare module 'react-relay/lib/writeRelayUpdatePayload' {
+  declare module.exports: any;
+}
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_Variables.js b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_Variables.js
new file mode 100644
index 0000000000..a310f7cab4
--- /dev/null
+++ b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_Variables.js
@@ -0,0 +1,8 @@
+/* @flow */
+import { type Variables } from "react-relay";
+
+const variables: Variables = {
+  arrayTypeString: ["test0", "test1", "test2"],
+  arrayTypeInt: [0, 1, 2],
+  arrayTypeObj: [{ attr0: 0, attr1: 0 }, { attr0: 1, attr1: 1 }]
+};
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_classic.js b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_classic.js
new file mode 100644
index 0000000000..3a5ce7a369
--- /dev/null
+++ b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_classic.js
@@ -0,0 +1,14 @@
+/* @flow */
+import Relay from "react-relay/classic";
+
+const Comp = () => <span>component</span>;
+
+const CompFragmentContainer = Relay.createContainer(Comp, {
+  fragments: {
+    viewer: Relay.graphql`
+      fragment Comp_viewer on Viewer {
+        id
+      }
+    `
+  }
+});
diff --git a/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_fragmentContainer.js b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_fragmentContainer.js
new file mode 100644
index 0000000000..57cdd46342
--- /dev/null
+++ b/definitions/npm/react-relay_v1.x.x/flow_v0.201.x-/test_fragmentContainer.js
@@ -0,0 +1,12 @@
+/* @flow */
+import { graphql, createFragmentContainer } from "react-relay";
+
+const Comp = () => <span>component</span>;
+
+const CompFragmentContainer = createFragmentContainer(Comp, {
+  viewer: graphql`
+    fragment Comp_viewer on Viewer {
+      id
+    }
+  `
+});
diff --git a/definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-/react-router-dom_v4.x.x.js b/definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-v.200.x/react-router-dom_v4.x.x.js
similarity index 100%
rename from definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-/react-router-dom_v4.x.x.js
rename to definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-v.200.x/react-router-dom_v4.x.x.js
diff --git a/definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-v.200.x/test_react-router-dom.js
similarity index 100%
rename from definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-/test_react-router-dom.js
rename to definitions/npm/react-router-dom_v4.x.x/flow_v0.104.x-v.200.x/test_react-router-dom.js
diff --git a/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/react-router-dom_v4.x.x.js b/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/react-router-dom_v4.x.x.js
new file mode 100644
index 0000000000..9cd649c776
--- /dev/null
+++ b/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/react-router-dom_v4.x.x.js
@@ -0,0 +1,179 @@
+declare module "react-router-dom" {
+  declare export var BrowserRouter: React$ComponentType<{|
+    basename?: string,
+    forceRefresh?: boolean,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node
+  |}>
+
+  declare export var HashRouter: React$ComponentType<{|
+    basename?: string,
+    getUserConfirmation?: GetUserConfirmation,
+    hashType?: "slash" | "noslash" | "hashbang",
+    children?: React$Node
+  |}>
+
+  declare export var Link: React$ComponentType<{
+    +className?: string,
+    +to: string | LocationShape,
+    +replace?: boolean,
+    +children?: React$Node,
+    ...
+  }>
+
+  declare export var NavLink: React$ComponentType<{
+    +to: string | LocationShape,
+    +activeClassName?: string,
+    +className?: string,
+    +activeStyle?: Object,
+    +style?: Object,
+    +isActive?: (match: Match, location: Location) => boolean,
+    +children?: React$Node,
+    +exact?: boolean,
+    +strict?: boolean,
+    ...
+  }>
+
+  // NOTE: Below are duplicated from react-router. If updating these, please
+  // update the react-router and react-router-native types as well.
+  declare export type Location = {
+    pathname: string,
+    search: string,
+    hash: string,
+    state?: any,
+    key?: string,
+    ...
+  };
+
+  declare export type LocationShape = {
+    pathname?: string,
+    search?: string,
+    hash?: string,
+    state?: any,
+    ...
+  };
+
+  declare export type HistoryAction = "PUSH" | "REPLACE" | "POP";
+
+  declare export type RouterHistory = {
+    length: number,
+    location: Location,
+    action: HistoryAction,
+    listen(
+      callback: (location: Location, action: HistoryAction) => void
+    ): () => void,
+    push(path: string | LocationShape, state?: any): void,
+    replace(path: string | LocationShape, state?: any): void,
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    canGo?: (n: number) => boolean,
+    block(
+      callback: string | (location: Location, action: HistoryAction) => ?string
+    ): () => void,
+    // createMemoryHistory
+    index?: number,
+    entries?: Array<Location>,
+    ...
+  };
+
+  declare export type Match = {
+    params: { [key: string]: ?string, ... },
+    isExact: boolean,
+    path: string,
+    url: string,
+    ...
+  };
+
+  declare export type ContextRouter = {|
+    history: RouterHistory,
+    location: Location,
+    match: Match,
+    staticContext?: StaticRouterContext
+  |};
+
+  declare type ContextRouterVoid = {
+    history: RouterHistory | void,
+    location: Location | void,
+    match: Match | void,
+    staticContext?: StaticRouterContext | void,
+    ...
+  };
+
+  declare export type GetUserConfirmation = (
+    message: string,
+    callback: (confirmed: boolean) => void
+  ) => void;
+
+  declare export type StaticRouterContext = { url?: string, ... };
+
+  declare export var StaticRouter: React$ComponentType<{|
+    basename?: string,
+    location?: string | Location,
+    context: StaticRouterContext,
+    children?: React$Node
+  |}>
+
+  declare export var MemoryRouter: React$ComponentType<{|
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node
+  |}>
+
+  declare export var Router: React$ComponentType<{|
+    history: RouterHistory,
+    children?: React$Node
+  |}>
+
+  declare export var Prompt: React$ComponentType<{|
+    message: string | ((location: Location) => string | boolean),
+    when?: boolean
+  |}>
+
+  declare export var Redirect: React$ComponentType<{|
+    to: string | LocationShape,
+    push?: boolean,
+    from?: string,
+    exact?: boolean,
+    strict?: boolean
+  |}>
+
+  declare export var Route: React$ComponentType<{|
+    component?: React$ComponentType<any>,
+    render?: (router: ContextRouter) => React$Node,
+    children?: React$ComponentType<ContextRouter> | React$Node,
+    path?: string | Array<string>,
+    exact?: boolean,
+    strict?: boolean,
+    location?: LocationShape,
+    sensitive?: boolean
+  |}>
+
+  declare export var Switch: React$ComponentType<{|
+    children?: React$Node,
+    location?: Location
+  |}>
+
+  declare export function withRouter<Props: {...}, Component: React$ComponentType<Props>>(
+    WrappedComponent: Component
+  ): React$ComponentType<$Diff<React$ElementConfig<Component>, ContextRouterVoid>>;
+
+  declare type MatchPathOptions = {
+    path?: string,
+    exact?: boolean,
+    sensitive?: boolean,
+    strict?: boolean,
+    ...
+  };
+
+  declare export function matchPath(
+    pathname: string,
+    options?: MatchPathOptions | string,
+    parent?: Match
+  ): null | Match;
+
+  declare export function generatePath(pattern?: string, params?: Object): string;
+}
diff --git a/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/test_react-router-dom.js
new file mode 100644
index 0000000000..8ba696a7bf
--- /dev/null
+++ b/definitions/npm/react-router-dom_v4.x.x/flow_v0.201.x-/test_react-router-dom.js
@@ -0,0 +1,390 @@
+// @flow
+import React from "react";
+import {
+  BrowserRouter,
+  HashRouter,
+  Link,
+  NavLink,
+  matchPath,
+  withRouter,
+  Redirect,
+  Route
+} from "react-router-dom";
+import type {
+  ContextRouter,
+  Match,
+  StaticRouterContext,
+  RouterHistory
+} from "react-router-dom";
+import { it, describe } from "flow-typed-test";
+
+describe("react-router-dom", () => {
+  describe("BrowserRouter", () => {
+    it("works", () => {
+      <BrowserRouter>
+        <div />
+      </BrowserRouter>;
+
+      <BrowserRouter
+        basename="/base"
+        forceRefresh
+        getUserConfirmation={(message, callback) => {}}
+        keyLength={3}
+      >
+        <div />
+      </BrowserRouter>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - basename must be a string
+      <BrowserRouter basename={{}} />;
+    });
+  });
+
+  describe("HashRouter", () => {
+    it("works", () => {
+      <HashRouter>
+        <div />
+      </HashRouter>;
+
+      <HashRouter
+        basename="/base"
+        getUserConfirmation={(message, callback) => {}}
+        hashType="noslash"
+      >
+        <div />
+      </HashRouter>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - hashType must be a string
+      <HashRouter hashType="magic" />;
+    });
+  });
+
+  describe("<Link />", () => {
+    it("works", () => {
+      <Link to="/about">About</Link>;
+
+      <Link replace to="/about">
+        About
+      </Link>;
+
+      <Link
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+      >
+        About
+      </Link>;
+    });
+
+    it("allows attributes of <a> element", () => {
+      <Link
+        to="/about"
+        download
+        hreflang="de"
+        ping="https://www.example.com"
+        referrerpolicy="no-referrer"
+        target="_self"
+        type="foo"
+        onClick={() => {}}
+      >About</Link>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <Link />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <Link to={[]} />;
+    });
+  });
+
+  describe("<NavLink />", () => {
+    it("works", () => {
+      <NavLink to="/about">About</NavLink>;
+
+      <NavLink
+        to="/about"
+        activeClassName="active"
+        className="link"
+        activeStyle={{ color: "red" }}
+        style={{ color: "blue" }}
+        isActive={(match, location) => true}
+        strict
+        exact
+      >
+        About
+      </NavLink>;
+
+      <NavLink
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+      >
+        About
+      </NavLink>;
+    });
+
+    it("allows attributes of <a> element", () => {
+      <NavLink
+        to="/about"
+        download
+        hreflang="de"
+        ping="https://www.example.com"
+        referrerpolicy="no-referrer"
+        target="_self"
+        type="foo"
+        onClick={() => {}}
+      >About</NavLink>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <NavLink />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <NavLink to={[]} />;
+    });
+  });
+
+  describe("matchPath", () => {
+    it("works", () => {
+      const match: null | Match = matchPath("/the/pathname", {
+        path: "/the/:dynamicId",
+        exact: true,
+        strict: false
+      });
+      const match2: null | Match = matchPath("/the/pathname", {
+        path: "/the/:dynamicId"
+      });
+      const match3: null | Match = matchPath("/the/pathname");
+    });
+
+    it("raises an error if passed invalid argument", () => {
+      // $FlowExpectedError[incompatible-call] - pathname argument is required
+      matchPath();
+
+      // $FlowExpectedError[incompatible-type] - matchPath returns Match or null
+      const matchError: string = matchPath("/the/pathname", {
+        path: "the/:dynamicId"
+      });
+    });
+  });
+
+  describe("withRouter", () => {
+    type Props = {
+      history: RouterHistory,
+      location: Location,
+      match: Match,
+      staticContext: StaticRouterContext,
+      s: string,
+      ...
+    };
+    describe("Stateless Functional Components", () => {
+      it("passes if the component is passed required props", () => {
+        const Comp = ({
+          history,
+          location,
+          match,
+          staticContext,
+          s
+        }: Props) => <div />;
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if the component is not passed correct props", () => {
+        const Comp = ({
+          history,
+          location,
+          match,
+          staticContext,
+          s
+        }: Props) => <div />;
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <WrappedComp />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={1} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <ChainedHOC />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={1} />;
+      });
+
+      it("errors if trying to access a prop that withRouter does not supply", () => {
+        const Comp = ({ histry, s }: {
+          histry: RouterHistory,
+          s: string,
+          ...
+        }) => (
+          <div />
+        );
+        const WrappedComp = withRouter(Comp);
+      });
+
+      it("errors if using block() incorrectly", () => {
+        const Comp = ({history}: { history: RouterHistory, ... }) => {
+          // $FlowExpectedError[incompatible-call] - wrong param
+          history.block(false);
+
+          // These are valid
+          history.block('Are you sure you want to leave this page?');
+          history.block((location, action) => {
+            return 'Are you sure you want to leave this page?';
+          });
+
+          return <div />;
+        };
+        const WrappedComp = withRouter(Comp);
+      });
+    });
+
+    describe("Class Components", () => {
+      it("passes if the component is passed required props", () => {
+        class Comp extends React.Component<Props> {
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if the component is not passed the correct props", () => {
+        class Comp extends React.Component<Props> {
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <WrappedComp />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={1} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <ChainedHOC />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={1} />;
+      });
+
+      it("passes if a required prop is handled by defaultProps", () => {
+        class Comp extends React.Component<Props> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp />;
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC />;
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if a required prop that has a defaultProp is passed the wrong type", () => {
+        class Comp extends React.Component<Props> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={123} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={123} />;
+      });
+    });
+  });
+
+  describe("Redirect", () => {
+    it("works", () => {
+      <Redirect to="/login" />;
+
+      <Redirect exact strict to="/new-path" from="/old-Path" />;
+
+      <Redirect
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+        from="/x"
+        push
+      />;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <Redirect />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <Redirect to={[]} />;
+
+      // $FlowExpectedError[prop-missing] - unexpected prop xxx
+      <Redirect to='/x' xxx="1"/>;
+    });
+  });
+
+  describe("Route", () => {
+    it("works", () => {
+      const Component = ({}) => <div>Hi!</div>;
+      <Route path="/login" />;
+
+      <Route path={["/login", "/logout"]} />;
+
+      <Route path="/login" component={Component} />;
+
+      <Route path="/login" render={(context: ContextRouter) => <Component />} />;
+
+      <Route path="/login" children={(context: ContextRouter) => <Component />} />;
+
+      <Route
+        location={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash"
+        }}
+        exact
+        strict
+        sensitive
+      />;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - prop must be a string
+      <Route path={123} />;
+
+      // $FlowExpectedError[prop-missing] - unexpected prop xxx
+      <Route xxx="1" />;
+    });
+  })
+});
diff --git a/definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-/react-router-dom_v5.x.x.js b/definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-v.200.x/react-router-dom_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-/react-router-dom_v5.x.x.js
rename to definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-v.200.x/react-router-dom_v5.x.x.js
diff --git a/definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-v.200.x/test_react-router-dom.js
similarity index 100%
rename from definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-/test_react-router-dom.js
rename to definitions/npm/react-router-dom_v5.x.x/flow_v0.104.x-v.200.x/test_react-router-dom.js
diff --git a/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/react-router-dom_v5.x.x.js b/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/react-router-dom_v5.x.x.js
new file mode 100644
index 0000000000..b33030e1f0
--- /dev/null
+++ b/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/react-router-dom_v5.x.x.js
@@ -0,0 +1,181 @@
+declare module "react-router-dom" {
+  declare export var BrowserRouter: React$ComponentType<{|
+    basename?: string,
+    forceRefresh?: boolean,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node
+  |}>
+
+  declare export var HashRouter: React$ComponentType<{|
+    basename?: string,
+    getUserConfirmation?: GetUserConfirmation,
+    hashType?: "slash" | "noslash" | "hashbang",
+    children?: React$Node
+  |}>
+
+  declare export var Link: React$ComponentType<{
+    +className?: string,
+    +to: string | LocationShape,
+    +replace?: boolean,
+    +children?: React$Node,
+    ...
+  }>
+
+  declare export var NavLink: React$ComponentType<{
+    +to: string | LocationShape,
+    +activeClassName?: string,
+    +className?: string,
+    +activeStyle?: { +[string]: mixed, ... },
+    +style?: { +[string]: mixed, ... },
+    +isActive?: (match: Match, location: Location) => boolean,
+    +children?: React$Node,
+    +exact?: boolean,
+    +strict?: boolean,
+    ...
+  }>
+
+  // NOTE: Below are duplicated from react-router. If updating these, please
+  // update the react-router and react-router-native types as well.
+  declare export type Location = $ReadOnly<{
+    pathname: string,
+    search: string,
+    hash: string,
+    state?: any,
+    key?: string,
+    ...
+  }>;
+
+  declare export type LocationShape = {
+    pathname?: string,
+    search?: string,
+    hash?: string,
+    state?: any,
+    ...
+  };
+
+  declare export type HistoryAction = "PUSH" | "REPLACE" | "POP";
+
+  declare export type RouterHistory = {
+    length: number,
+    location: Location,
+    action: HistoryAction,
+    listen(
+      callback: (location: Location, action: HistoryAction) => void
+    ): () => void,
+    push(path: string | LocationShape, state?: any): void,
+    replace(path: string | LocationShape, state?: any): void,
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    canGo?: (n: number) => boolean,
+    block(
+      callback: string | (location: Location, action: HistoryAction) => ?string
+    ): () => void,
+    ...
+  };
+
+  declare export type Match = {
+    params: { [key: string]: ?string, ... },
+    isExact: boolean,
+    path: string,
+    url: string,
+    ...
+  };
+
+  declare export type ContextRouter = {|
+    history: RouterHistory,
+    location: Location,
+    match: Match,
+    staticContext?: StaticRouterContext
+  |};
+
+  declare type ContextRouterVoid = {
+    history: RouterHistory | void,
+    location: Location | void,
+    match: Match | void,
+    staticContext?: StaticRouterContext | void,
+    ...
+  };
+
+  declare export type GetUserConfirmation = (
+    message: string,
+    callback: (confirmed: boolean) => void
+  ) => void;
+
+  declare export type StaticRouterContext = { url?: string, ... };
+
+  declare export var StaticRouter: React$ComponentType<{|
+    basename?: string,
+    location?: string | Location,
+    context: StaticRouterContext,
+    children?: React$Node
+  |}>
+
+  declare export var MemoryRouter: React$ComponentType<{|
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node
+  |}>
+
+  declare export var Router: React$ComponentType<{|
+    history: RouterHistory,
+    children?: React$Node
+  |}>
+
+  declare export var Prompt: React$ComponentType<{|
+    message: string | ((location: Location) => string | boolean),
+    when?: boolean
+  |}>
+
+  declare export var Redirect: React$ComponentType<{|
+    to: string | LocationShape,
+    push?: boolean,
+    from?: string,
+    exact?: boolean,
+    strict?: boolean
+  |}>
+
+  declare export var Route: React$ComponentType<{|
+    component?: React$ComponentType<any>,
+    render?: (router: ContextRouter) => React$Node,
+    children?: React$ComponentType<ContextRouter> | React$Node,
+    path?: string | Array<string>,
+    exact?: boolean,
+    strict?: boolean,
+    location?: LocationShape,
+    sensitive?: boolean
+  |}>
+
+  declare export var Switch: React$ComponentType<{|
+    children?: React$Node,
+    location?: Location
+  |}>
+
+  declare export function withRouter<Props: {...}, Component: React$ComponentType<Props>>(
+    WrappedComponent: Component
+  ): React$ComponentType<$Diff<React$ElementConfig<Component>, ContextRouterVoid>>;
+
+  declare type MatchPathOptions = {
+    path?: string | string[],
+    exact?: boolean,
+    sensitive?: boolean,
+    strict?: boolean,
+    ...
+  };
+
+  declare export function matchPath(
+    pathname: string,
+    options?: MatchPathOptions | string | string[],
+    parent?: Match
+  ): null | Match;
+
+  declare export function useHistory(): $PropertyType<ContextRouter, 'history'>;
+  declare export function useLocation(): $PropertyType<ContextRouter, 'location'>;
+  declare export function useParams<Params = $PropertyType<$PropertyType<ContextRouter, 'match'>, 'params'>>(): Params;
+  declare export function useRouteMatch(path?: MatchPathOptions | string | string[]): $PropertyType<ContextRouter, 'match'>;
+
+  declare export function generatePath(pattern?: string, params?: { +[string]: mixed, ... }): string;
+}
diff --git a/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/test_react-router-dom.js
new file mode 100644
index 0000000000..730fd48d9f
--- /dev/null
+++ b/definitions/npm/react-router-dom_v5.x.x/flow_v0.201.x-/test_react-router-dom.js
@@ -0,0 +1,442 @@
+// @flow
+import React from "react";
+import {
+  BrowserRouter,
+  HashRouter,
+  Link,
+  NavLink,
+  matchPath,
+  withRouter,
+  Redirect,
+  Route,
+  useHistory,
+  useLocation,
+  useParams,
+  useRouteMatch,
+} from "react-router-dom";
+import type {
+  Location,
+  ContextRouter,
+  Match,
+  StaticRouterContext,
+  RouterHistory,
+} from "react-router-dom";
+import { it, describe } from "flow-typed-test";
+
+describe("react-router-dom", () => {
+  describe("BrowserRouter", () => {
+    it("works", () => {
+      <BrowserRouter>
+        <div />
+      </BrowserRouter>;
+
+      <BrowserRouter
+        basename="/base"
+        forceRefresh
+        getUserConfirmation={(message, callback) => {}}
+        keyLength={3}
+      >
+        <div />
+      </BrowserRouter>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - basename must be a string
+      <BrowserRouter basename={{}} />;
+    });
+  });
+
+  describe("HashRouter", () => {
+    it("works", () => {
+      <HashRouter>
+        <div />
+      </HashRouter>;
+
+      <HashRouter
+        basename="/base"
+        getUserConfirmation={(message, callback) => {}}
+        hashType="noslash"
+      >
+        <div />
+      </HashRouter>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - hashType must be a string
+      <HashRouter hashType="magic" />;
+    });
+  });
+
+  describe("<Link />", () => {
+    it("works", () => {
+      <Link to="/about">About</Link>;
+
+      <Link replace to="/about">
+        About
+      </Link>;
+
+      <Link
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+      >
+        About
+      </Link>;
+    });
+
+    it("allows attributes of <a> element", () => {
+      <Link
+        to="/about"
+        download
+        hreflang="de"
+        ping="https://www.example.com"
+        referrerpolicy="no-referrer"
+        target="_self"
+        type="foo"
+        onClick={() => {}}
+      >About</Link>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <Link />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <Link to={[]} />;
+    });
+  });
+
+  describe("<NavLink />", () => {
+    it("works", () => {
+      <NavLink to="/about">About</NavLink>;
+
+      <NavLink
+        to="/about"
+        activeClassName="active"
+        className="link"
+        activeStyle={{ color: "red" }}
+        style={{ color: "blue" }}
+        isActive={(match, location) => true}
+        strict
+        exact
+      >
+        About
+      </NavLink>;
+
+      <NavLink
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+      >
+        About
+      </NavLink>;
+    });
+
+    it("allows attributes of <a> element", () => {
+      <NavLink
+        to="/about"
+        download
+        hreflang="de"
+        ping="https://www.example.com"
+        referrerpolicy="no-referrer"
+        target="_self"
+        type="foo"
+        onClick={() => {}}
+      >About</NavLink>;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <NavLink />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <NavLink to={[]} />;
+    });
+  });
+
+  describe("matchPath", () => {
+    it("works", () => {
+      const match: null | Match = matchPath("/the/pathname", {
+        path: "/the/:dynamicId",
+        exact: true,
+        strict: false
+      });
+      const match2: null | Match = matchPath("/the/pathname", {
+        path: ["/the/:dynamicId", "/the/otherRoute"],
+        exact: true,
+        strict: false,
+      });
+      const match3: null | Match = matchPath("/the/pathname", "/the/:dynamicId");
+      const match4: null | Match = matchPath("/the/pathname", [
+        "/the/:dynamicId",
+        "/the/otherRoute",
+      ]);
+      const match5: null | Match = matchPath("/the/pathname");
+    });
+
+    it("raises an error if passed invalid argument", () => {
+      // $FlowExpectedError[incompatible-call] - pathname argument is required
+      matchPath();
+
+      // $FlowExpectedError[incompatible-type] - matchPath returns Match or null
+      const matchError: string = matchPath("/the/pathname", {
+        path: "the/:dynamicId"
+      });
+    });
+  });
+
+  describe("withRouter", () => {
+    type Props = {
+      history: RouterHistory,
+      location: Location,
+      match: Match,
+      staticContext: StaticRouterContext,
+      s: string,
+      ...
+    };
+    describe("Stateless Functional Components", () => {
+      it("passes if the component is passed required props", () => {
+        const Comp = ({
+          history,
+          location,
+          match,
+          staticContext,
+          s
+        }: Props) => <div />;
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if the component is not passed correct props", () => {
+        const Comp = ({
+          history,
+          location,
+          match,
+          staticContext,
+          s
+        }: Props) => <div />;
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <WrappedComp />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={1} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <ChainedHOC />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={1} />;
+      });
+
+      it("errors if trying to access a prop that withRouter does not supply", () => {
+        const Comp = ({ histry, s }: {
+          histry: RouterHistory,
+          s: string,
+          ...
+        }) => (
+          <div />
+        );
+        const WrappedComp = withRouter(Comp);
+      });
+
+      it("errors if using block() incorrectly", () => {
+        const Comp = ({history}: { history: RouterHistory, ... }) => {
+          // $FlowExpectedError[incompatible-call] - wrong param
+          history.block(false);
+
+          // These are valid
+          history.block('Are you sure you want to leave this page?');
+          history.block((location, action) => {
+            return 'Are you sure you want to leave this page?';
+          });
+
+          return <div />;
+        };
+        const WrappedComp = withRouter(Comp);
+      });
+    });
+
+    describe("Class Components", () => {
+      it("passes if the component is passed required props", () => {
+        class Comp extends React.Component<Props> {
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if the component is not passed the correct props", () => {
+        class Comp extends React.Component<Props> {
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <WrappedComp />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={1} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[prop-missing] - missing prop "s"
+        <ChainedHOC />;
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={1} />;
+      });
+
+      it("passes if a required prop is handled by defaultProps", () => {
+        class Comp extends React.Component<Props> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        <WrappedComp />;
+        <WrappedComp s="" />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        <ChainedHOC />;
+        <ChainedHOC s="" />;
+      });
+
+      it("errors if a required prop that has a defaultProp is passed the wrong type", () => {
+        class Comp extends React.Component<Props> {
+          static defaultProps = {
+            s: "defaultS"
+          };
+          render() {
+            return <div />;
+          }
+        }
+        const WrappedComp = withRouter(Comp);
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <WrappedComp s={123} />;
+
+        const ChainedHOC = withRouter(WrappedComp);
+        // $FlowExpectedError[incompatible-type] - wrong type
+        <ChainedHOC s={123} />;
+      });
+    });
+  });
+
+  describe("Redirect", () => {
+    it("works", () => {
+      <Redirect to="/login" />;
+
+      <Redirect exact strict to="/new-path" from="/old-Path" />;
+
+      <Redirect
+        to={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash",
+          state: { fromDashboard: true }
+        }}
+        from="/x"
+        push
+      />;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[prop-missing] - to prop is required
+      <Redirect />;
+
+      // $FlowExpectedError[incompatible-type] - to prop must be a string or LocationShape
+      <Redirect to={[]} />;
+
+      // $FlowExpectedError[prop-missing] - unexpected prop xxx
+      <Redirect to='/x' xxx="1"/>;
+    });
+  });
+
+  describe("Route", () => {
+    it("works", () => {
+      const Component = ({}) => <div>Hi!</div>;
+      <Route path="/login" />;
+
+      <Route path={["/login", "/logout"]} />;
+
+      <Route path="/login" component={Component} />;
+
+      <Route path="/login" render={(context: ContextRouter) => <Component />} />;
+
+      <Route path="/login" children={(context: ContextRouter) => <Component />} />;
+
+      <Route
+        location={{
+          pathname: "/courses",
+          search: "?sort=name",
+          hash: "#the-hash"
+        }}
+        exact
+        strict
+        sensitive
+      />;
+    });
+
+    it("raises error if passed incorrect props", () => {
+      // $FlowExpectedError[incompatible-type] - prop must be a string
+      <Route path={123} />;
+
+      // $FlowExpectedError[prop-missing] - unexpected prop xxx
+      <Route xxx="1" />;
+    });
+  })
+
+  describe('react hook', () => {
+    it('useHistory', () => {
+      const history: RouterHistory = useHistory();
+    });
+
+    it('useLocation', () => {
+      const location: Location = useLocation();
+    });
+
+    it('useParams', () => {
+      const params: { [key: string]: ?string, ... } = useParams();
+    });
+
+    it('useParams with generic', () => {
+      type ParamsType = {|
+        +slug: string,
+      |};
+
+      const params: ParamsType = useParams<ParamsType>();
+    });
+
+    it('useRouteMatch', () => {
+      const match: Match = useRouteMatch();
+      const matchPath: Match = useRouteMatch('/path');
+      const matchArray: Match = useRouteMatch(['/path', '/the/otherRoute']);
+
+      const matchObject: Match = useRouteMatch({
+        path: '/path',
+        strict: true,
+        sensitive: true,
+        exact: true,
+      });
+
+      // $FlowExpectedError[incompatible-call]
+      const matchObject2: Match = useRouteMatch({
+        sensitive: 'foo',
+      });
+    });
+  });
+});
diff --git a/definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-/react-router-native_v4.x.x.js b/definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-v.200.x/react-router-native_v4.x.x.js
similarity index 100%
rename from definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-/react-router-native_v4.x.x.js
rename to definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-v.200.x/react-router-native_v4.x.x.js
diff --git a/definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-/test_react-router-native.js b/definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-v.200.x/test_react-router-native.js
similarity index 100%
rename from definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-/test_react-router-native.js
rename to definitions/npm/react-router-native_v4.x.x/flow_v0.104.x-v.200.x/test_react-router-native.js
diff --git a/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/react-router-native_v4.x.x.js b/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/react-router-native_v4.x.x.js
new file mode 100644
index 0000000000..a83dd0a6e8
--- /dev/null
+++ b/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/react-router-native_v4.x.x.js
@@ -0,0 +1,146 @@
+declare module "react-router-native" {
+  declare export class NativeRouter extends React$Component<{
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Link extends React$Component<{
+    to: string | LocationShape,
+    replace?: boolean,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class DeepLinking extends React$Component<{ children?: React$Node, ... }> {}
+  
+  declare export class BackButton extends React$Component<{ children?: React$Node, ... }> {}
+
+  declare export class AndroidBackButton extends React$Component<{ children?: React$Node, ... }> {}
+
+  // NOTE: Below are duplicated from react-router. If updating these, please
+  // update the react-router and react-router-dom types as well.
+  declare export type Location = $ReadOnly<{
+    pathname: string,
+    search: string,
+    hash: string,
+    state?: any,
+    key?: string,
+    ...
+  }>;
+
+  declare export type LocationShape = {
+    pathname?: string,
+    search?: string,
+    hash?: string,
+    state?: any,
+    ...
+  };
+
+  declare export type HistoryAction = "PUSH" | "REPLACE" | "POP";
+
+  declare export type RouterHistory = {
+    length: number,
+    location: Location,
+    action: HistoryAction,
+    listen(
+      callback: (location: Location, action: HistoryAction) => void
+    ): () => void,
+    push(path: string | LocationShape, state?: any): void,
+    replace(path: string | LocationShape, state?: any): void,
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    canGo?: (n: number) => boolean,
+    block(
+      callback: (location: Location, action: HistoryAction) => boolean
+    ): void,
+    ...
+  };
+
+  declare export type Match = {
+    params: { [key: string]: ?string, ... },
+    isExact: boolean,
+    path: string,
+    url: string,
+    ...
+  };
+
+  declare export type ContextRouter = {|
+    history: RouterHistory,
+    location: Location,
+    match: Match
+  |};
+
+  declare export type GetUserConfirmation = (
+    message: string,
+    callback: (confirmed: boolean) => void
+  ) => void;
+
+  declare type StaticRouterContext = { url?: string, ... };
+
+  declare export class StaticRouter extends React$Component<{
+    basename?: string,
+    location?: string | Location,
+    context: StaticRouterContext,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class MemoryRouter extends React$Component<{
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Router extends React$Component<{
+    history: RouterHistory,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Prompt extends React$Component<{
+    message: string | ((location: Location) => string | true),
+    when?: boolean,
+    ...
+  }> {}
+
+  declare export class Redirect extends React$Component<{
+    to: string | LocationShape,
+    push?: boolean,
+    ...
+  }> {}
+
+  declare export class Route extends React$Component<{
+    component?: React$ComponentType<any>,
+    render?: (router: ContextRouter) => React$Node,
+    children?: React$ComponentType<ContextRouter> | React$Node,
+    path?: string,
+    exact?: boolean,
+    strict?: boolean,
+    ...
+  }> {}
+
+  declare export class Switch extends React$Component<{ children?: React$Node, ... }> {}
+
+  declare export function withRouter<P>(
+    Component: React$ComponentType<{| ...ContextRouter, ...P |}>
+  ): React$ComponentType<P>;
+
+  declare type MatchPathOptions = {
+    path?: string,
+    exact?: boolean,
+    sensitive?: boolean,
+    strict?: boolean,
+    ...
+  };
+
+  declare export function matchPath(
+    pathname: string,
+    options?: MatchPathOptions | string
+  ): null | Match;
+}
diff --git a/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/test_react-router-native.js b/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/test_react-router-native.js
new file mode 100644
index 0000000000..c879b2b294
--- /dev/null
+++ b/definitions/npm/react-router-native_v4.x.x/flow_v0.201.x-/test_react-router-native.js
@@ -0,0 +1,84 @@
+import React from "react";
+import {
+  NativeRouter,
+  Link,
+  DeepLinking,
+  AndroidBackButton,
+  matchPath,
+  withRouter
+} from "react-router-native";
+import type { ContextRouter, Match } from "react-router-native";
+
+// NativeRouter
+<NativeRouter>
+  <div />
+</NativeRouter>;
+<NativeRouter getUserConfirmation={(message, callback) => {}} keyLength={3}>
+  <div />
+</NativeRouter>;
+
+// $FlowExpectedError[incompatible-type]
+<NativeRouter keyLength="five" />;
+
+// Link
+<Link to="/about">About</Link>;
+<Link replace to="/about">
+  About
+</Link>;
+<Link
+  to={{
+    pathname: "/courses",
+    search: "?sort=name",
+    hash: "#the-hash",
+    state: { fromDashboard: true }
+  }}
+>
+  About
+</Link>;
+
+// $FlowExpectedError[incompatible-type]
+<Link to={3} />;
+
+// DeepLinking
+<DeepLinking />;
+
+// AndroidBackButton
+<AndroidBackButton />;
+
+// matchPath
+const match: null | Match = matchPath("/the/pathname", {
+  path: "/the/:dynamicId",
+  exact: true,
+  strict: false
+});
+const match2: null | Match = matchPath("/the/pathname", {
+  path: "/the/:dynamicId"
+});
+const match3: null | Match = matchPath("/the/pathname");
+
+// $FlowExpectedError[incompatible-call]
+matchPath();
+// $FlowExpectedError[incompatible-type]
+const matchError: string = matchPath("/the/pathname", {
+  path: "the/:dynamicId"
+});
+
+const Unrouted: React$ComponentType<{|
+  ...ContextRouter,
+  someProp: string
+|}> = () => <span />;
+
+const Routed1: React$ComponentType<{| someProp: string |}> = withRouter(
+  Unrouted
+);
+
+const Unrouted2: React$ComponentType<{|
+  ...ContextRouter,
+  someProp: string
+|}> = () => <span />;
+
+
+const Routed2: React$ComponentType<{| someProp2: string |}> = withRouter(
+  // $FlowExpectedError[prop-missing]
+  Unrouted2
+);
diff --git a/definitions/npm/react-router_v4.x.x/flow_v0.104.x-/react-router_v4.x.x.js b/definitions/npm/react-router_v4.x.x/flow_v0.104.x-v.200.x/react-router_v4.x.x.js
similarity index 100%
rename from definitions/npm/react-router_v4.x.x/flow_v0.104.x-/react-router_v4.x.x.js
rename to definitions/npm/react-router_v4.x.x/flow_v0.104.x-v.200.x/react-router_v4.x.x.js
diff --git a/definitions/npm/react-router_v4.x.x/flow_v0.104.x-/test_react-router.js b/definitions/npm/react-router_v4.x.x/flow_v0.104.x-v.200.x/test_react-router.js
similarity index 100%
rename from definitions/npm/react-router_v4.x.x/flow_v0.104.x-/test_react-router.js
rename to definitions/npm/react-router_v4.x.x/flow_v0.104.x-v.200.x/test_react-router.js
diff --git a/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/react-router_v4.x.x.js b/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/react-router_v4.x.x.js
new file mode 100644
index 0000000000..309d6347c8
--- /dev/null
+++ b/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/react-router_v4.x.x.js
@@ -0,0 +1,138 @@
+declare module "react-router" {
+  // NOTE: many of these are re-exported by react-router-dom and
+  // react-router-native, so when making changes, please be sure to update those
+  // as well.
+  declare export type Location = {
+    pathname: string,
+    search: string,
+    hash: string,
+    state?: any,
+    key?: string,
+    ...
+  };
+
+  declare export type LocationShape = {
+    pathname?: string,
+    search?: string,
+    hash?: string,
+    state?: any,
+    ...
+  };
+
+  declare export type HistoryAction = "PUSH" | "REPLACE" | "POP";
+
+  declare export type RouterHistory = {
+    length: number,
+    location: Location,
+    action: HistoryAction,
+    listen(
+      callback: (location: Location, action: HistoryAction) => void
+    ): () => void,
+    push(path: string | LocationShape, state?: any): void,
+    replace(path: string | LocationShape, state?: any): void,
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    canGo?: (n: number) => boolean,
+    block(
+      callback: string | (location: Location, action: HistoryAction) => ?string
+    ): () => void,
+    // createMemoryHistory
+    index?: number,
+    entries?: Array<Location>,
+    ...
+  };
+
+  declare export type Match = {
+    params: { [key: string]: ?string, ... },
+    isExact: boolean,
+    path: string,
+    url: string,
+    ...
+  };
+
+  declare export type ContextRouter = {|
+    history: RouterHistory,
+    location: Location,
+    match: Match,
+    staticContext?: StaticRouterContext
+  |};
+
+  declare export type GetUserConfirmation = (
+    message: string,
+    callback: (confirmed: boolean) => void
+  ) => void;
+
+  declare type StaticRouterContext = { url?: string, ... };
+
+  declare export class StaticRouter extends React$Component<{
+    basename?: string,
+    location?: string | Location,
+    context: StaticRouterContext,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class MemoryRouter extends React$Component<{
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Router extends React$Component<{
+    history: RouterHistory,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Prompt extends React$Component<{
+    message: string | ((location: Location) => string | true),
+    when?: boolean,
+    ...
+  }> {}
+
+  declare export class Redirect extends React$Component<{|
+    to: string | LocationShape,
+    push?: boolean,
+    from?: string,
+    exact?: boolean,
+    strict?: boolean
+  |}> {}
+
+
+  declare export class Route extends React$Component<{|
+    component?: React$ComponentType<any>,
+    render?: (router: ContextRouter) => React$Node,
+    children?: React$ComponentType<ContextRouter> | React$Node,
+    path?: string,
+    exact?: boolean,
+    strict?: boolean,
+    location?: LocationShape,
+    sensitive?: boolean
+  |}> {}
+
+  declare export class Switch extends React$Component<{|
+    children?: React$Node,
+    location?: Location
+  |}> {}
+
+  declare export function withRouter<P>(
+    Component: React$ComponentType<{| ...ContextRouter, ...P |}>
+  ): React$ComponentType<P>;
+
+  declare type MatchPathOptions = {
+    path?: string,
+    exact?: boolean,
+    strict?: boolean,
+    sensitive?: boolean,
+    ...
+  };
+
+  declare export function matchPath(
+    pathname: string,
+    options?: MatchPathOptions | string
+  ): null | Match;
+}
diff --git a/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/test_react-router.js b/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/test_react-router.js
new file mode 100644
index 0000000000..3e5d3e38e5
--- /dev/null
+++ b/definitions/npm/react-router_v4.x.x/flow_v0.201.x-/test_react-router.js
@@ -0,0 +1,212 @@
+// @flow
+import React from 'react';
+import { describe, it } from 'flow-typed-test';
+import {
+  StaticRouter,
+  MemoryRouter,
+  Router,
+  Prompt,
+  Redirect,
+  Route,
+  Switch,
+  withRouter,
+  matchPath,
+} from 'react-router';
+import type {
+  Location,
+  Match,
+  ContextRouter,
+  RouterHistory,
+} from 'react-router';
+
+describe('Location', () => {
+  it('should error if wrong type is passed', () => {
+    // $FlowExpectedError[incompatible-type]
+    const locationError: Location = 'location';
+  });
+
+  it('should work if type is correct', () => {
+    const location: Location = {
+      pathname: '/path',
+      search: '?search',
+      hash: '#hash',
+      state: null,
+      key: 'key',
+    };
+  });
+});
+
+describe('StaticRouter', () => {
+  <StaticRouter context={{}}>
+    <div />
+  </StaticRouter>;
+  <StaticRouter location="/" context={{}} basename="/foo/">
+    <div />
+  </StaticRouter>;
+
+  // $FlowExpectedError[prop-missing]
+  <StaticRouter />;
+});
+
+describe('MemoryRouter', () => {
+  <MemoryRouter>
+    <div />
+  </MemoryRouter>;
+  <MemoryRouter
+    initialEntries={['/one', '/two', { pathname: '/three' }]}
+    initialIndex={1}
+    getUserConfirmation={(
+      message: string,
+      callback: (confirmed: boolean) => void,
+    ): void => {}}
+    keyLength={3}
+  >
+    <div />
+  </MemoryRouter>;
+
+  // $FlowExpectedError[incompatible-type]
+  <MemoryRouter initialEntries={''} />;
+});
+
+describe('RouterHistory', () => {
+  declare var history: RouterHistory;
+  <Router history={history}>
+    <div />
+  </Router>;
+
+  // $FlowExpectedError[prop-missing]
+  <Router>
+    <div />
+  </Router>;
+});
+
+describe('Prompt', () => {
+  <Prompt message="ok?" when={true} />;
+  <Prompt message={location => 'ok?'} />;
+  <Prompt message={location => true} />;
+
+  // $FlowExpectedError[prop-missing]
+  <Prompt />;
+});
+
+describe('Redirect', () => {
+  <Redirect to="/foo" push />;
+  <Redirect
+    to={{
+      pathname: '/login',
+      search: '?utm=foo',
+      state: { referrer: '/current' },
+    }}
+  />;
+  <Redirect to="/foo" push from="/x" />;
+
+  // $FlowExpectedError[prop-missing]
+  <Redirect />;
+});
+
+describe('Route', () => {
+  const User = () => <div />;
+  <Route path="/user/:username" component={User} exact={true} strict={true} />;
+  <Route path="/home" render={({ match }) => <div>Home {match.path}</div>} />;
+  <Route
+    path="/"
+    children={({ match }) => <div className={match ? 'active' : ''} />}
+  />;
+  <Route>
+    <div>children</div>
+  </Route>;
+
+  // $FlowExpectedError[incompatible-type]
+  <Route path="/user/:username" component={<User />} />;
+});
+
+describe('Switch', () => {
+  <Switch>
+    <Route />
+    <Route />
+  </Switch>;
+});
+
+describe('withRouter', () => {
+  type FooProps = {|
+    ...ContextRouter,
+    name: string,
+  |};
+  const Foo = ({ location, name }: FooProps) => (
+    <div>
+      {location.pathname} {name}
+    </div>
+  );
+  const FooWithRouter = withRouter(Foo);
+  <FooWithRouter name="name" />;
+
+  class Bar extends React.Component<FooProps> {}
+  const BarWithRouter = withRouter(Bar);
+  <BarWithRouter name="name" />;
+
+  // $FlowExpectedError[incompatible-call]
+  withRouter('nope');
+
+  // const FooWithRouterError = withRouter(Foo);
+  // <FooWithRouterError name={3} />;
+
+  // $FlowExpectedError[incompatible-call]
+  const BarWithRouterError = withRouter(Bar);
+  <BarWithRouterError name={3} />;
+
+  const IncorrectHistoryUsage = ({ history, name }: FooProps) => {
+    // Wrong arguments here
+    // $FlowExpectedError[incompatible-call]
+    history.push(['bla']);
+    return <div>{name}</div>;
+  };
+
+  const IncorrectHistoryBlockUsage = (history: RouterHistory) => {
+    // Wrong arguments here
+    // $FlowExpectedError[incompatible-call]
+    history.block(false);
+
+    // These are valid
+    history.block('Are you sure you want to leave this page?');
+    history.block((location, action) => {
+      return 'Are you sure you want to leave this page?';
+    });
+  };
+});
+
+describe('matchPath', () => {
+  // matchPath
+  const match: null | Match = matchPath('/the/pathname', {
+    path: '/the/:dynamicId',
+    exact: true,
+    strict: false,
+  });
+  const match2: null | Match = matchPath('/the/pathname', '/the/:dynamicId');
+  const match3: null | Match = matchPath('/the/pathname');
+
+  // $FlowExpectedError[incompatible-call]
+  matchPath();
+  // $FlowExpectedError[incompatible-type]
+  const matchError: string = matchPath('/the/pathname', 'the/:dynamicId');
+});
+
+describe('Unrouted', () => {
+  const Unrouted: React$ComponentType<{|
+    ...ContextRouter,
+    someProp: string,
+  |}> = () => <span />;
+
+  const Routed1: React$ComponentType<{| someProp: string |}> = withRouter(
+    Unrouted,
+  );
+
+  const Unrouted2: React$ComponentType<{|
+    ...ContextRouter,
+    someProp: string,
+  |}> = () => <span />;
+
+  const Routed2: React$ComponentType<{| someProp2: string |}> = withRouter(
+    // $FlowExpectedError[prop-missing]
+    Unrouted2,
+  );
+});
diff --git a/definitions/npm/react-router_v5.x.x/flow_v0.104.x-/react-router_v5.x.x.js b/definitions/npm/react-router_v5.x.x/flow_v0.104.x-v.200.x/react-router_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-router_v5.x.x/flow_v0.104.x-/react-router_v5.x.x.js
rename to definitions/npm/react-router_v5.x.x/flow_v0.104.x-v.200.x/react-router_v5.x.x.js
diff --git a/definitions/npm/react-router_v5.x.x/flow_v0.104.x-/test_react-router.js b/definitions/npm/react-router_v5.x.x/flow_v0.104.x-v.200.x/test_react-router.js
similarity index 100%
rename from definitions/npm/react-router_v5.x.x/flow_v0.104.x-/test_react-router.js
rename to definitions/npm/react-router_v5.x.x/flow_v0.104.x-v.200.x/test_react-router.js
diff --git a/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/react-router_v5.x.x.js b/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/react-router_v5.x.x.js
new file mode 100644
index 0000000000..b4f5d4e4bd
--- /dev/null
+++ b/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/react-router_v5.x.x.js
@@ -0,0 +1,156 @@
+declare module "react-router" {
+  // NOTE: many of these are re-exported by react-router-dom and
+  // react-router-native, so when making changes, please be sure to update those
+  // as well.
+  declare export type Location = $ReadOnly<{
+    pathname: string,
+    search: string,
+    hash: string,
+    state?: any,
+    key?: string,
+    ...
+  }>;
+
+  declare export type LocationShape = {
+    pathname?: string,
+    search?: string,
+    hash?: string,
+    state?: any,
+    ...
+  };
+
+  declare export type HistoryAction = "PUSH" | "REPLACE" | "POP";
+
+  declare export type RouterHistory = {
+    length: number,
+    location: Location,
+    action: HistoryAction,
+    listen(
+      callback: (location: Location, action: HistoryAction) => void
+    ): () => void,
+    push(path: string | LocationShape, state?: any): void,
+    replace(path: string | LocationShape, state?: any): void,
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    canGo?: (n: number) => boolean,
+    block(
+      callback: string | (location: Location, action: HistoryAction) => ?string
+    ): () => void,
+    ...
+  };
+
+  declare export type Match = {
+    params: { [key: string]: ?string, ... },
+    isExact: boolean,
+    path: string,
+    url: string,
+    ...
+  };
+
+  declare export type ContextRouter = {|
+    history: RouterHistory,
+    location: Location,
+    match: Match,
+    staticContext?: StaticRouterContext
+  |};
+
+  declare export type GetUserConfirmation = (
+    message: string,
+    callback: (confirmed: boolean) => void
+  ) => void;
+
+  declare type StaticRouterContext = { url?: string, ... };
+
+  declare export class StaticRouter extends React$Component<{
+    basename?: string,
+    location?: string | Location,
+    context: StaticRouterContext,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class MemoryRouter extends React$Component<{
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Router extends React$Component<{
+    history: RouterHistory,
+    children?: React$Node,
+    ...
+  }> {}
+
+  declare export class Prompt extends React$Component<{
+    message: string | ((location: Location) => string | true),
+    when?: boolean,
+    ...
+  }> {}
+
+  declare export class Redirect extends React$Component<{|
+    to: string | LocationShape,
+    push?: boolean,
+    from?: string,
+    exact?: boolean,
+    strict?: boolean
+  |}> {}
+
+
+  declare export class Route extends React$Component<{|
+    component?: React$ComponentType<any>,
+    render?: (router: ContextRouter) => React$Node,
+    children?: React$ComponentType<ContextRouter> | React$Node,
+    path?: string | Array<string>,
+    exact?: boolean,
+    strict?: boolean,
+    location?: LocationShape,
+    sensitive?: boolean
+  |}> {}
+
+  declare export class Switch extends React$Component<{|
+    children?: React$Node,
+    location?: Location
+  |}> {}
+
+  declare export function withRouter<P>(
+    Component: React$ComponentType<{| ...ContextRouter, ...P |}>
+  ): React$ComponentType<P>;
+
+  declare type MatchPathOptions = {
+    path?: string | string[],
+    exact?: boolean,
+    strict?: boolean,
+    sensitive?: boolean,
+    ...
+  };
+
+  declare export function matchPath(
+    pathname: string,
+    options?: MatchPathOptions | string | string[]
+  ): null | Match;
+
+  declare export function useHistory(): $PropertyType<ContextRouter, 'history'>;
+  declare export function useLocation(): $PropertyType<ContextRouter, 'location'>;
+  declare export function useParams<Params = $PropertyType<$PropertyType<ContextRouter, 'match'>, 'params'>>(): Params;
+  declare export function useRouteMatch(path?: MatchPathOptions | string | string[]): $PropertyType<ContextRouter, 'match'>;
+
+  declare export function generatePath(pattern?: string, params?: {...}): string;
+
+  declare export default {
+    StaticRouter: typeof StaticRouter,
+    MemoryRouter: typeof MemoryRouter,
+    Router: typeof Router,
+    Prompt: typeof Prompt,
+    Redirect: typeof Redirect,
+    Route: typeof Route,
+    Switch: typeof Switch,
+    withRouter: typeof withRouter,
+    matchPath: typeof matchPath,
+    generatePath: typeof generatePath,
+    ...
+  };
+}
diff --git a/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/test_react-router.js b/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/test_react-router.js
new file mode 100644
index 0000000000..419aa1f11a
--- /dev/null
+++ b/definitions/npm/react-router_v5.x.x/flow_v0.201.x-/test_react-router.js
@@ -0,0 +1,257 @@
+// @flow
+import React from 'react';
+import { describe, it } from 'flow-typed-test';
+import {
+  StaticRouter,
+  MemoryRouter,
+  Router,
+  Prompt,
+  Redirect,
+  Route,
+  Switch,
+  withRouter,
+  matchPath,
+  useHistory,
+  useLocation,
+  useParams,
+  useRouteMatch,
+} from 'react-router';
+import type {
+  Location,
+  Match,
+  ContextRouter,
+  RouterHistory,
+} from 'react-router';
+
+describe('Location', () => {
+  it('should error if wrong type is passed', () => {
+    // $FlowExpectedError[incompatible-type]
+    const locationError: Location = 'location';
+  });
+
+  it('should work if type is correct', () => {
+    const location: Location = {
+      pathname: '/path',
+      search: '?search',
+      hash: '#hash',
+      state: null,
+      key: 'key',
+    };
+  });
+});
+
+describe('StaticRouter', () => {
+  <StaticRouter context={{}}>
+    <div />
+  </StaticRouter>;
+  <StaticRouter location="/" context={{}} basename="/foo/">
+    <div />
+  </StaticRouter>;
+
+  // $FlowExpectedError[prop-missing]
+  <StaticRouter />;
+});
+
+describe('MemoryRouter', () => {
+  <MemoryRouter>
+    <div />
+  </MemoryRouter>;
+  <MemoryRouter
+    initialEntries={['/one', '/two', { pathname: '/three' }]}
+    initialIndex={1}
+    getUserConfirmation={(
+      message: string,
+      callback: (confirmed: boolean) => void,
+    ): void => {}}
+    keyLength={3}
+  >
+    <div />
+  </MemoryRouter>;
+
+  // $FlowExpectedError[incompatible-type]
+  <MemoryRouter initialEntries={''} />;
+});
+
+describe('RouterHistory', () => {
+  declare var history: RouterHistory;
+  <Router history={history}>
+    <div />
+  </Router>;
+
+  // $FlowExpectedError[prop-missing]
+  <Router>
+    <div />
+  </Router>;
+});
+
+describe('Prompt', () => {
+  <Prompt message="ok?" when={true} />;
+  <Prompt message={location => 'ok?'} />;
+  <Prompt message={location => true} />;
+
+  // $FlowExpectedError[prop-missing]
+  <Prompt />;
+});
+
+describe('Redirect', () => {
+  <Redirect to="/foo" push />;
+  <Redirect
+    to={{
+      pathname: '/login',
+      search: '?utm=foo',
+      state: { referrer: '/current' },
+    }}
+  />;
+  <Redirect to="/foo" push from="/x" />;
+
+  // $FlowExpectedError[prop-missing]
+  <Redirect />;
+});
+
+describe('Route', () => {
+  const User = () => <div />;
+  <Route
+    path={['/', '/user/:username']}
+    children={({ match }) => <div className={match ? 'active' : ''} />}
+  />;
+  <Route path="/user/:username" component={User} exact={true} strict={true} />;
+  <Route path="/home" render={({ match }) => <div>Home {match.path}</div>} />;
+  <Route
+    path="/"
+    children={({ match }) => <div className={match ? 'active' : ''} />}
+  />;
+  <Route>
+    <div>children</div>
+  </Route>;
+
+  // $FlowExpectedError[incompatible-type]
+  <Route path="/user/:username" component={<User />} />;
+});
+
+describe('Switch', () => {
+  <Switch>
+    <Route />
+    <Route />
+  </Switch>;
+});
+
+describe('withRouter', () => {
+  type FooProps = {|
+    ...ContextRouter,
+    name: string,
+  |};
+  const Foo = ({ location, name }: FooProps) => (
+    <div>
+      {location.pathname} {name}
+    </div>
+  );
+  const FooWithRouter = withRouter(Foo);
+  <FooWithRouter name="name" />;
+
+  class Bar extends React.Component<FooProps> {}
+  const BarWithRouter = withRouter(Bar);
+  <BarWithRouter name="name" />;
+
+  // $FlowExpectedError[incompatible-call]
+  withRouter('nope');
+
+  const FooWithRouterError = withRouter(Foo);
+  <FooWithRouterError name="3" />;
+
+  // $FlowExpectedError[incompatible-call]
+  const BarWithRouterError = withRouter(Bar);
+  <BarWithRouterError name={3} />;
+
+  const IncorrectHistoryUsage = ({ history, name }: FooProps) => {
+    // Wrong arguments here
+    // $FlowExpectedError[incompatible-call]
+    history.push(['bla']);
+    return <div>{name}</div>;
+  };
+});
+
+describe('matchPath', () => {
+  // matchPath
+  const match: null | Match = matchPath('/the/pathname', {
+    path: '/the/:dynamicId',
+    exact: true,
+    strict: false,
+  });
+  const match2: null | Match = matchPath('/the/pathname', {
+    path: ['/the/:dynamicId', '/the/otherRoute'],
+    exact: true,
+    strict: false,
+  });
+  const match3: null | Match = matchPath('/the/pathname', '/the/:dynamicId');
+  const match4: null | Match = matchPath('/the/pathname', [
+    '/the/:dynamicId',
+    '/the/otherRoute',
+  ]);
+  const match5: null | Match = matchPath('/the/pathname');
+
+  // $FlowExpectedError[incompatible-call]
+  matchPath();
+  // $FlowExpectedError[incompatible-type]
+  const matchError: string = matchPath('/the/pathname', 'the/:dynamicId');
+});
+
+describe('Unrouted', () => {
+  const Unrouted: React$ComponentType<{|
+    ...ContextRouter,
+    someProp: string,
+  |}> = () => <span />;
+
+  const Routed1: React$ComponentType<{| someProp: string |}> = withRouter(
+    Unrouted,
+  );
+
+  const Unrouted2: React$ComponentType<{|
+    ...ContextRouter,
+    someProp: string,
+  |}> = () => <span />;
+
+  const Routed2: React$ComponentType<{| someProp2: string |}> = withRouter(
+    // $FlowExpectedError[prop-missing]
+    Unrouted2,
+  );
+});
+
+describe('react hook', () => {
+  it('useHistory', () => {
+    const history: RouterHistory = useHistory();
+  });
+
+  it('useLocation', () => {
+    const location: Location = useLocation();
+  });
+
+  it('useParams', () => {
+    const params: { [key: string]: ?string, ... } = useParams();
+  });
+
+  it('useParams with generic', () => {
+    type ParamsType = {|
+      +slug: string,
+    |};
+
+    const params: ParamsType = useParams<ParamsType>();
+  });
+
+  it('useRouteMatch', () => {
+    const match: Match = useRouteMatch();
+    const matchPath: Match = useRouteMatch('/path');
+    const matchArray: Match = useRouteMatch(['/path', '/the/otherRoute']);
+
+    const matchObject: Match = useRouteMatch({
+      path: '/path',
+      strict: true,
+      sensitive: true,
+      exact: true,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    const matchObject2: Match = useRouteMatch({
+      sensitive: 'foo',
+    });
+  });
+});
diff --git a/definitions/npm/react-scripts_v0.7.x/flow_v0.104.x-/react-scripts_v0.7.x.js b/definitions/npm/react-scripts_v0.7.x/flow_v0.104.x-v.200.x/react-scripts_v0.7.x.js
similarity index 100%
rename from definitions/npm/react-scripts_v0.7.x/flow_v0.104.x-/react-scripts_v0.7.x.js
rename to definitions/npm/react-scripts_v0.7.x/flow_v0.104.x-v.200.x/react-scripts_v0.7.x.js
diff --git a/definitions/npm/react-scripts_v0.7.x/flow_v0.201.x-/react-scripts_v0.7.x.js b/definitions/npm/react-scripts_v0.7.x/flow_v0.201.x-/react-scripts_v0.7.x.js
new file mode 100644
index 0000000000..b589e0e66e
--- /dev/null
+++ b/definitions/npm/react-scripts_v0.7.x/flow_v0.201.x-/react-scripts_v0.7.x.js
@@ -0,0 +1,131 @@
+type JestMockFn = {
+  (...args: Array<any>): any,
+  mock: {
+    calls: Array<Array<any>>,
+    instances: mixed,
+    ...
+  },
+  mockClear(): Function,
+  mockImplementation(fn: Function): JestMockFn,
+  mockImplementationOnce(fn: Function): JestMockFn,
+  mockReturnThis(): void,
+  mockReturnValue(value: any): JestMockFn,
+  mockReturnValueOnce(value: any): JestMockFn,
+  ...
+};
+
+type JestAsymmetricEqualityType = { asymmetricMatch(value: mixed): boolean, ... };
+
+type JestCallsType = {
+  allArgs(): mixed,
+  all(): mixed,
+  any(): boolean,
+  count(): number,
+  first(): mixed,
+  mostRecent(): mixed,
+  reset(): void,
+  ...
+};
+
+type JestClockType = {
+  install(): void,
+  mockDate(date: Date): void,
+  tick(milliseconds?: number): void,
+  uninstall(): void,
+  ...
+};
+
+type JestExpectType = {
+  not: JestExpectType,
+  lastCalledWith(...args: Array<any>): void,
+  toBe(value: any): void,
+  toBeCalled(): void,
+  toBeCalledWith(...args: Array<any>): void,
+  toBeCloseTo(num: number, delta: any): void,
+  toBeDefined(): void,
+  toBeFalsy(): void,
+  toBeGreaterThan(number: number): void,
+  toBeGreaterThanOrEqual(number: number): void,
+  toBeLessThan(number: number): void,
+  toBeLessThanOrEqual(number: number): void,
+  toBeInstanceOf(cls: Class<any>): void,
+  toBeNull(): void,
+  toBeTruthy(): void,
+  toBeUndefined(): void,
+  toContain(item: any): void,
+  toContainEqual(item: any): void,
+  toEqual(value: any): void,
+  toHaveBeenCalled(): void,
+  toHaveBeenCalledTimes(number: number): void,
+  toHaveBeenCalledWith(...args: Array<any>): void,
+  toMatch(regexp: RegExp): void,
+  toMatchSnapshot(): void,
+  toThrow(message?: string | Error): void,
+  toThrowError(message?: string | Error | RegExp): void,
+  toThrowErrorMatchingSnapshot(): void,
+  ...
+};
+
+type JestSpyType = { calls: JestCallsType, ... };
+
+declare function afterEach(fn: Function): void;
+declare function beforeEach(fn: Function): void;
+declare function afterAll(fn: Function): void;
+declare function beforeAll(fn: Function): void;
+declare function describe(name: string, fn: Function): void;
+declare var it: {
+  (name: string, fn?: Function): ?Promise<void>,
+  only(name: string, fn?: Function): ?Promise<void>,
+  skip(name: string, fn?: Function): ?Promise<void>,
+  ...
+};
+declare function fit(name: string, fn: Function): ?Promise<void>;
+declare var test: typeof it;
+declare var xdescribe: typeof describe;
+declare var fdescribe: typeof describe;
+declare var xit: typeof it;
+declare var xtest: typeof it;
+
+declare function expect(value: any): JestExpectType;
+
+// TODO handle return type
+// http://jasmine.github.io/2.4/introduction.html#section-Spies
+declare function spyOn(value: mixed, method: string): Object;
+
+declare var jest: {
+  autoMockOff(): void,
+  autoMockOn(): void,
+  clearAllMocks(): void,
+  clearAllTimers(): void,
+  currentTestPath(): void,
+  disableAutomock(): void,
+  doMock(moduleName: string, moduleFactory?: any): void,
+  dontMock(moduleName: string): void,
+  enableAutomock(): void,
+  fn(implementation?: Function): JestMockFn,
+  isMockFunction(fn: Function): boolean,
+  genMockFromModule(moduleName: string): any,
+  mock(moduleName: string, moduleFactory?: any): void,
+  resetModules(): void,
+  runAllTicks(): void,
+  runAllTimers(): void,
+  runTimersToTime(msToRun: number): void,
+  runOnlyPendingTimers(): void,
+  setMock(moduleName: string, moduleExports: any): void,
+  unmock(moduleName: string): void,
+  useFakeTimers(): void,
+  useRealTimers(): void,
+  ...
+};
+
+declare var jasmine: {
+  DEFAULT_TIMEOUT_INTERVAL: number,
+  any(value: mixed): JestAsymmetricEqualityType,
+  anything(): void,
+  arrayContaining(value: mixed[]): void,
+  clock(): JestClockType,
+  createSpy(name: string): JestSpyType,
+  objectContaining(value: Object): void,
+  stringMatching(value: string): void,
+  ...
+};
diff --git a/definitions/npm/react-select_v1.x.x/flow_v0.104.x-/react-select_v1.x.x.js b/definitions/npm/react-select_v1.x.x/flow_v0.104.x-v.200.x/react-select_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-select_v1.x.x/flow_v0.104.x-/react-select_v1.x.x.js
rename to definitions/npm/react-select_v1.x.x/flow_v0.104.x-v.200.x/react-select_v1.x.x.js
diff --git a/definitions/npm/react-select_v1.x.x/flow_v0.104.x-/test_react-select_v1.x.x.js b/definitions/npm/react-select_v1.x.x/flow_v0.104.x-v.200.x/test_react-select_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-select_v1.x.x/flow_v0.104.x-/test_react-select_v1.x.x.js
rename to definitions/npm/react-select_v1.x.x/flow_v0.104.x-v.200.x/test_react-select_v1.x.x.js
diff --git a/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/react-select_v1.x.x.js b/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/react-select_v1.x.x.js
new file mode 100644
index 0000000000..246569555a
--- /dev/null
+++ b/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/react-select_v1.x.x.js
@@ -0,0 +1,193 @@
+declare module 'react-select' {
+  declare type OptionType = { [string]: any, ... };
+  declare type OptionsType = OptionType[];
+
+  declare type Props = {|
+    // html id(s) of element(s) that should be used to describe this input (for assistive tech)
+    'aria-describedby'?: string,
+    // aria label (for assistive tech)
+    'aria-label'?: string,
+    // html id of an element that should be used as the label (for assistive tech)
+    'aria-labelledby'?: string,
+    // placeholder displayed when you want to add a label on a multi-value input
+    addLabelText?: string,
+    // Create drop-down caret element
+    arrowRenderer?: React$ComponentType<{ onMouseDown?: SyntheticMouseEvent<any>, ... }>,
+    // automatically blur the component when an option is selected
+    autoBlur?: boolean,
+    // autoFocus the component on mount, autofocus deprecated; use autoFocus instead
+    autoFocus?: boolean,
+    // whether to enable autosizing or not
+    autosize?: boolean,
+    // whether backspace removes an item if there is no text input
+    backspaceRemoves?: boolean,
+    // Message to use for screenreaders to press backspace to remove the current item - {label} is replaced with the item label
+    backspaceToRemoveMessage?: string,
+    // className for the outer element
+    className?: string,
+    // title for the "clear" control when multi: true
+    clearAllText?: string | React$Element<any>,
+    // create clearable x element
+    clearRenderer?: React$ComponentType<{...}>,
+    // title for the "clear" control
+    clearValueText?: string | React$Element<any>,
+    // should it be possible to reset value
+    clearable?: boolean,
+    // whether to close the menu when a value is selected
+    closeOnSelect?: boolean,
+    // whether backspace removes an item if there is no text input
+    deleteRemoves?: boolean,
+    // delimiter to use to join multiple values for the hidden field value
+    delimiter?: string,
+    // whether the Select is disabled or not
+    disabled?: boolean,
+    // whether escape clears the value when the menu is closed
+    escapeClearsValue?: boolean,
+    // method to filter a single option (option, filterString)
+    filterOption?: (option: OptionType, filterString: string) => boolean,
+    // boolean to enable default filtering or function to filter the options array ([options], filterString, [values])
+    filterOptions?:
+      | boolean
+      | ((
+          options: OptionsType,
+          filterValue: string,
+          excludeOptions: Array<{...}>,
+          props: {...}
+        ) => OptionsType),
+    // html id to set on the input element for accessibility or tests
+    id?: string,
+    // whether to strip diacritics when filtering
+    ignoreAccents?: boolean,
+    // whether to perform case-insensitive filtering
+    ignoreCase?: boolean,
+    // custom attributes for the Input
+    inputProps?: {...},
+    // returns a custom input component
+    inputRenderer?: React$ComponentType<{...}>,
+    // set the components instanceId
+    instanceId?: string,
+    // whether the Select is loading externally or not (such as options being loaded)
+    isLoading?: boolean,
+    // joins multiple values into a single form field with the delimiter (legacy mode)
+    joinValues?: boolean,
+    // path of the label value in option objects
+    labelKey?: string,
+    // (any|start) match the start or entire string when filtering
+    matchPos?: 'any' | 'start',
+    // (any|label|value) which option property to filter on
+    matchProp?: 'any' | 'label' | 'value',
+    // optional buffer (in px) between the bottom of the viewport and the bottom of the menu
+    menuBuffer?: number,
+    // optional style to apply to the menu container
+    menuContainerStyle?: {...},
+    // renders a custom menu with options
+    menuRenderer?: React$ComponentType<{...}>,
+    // optional style to apply to the menu
+    menuStyle?: {...},
+    // multi-value input
+    multi?: boolean,
+    // generates a hidden <input /> tag with this field name for html forms
+    name?: string,
+    // placeholder displayed when there are no matching search results
+    noResultsText?: string | React$Element<any>,
+    // onBlur handler: function (event) {}
+    onBlur?: (event: SyntheticFocusEvent<any>) => void,
+    // whether input is cleared on blur
+    onBlurResetsInput?: boolean,
+    // onChange handler: function (newValue) {}
+    onChange?: (value: any) => void,
+    // fires when the menu is closed
+    onClose?: () => void,
+    // whether input is cleared when menu is closed through the arrow
+    onCloseResetsInput?: boolean,
+    // onFocus handler: function (event) {}
+    onFocus?: (event: SyntheticFocusEvent<any>) => void,
+    // onInputChange handler: function (inputValue) {}
+    onInputChange?: (value: any) => any,
+    // input keyDown handler: function (event) {}
+    onInputKeyDown?: (event: SyntheticKeyboardEvent<any>) => void,
+    // fires when the menu is scrolled to the bottom; can be used to paginate options
+    onMenuScrollToBottom?: () => void,
+    // fires when the menu is opened
+    onOpen?: () => void,
+    // whether input is cleared on select (works only for multiselect)
+    onSelectResetsInput?: boolean,
+    // onClick handler for value labels: function (value, event) {}
+    onValueClick?: (value: string, event: Event) => void,
+    // boolean to enable opening dropdown when focused
+    openAfterFocus?: boolean,
+    // boolean to control opening the menu when the control is clicked
+    openOnClick?: boolean,
+    // always open options menu on focus
+    openOnFocus?: boolean,
+    // additional class(es) to apply to the <Option /> elements
+    optionClassName?: string,
+    // option component to render in dropdown
+    optionComponent?: React$ComponentType<{...}>,
+    // optionRenderer: function (option) {}
+    optionRenderer?: (
+      option: OptionType,
+      idx: number,
+      inputValue: any
+    ) => React$Node,
+    // array of options
+    options?: OptionsType,
+    // number of entries to page when using page up/down keys
+    pageSize?: number,
+    // field placeholder, displayed when there's no value
+    placeholder?: string | React$Element<any>,
+    // whether the selected option is removed from the dropdown on multi selects
+    removeSelected?: boolean,
+    // applies HTML5 required attribute when needed
+    required?: boolean,
+    // value to use when you clear the control
+    resetValue?: any,
+    // set to true in order to use react-select in right-to-left direction
+    rtl?: boolean,
+    // boolean to enable the viewport to shift so that the full menu fully visible when engaged
+    scrollMenuIntoView?: boolean,
+    // whether to enable searching feature or not
+    searchable?: boolean,
+    // pass the value to onChange as a simple value (legacy pre 1.0 mode), defaults to false
+    simpleValue?: boolean,
+    // optional style to apply to the control
+    style?: {...},
+    // optional tab index of the control
+    tabIndex?: number,
+    // whether to treat tabbing out while focused to be value selection
+    tabSelectsValue?: boolean,
+    // whether to trim whitespace around filter value
+    trimFilter?: boolean,
+    // initial field value
+    value?: any,
+    // value component to render
+    valueComponent?: React$ComponentType<{...}>,
+    // path of the label value in option objects
+    valueKey?: string,
+    // valueRenderer: function (option) {}
+    valueRenderer?: (option: OptionType, idx?: number) => React$Node,
+    // optional style to apply to the component wrapper
+    wrapperStyle?: {...},
+    isSearchable?: boolean,
+    // whether to cache the search results
+    cache?: {...} | false
+  |};
+
+  declare type AsyncProps = {|
+    /* The default set of options to show before the user starts searching. When
+     set to `true`, the results for loadOptions('') will be autoloaded. */
+    defaultOptions?: OptionsType | boolean,
+    /* Function that returns a promise, which is the set of options to be used
+     once the promise resolves. */
+    loadOptions: (string, (OptionsType) => void) => Promise<any> | void,
+    /* If cacheOptions is truthy, then the loaded data will be cached. The cache
+     will remain until `cacheOptions` changes value. */
+    cacheOptions?: any
+  |};
+
+  declare export default class Select extends React$Component<Props> {}
+  declare export class Async extends React$Component<{|
+    ...Props,
+    ...AsyncProps
+  |}> {}
+}
diff --git a/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/test_react-select_v1.x.x.js b/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/test_react-select_v1.x.x.js
new file mode 100644
index 0000000000..0b017e5688
--- /dev/null
+++ b/definitions/npm/react-select_v1.x.x/flow_v0.201.x-/test_react-select_v1.x.x.js
@@ -0,0 +1,187 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import React from 'react';
+import Select from 'react-select';
+
+let ArrowRenderer = () => <span />;
+let ClearRenderer = () => <span />;
+let filterOption = (option: {...}, filterString: string) => true;
+let InputRenderer = (props: {...}) => <span />;
+let MenuRenderer = (props: {...}) => [<span />];
+let OptionComponent = (props: {...}) => <span />;
+let OptionRenderer = () => <span />;
+let options = [
+  { value: 123, label: 'first item' },
+  { value: 345, label: 'second item' },
+  { value: 'foo', label: 'third item', clearableValue: true }
+];
+let ValueComponent = (props: {...}) => <span />;
+let ValueRenderer = (option: { label: string, ... }) => option.label;
+
+type OptionType = { [string]: any, ... };
+
+let customOptions: OptionType[] = [
+  {
+    type: 'parent',
+    disabled: true,
+    commonData: 'data'
+  },
+  {
+    type: 'child',
+    disabled: false,
+    commonData: 'data',
+    childData: 'child data 1'
+  },
+  {
+    type: 'child',
+    disabled: false,
+    commonData: 'data',
+    childData: 'child data 2'
+  }
+];
+
+describe('The `Select` component', () => {
+  it('should validate on proper props usage', () => {
+    <Select
+      addLabelText="Add label, plz"
+      aria-describedby="aria-describedby"
+      aria-label="aria-label"
+      aria-labelledby="aria-labelledby"
+      arrowRenderer={ArrowRenderer}
+      autoBlur={false}
+      autoFocus={false}
+      autosize={false}
+      backspaceRemoves={false}
+      backspaceToRemoveMessage="Click backspace to remove"
+      className="my-class-name"
+      clearAllText="Clear all"
+      clearRenderer={ClearRenderer}
+      clearValueText="Clear value"
+      clearable={true}
+      deleteRemoves={false}
+      delimiter=","
+      disabled={false}
+      escapeClearsValue={false}
+      filterOption={filterOption}
+      filterOptions={false}
+      ignoreAccents={false}
+      ignoreCase={false}
+      inputProps={{ someCustomProp: false }}
+      inputRenderer={InputRenderer}
+      instanceId="UNIQUE_ID_HERE"
+      isLoading={false}
+      joinValues={false}
+      labelKey="labelKey"
+      matchPos="start"
+      matchProp="label"
+      menuBuffer={10}
+      menuContainerStyle={{ color: 'green' }}
+      menuRenderer={MenuRenderer}
+      menuStyle={{ color: 'green' }}
+      multi={false}
+      name="fance name"
+      noResultsText="No results found. I'm so terribly sorry. I'll just go now. :´("
+      onBlur={(event): void => {}}
+      onBlurResetsInput={false}
+      onChange={(value: any): void => {}}
+      onClose={(): void => {}}
+      onCloseResetsInput={false}
+      onFocus={event => {}}
+      onInputChange={(value: any) => {
+        return 'foo';
+      }}
+      onInputKeyDown={event => {}}
+      onMenuScrollToBottom={(): void => {}}
+      onOpen={() => {}}
+      onValueClick={(value: string, event: Event) => {}}
+      openAfterFocus={false}
+      openOnFocus={false}
+      optionClassName="fancy-class-for-option"
+      optionComponent={OptionComponent}
+      optionRenderer={OptionRenderer}
+      options={options}
+      pageSize={10}
+      placeholder="Placeholder text"
+      required={false}
+      resetValue={0}
+      scrollMenuIntoView={false}
+      searchable={true}
+      simpleValue={false}
+      style={{ color: 'gray' }}
+      tabIndex={-1}
+      tabSelectsValue={false}
+      value={0}
+      valueComponent={ValueComponent}
+      valueKey="valueKey"
+      valueRenderer={ValueRenderer}
+      wrapperStyle={{ backgroundColor: 'white' }}
+    />;
+  });
+
+  it('should error on invalid props usage', () => {
+    // $FlowExpectedError addLabelText cannot be number
+    <Select addLabelText={123} />;
+  });
+
+  it('should handle custom options', () => {
+    let customOptionRenderer = (o: OptionType) => <span />;
+    let customFilterOption = (options: OptionType[], filterValue: string) =>
+      options;
+    <Select
+      name="name"
+      autoFocus
+      placeholder="Enter data"
+      valueKey="id"
+      labelKey="data"
+      options={customOptions}
+      value=""
+      optionRenderer={customOptionRenderer}
+      filterOptions={customFilterOption}
+    />;
+  });
+
+  it('should error when optionRenderer option param type is not the same as options element type', () => {
+    let invalidRenderer = (o: string) => <span />;
+    // $FlowExpectedError
+    <Select
+      name="name"
+      autoFocus
+      placeholder="Enter data"
+      valueKey="id"
+      labelKey="data"
+      options={customOptions}
+      value=""
+      optionRenderer={invalidRenderer}
+    />;
+  });
+
+  it('should error when filterOptions options param type is not an array of options element type', () => {
+    let invalidFilterOptions = (o: string) => <span />;
+    // $FlowExpectedError
+    <Select
+      name="name"
+      autoFocus
+      placeholder="Enter data"
+      valueKey="id"
+      labelKey="data"
+      options={customOptions}
+      value=""
+      filterOptions={invalidFilterOptions}
+    />;
+  });
+
+  it('should error when given non-existent prop', () => {
+    // Deprecated autofocus
+    // $FlowExpectedError
+    <Select
+      name="name"
+      autofocus
+      placeholder="Enter data"
+      valueKey="id"
+      labelKey="data"
+      options={customOptions}
+      value=""
+    />;
+  });
+});
diff --git a/definitions/npm/react-slick_v0.16.x/flow_v0.104.x-/react-slick_v0.16.x.js b/definitions/npm/react-slick_v0.16.x/flow_v0.104.x-v.200.x/react-slick_v0.16.x.js
similarity index 100%
rename from definitions/npm/react-slick_v0.16.x/flow_v0.104.x-/react-slick_v0.16.x.js
rename to definitions/npm/react-slick_v0.16.x/flow_v0.104.x-v.200.x/react-slick_v0.16.x.js
diff --git a/definitions/npm/react-slick_v0.16.x/flow_v0.201.x-/react-slick_v0.16.x.js b/definitions/npm/react-slick_v0.16.x/flow_v0.201.x-/react-slick_v0.16.x.js
new file mode 100644
index 0000000000..62ffcf3511
--- /dev/null
+++ b/definitions/npm/react-slick_v0.16.x/flow_v0.201.x-/react-slick_v0.16.x.js
@@ -0,0 +1,76 @@
+declare module "react-slick" {
+  declare export type CustomArrowProps = {
+    className?: string,
+    style?: CSSStyleDeclaration,
+    onClick?: (e: SyntheticMouseEvent<any>) => void,
+    currentSlide?: number,
+    slideCount?: number,
+    ...
+  };
+
+  declare export type ResponsiveObject = {
+    breakpoint: number,
+    settings: "unslick" | Props,
+    ...
+  };
+
+  declare export type SwipeDirection =
+    | "left"
+    | "down"
+    | "right"
+    | "up"
+    | string;
+
+  declare export type Props = {
+    accessibility?: boolean,
+    className?: string,
+    adaptiveHeight?: boolean,
+    arrows?: boolean,
+    nextArrow?: React$Element<any>,
+    prevArrow?: React$Element<any>,
+    autoplay?: boolean,
+    autoplaySpeed?: number,
+    centerMode?: boolean,
+    centerPadding?: string,
+    cssEase?: string,
+    customPaging?: (index: number) => React$Element<any>,
+    dots?: boolean,
+    dotsClass?: string,
+    draggable?: boolean,
+    easing?: string,
+    fade?: boolean,
+    focusOnSelect?: boolean,
+    infinite?: boolean,
+    initialSlide?: number,
+    lazyLoad?: boolean,
+    pauseOnHover?: boolean,
+    responsive?: Array<ResponsiveObject>,
+    rtl?: boolean,
+    slide?: string,
+    slidesToShow?: number,
+    slidesToScroll?: number,
+    speed?: number,
+    swipe?: boolean,
+    swipeToSlide?: boolean,
+    touchMove?: boolean,
+    touchThreshold?: number,
+    variableWidth?: boolean,
+    useCSS?: boolean,
+    vertical?: boolean,
+    afterChange?: (currentSlide: number) => void,
+    beforeChange?: (currentSlide: number, nextSlide: number) => void,
+    slickGoTo?: number,
+    edgeFriction?: number,
+    waitForAnimate?: boolean,
+    edgeEvent?: (swipeDirection: SwipeDirection) => void,
+    swipeEvent?: (swipeDirection: SwipeDirection) => void,
+    init?: () => void,
+    ...
+  };
+
+  declare export default class Slider extends React$Component<Props> {
+    slickNext(): void;
+    slickPrev(): void;
+    slickGoTo(slideNumber: number): void;
+  }
+}
diff --git a/definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-/react-testing-library_v2.0.x.js b/definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-v.200.x/react-testing-library_v2.0.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-/react-testing-library_v2.0.x.js
rename to definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-v.200.x/react-testing-library_v2.0.x.js
diff --git a/definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-/test_react-testing-library_v2.0.x.js b/definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-v.200.x/test_react-testing-library_v2.0.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-/test_react-testing-library_v2.0.x.js
rename to definitions/npm/react-testing-library_v2.0.x/flow_v0.104.x-v.200.x/test_react-testing-library_v2.0.x.js
diff --git a/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/react-testing-library_v2.0.x.js b/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/react-testing-library_v2.0.x.js
new file mode 100644
index 0000000000..e6a84910b8
--- /dev/null
+++ b/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/react-testing-library_v2.0.x.js
@@ -0,0 +1,34 @@
+declare module 'react-testing-library' {
+  declare type RenderResult = {
+    container: HTMLDivElement,
+    unmount: () => void,
+    queryByTestId: (id: string) => ?HTMLElement,
+    getByTestId: (id: string) => HTMLElement,
+    queryByText: (id: string) => ?HTMLElement,
+    getByText: (id: string) => HTMLElement,
+    queryByPlaceholderText: (id: string) => ?HTMLElement,
+    getByPlaceholderText: (id: string) => HTMLElement,
+    queryByLabelText: (id: string) => ?HTMLElement,
+    getByLabelText: (id: string) => HTMLElement,
+    queryByAltText: (text: string) => ?HTMLElement,
+    getByAltText: (text: string) => HTMLElement,
+    ...
+  }
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: { container: HTMLElement, ... }
+  ): RenderResult
+
+  declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    },
+  ): Promise<void>;
+
+  // copy from react-dom/test-utils
+  declare export var Simulate: { [eventName: string]: (element: Element, eventData?: Object) => void, ... };
+}
diff --git a/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/test_react-testing-library_v2.0.x.js b/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/test_react-testing-library_v2.0.x.js
new file mode 100644
index 0000000000..0819eea9ef
--- /dev/null
+++ b/definitions/npm/react-testing-library_v2.0.x/flow_v0.201.x-/test_react-testing-library_v2.0.x.js
@@ -0,0 +1,99 @@
+// @flow
+
+import React from 'react';
+import { render, Simulate, wait } from 'react-testing-library';
+import { describe, it } from 'flow-typed-test';
+
+describe('wait()', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError
+    wait(1);
+    // $FlowExpectedError
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('render()', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    container,
+    unmount,
+    queryByTestId,
+    getByTestId,
+    queryByText,
+    getByText,
+    queryByPlaceholderText,
+    getByPlaceholderText,
+    queryByLabelText,
+    getByLabelText,
+    queryByAltText,
+    getByAltText
+  } = render(<Component/>);
+
+  it('unmount() should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('queryByTestId should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('getByTestId should return html element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('queryByText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryByText should return html element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('queryByPlaceholderText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('getByPlaceholderText should return html element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('queryByLabelText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('getByLabelText should return html element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('queryByAltText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('getByAltText should return html element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+});
diff --git a/definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-/react-testing-library_v2.1.x.js b/definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-v.200.x/react-testing-library_v2.1.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-/react-testing-library_v2.1.x.js
rename to definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-v.200.x/react-testing-library_v2.1.x.js
diff --git a/definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-/test_react-testing-library_v2.1.x.js b/definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-v.200.x/test_react-testing-library_v2.1.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-/test_react-testing-library_v2.1.x.js
rename to definitions/npm/react-testing-library_v2.1.x/flow_v0.104.x-v.200.x/test_react-testing-library_v2.1.x.js
diff --git a/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/react-testing-library_v2.1.x.js b/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/react-testing-library_v2.1.x.js
new file mode 100644
index 0000000000..5653cac75a
--- /dev/null
+++ b/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/react-testing-library_v2.1.x.js
@@ -0,0 +1,113 @@
+declare module 'react-testing-library' {
+  declare type RenderResult = {
+    container: HTMLDivElement,
+    unmount: () => void,
+    queryByTestId: (id: string) => ?HTMLElement,
+    getByTestId: (id: string) => HTMLElement,
+    queryByText: (id: string) => ?HTMLElement,
+    getByText: (id: string) => HTMLElement,
+    queryByPlaceholderText: (id: string) => ?HTMLElement,
+    getByPlaceholderText: (id: string) => HTMLElement,
+    queryByLabelText: (id: string) => ?HTMLElement,
+    getByLabelText: (id: string) => HTMLElement,
+    queryByAltText: (text: string) => ?HTMLElement,
+    getByAltText: (text: string) => HTMLElement,
+    ...
+  };
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: { container: HTMLElement, ... }
+  ): RenderResult;
+
+  declare export function renderIntoDocument(ui: React$Element<any>): RenderResult;
+  declare export function cleanup(): void;
+
+  declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    },
+  ): Promise<void>;
+
+  // copy from react-dom/test-utils
+  declare export var Simulate: { [eventName: string]: (element: Element, eventData?: Object) => void, ... };
+
+  declare type FireEvent<TInit> = (element: HTMLElement, eventInit?: TInit) => void;
+
+  declare export var fireEvent: {
+    (element: HTMLElement, event: Event): void,
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+    ...
+  };
+}
diff --git a/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/test_react-testing-library_v2.1.x.js b/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/test_react-testing-library_v2.1.x.js
new file mode 100644
index 0000000000..05cdc3aad9
--- /dev/null
+++ b/definitions/npm/react-testing-library_v2.1.x/flow_v0.201.x-/test_react-testing-library_v2.1.x.js
@@ -0,0 +1,277 @@
+// @flow
+
+import React from 'react';
+import { render, Simulate, wait, fireEvent, renderIntoDocument, cleanup } from 'react-testing-library';
+import { describe, it } from 'flow-typed-test';
+
+describe('wait()', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError
+    wait(1);
+    // $FlowExpectedError
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('render()', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    container,
+    unmount,
+    queryByTestId,
+    getByTestId,
+    queryByText,
+    getByText,
+    queryByPlaceholderText,
+    getByPlaceholderText,
+    queryByLabelText,
+    getByLabelText,
+    queryByAltText,
+    getByAltText
+  } = render(<Component/>);
+
+  it('unmount() should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('queryByTestId should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('getByTestId should return html element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('queryByText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryByText should return html element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('queryByPlaceholderText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('getByPlaceholderText should return html element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('queryByLabelText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('getByLabelText should return html element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('queryByAltText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('getByAltText should return html element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+});
+
+describe('renderIntoDocument()', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    container,
+    unmount,
+    queryByTestId,
+    getByTestId,
+    queryByText,
+    getByText,
+    queryByPlaceholderText,
+    getByPlaceholderText,
+    queryByLabelText,
+    getByLabelText,
+    queryByAltText,
+    getByAltText
+  } = renderIntoDocument(<Component/>);
+
+  it('unmount() should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('queryByTestId should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('getByTestId should return html element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('queryByText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryByText should return html element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('queryByPlaceholderText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('getByPlaceholderText should return html element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('queryByLabelText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('getByLabelText should return html element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('queryByAltText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('getByAltText should return html element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+});
+
+describe('cleanup()', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError
+    cleanup(1);
+  });
+});
+
+describe('fireEvent()', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(htmlEl, new MouseEvent('click', {
+      bubbles: true,
+      cancelable: true,
+    }));
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError
+    fireEvent(1);
+    // $FlowExpectedError
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
diff --git a/definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-/react-testing-library_v3.x.x.js b/definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-v.200.x/react-testing-library_v3.x.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-/react-testing-library_v3.x.x.js
rename to definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-v.200.x/react-testing-library_v3.x.x.js
diff --git a/definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-/test_react-testing-library_v3.x.x.js b/definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-v.200.x/test_react-testing-library_v3.x.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-/test_react-testing-library_v3.x.x.js
rename to definitions/npm/react-testing-library_v3.x.x/flow_v0.104.x-v.200.x/test_react-testing-library_v3.x.x.js
diff --git a/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/react-testing-library_v3.x.x.js b/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/react-testing-library_v3.x.x.js
new file mode 100644
index 0000000000..d4e2e94ce5
--- /dev/null
+++ b/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/react-testing-library_v3.x.x.js
@@ -0,0 +1,132 @@
+declare module 'react-testing-library' {
+  declare type TextMatch = string | RegExp | (content: string, element: HTMLElement) => boolean;
+
+  declare type TextMatchOptions = {
+    exact?: boolean,
+    trim?: boolean,
+    collapseWhitespace?: boolean,
+    ...
+  };
+
+  declare type RenderResult = {
+    container: HTMLDivElement,
+    unmount: () => void,
+    queryByTestId: (id: TextMatch, options?: TextMatchOptions,) => ?HTMLElement,
+    getByTestId: (id: TextMatch, options?: TextMatchOptions) => HTMLElement,
+    queryByText: (text: TextMatch, options?: TextMatchOptions) => ?HTMLElement,
+    getByText: (text: TextMatch, options?: TextMatchOptions) => HTMLElement,
+    queryByPlaceholderText: (text: TextMatch, options?: TextMatchOptions) => ?HTMLElement,
+    getByPlaceholderText: (text: TextMatch, options?: TextMatchOptions) => HTMLElement,
+    queryByLabelText: (text: TextMatch, options?: TextMatchOptions) => ?HTMLElement,
+    getByLabelText: (text: TextMatch, options?: { selector?: string, ... } & TextMatchOptions) => HTMLElement,
+    queryByAltText: (text: TextMatch, options?: TextMatchOptions) => ?HTMLElement,
+    getByAltText: (text: TextMatch, options?: TextMatchOptions) => HTMLElement,
+    ...
+  };
+
+  declare export function render(
+    ui: React$Element<any>,
+    options?: { container: HTMLElement, ... }
+  ): RenderResult;
+
+  // copy from react-dom/test-utils
+  declare export var Simulate: { [eventName: string]: (element: Element, eventData?: Object) => void, ... };
+
+  declare export function wait(
+    callback?: () => void,
+    options?: {
+      timeout?: number,
+      interval?: number,
+      ...
+    },
+  ): Promise<void>;
+
+  declare export function waitForElement<T>(
+    callback?: () => T,
+    options?: {
+      container?: HTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    },
+  ): Promise<T | void>
+
+  declare type FireEvent<TInit> = (element: HTMLElement, eventInit?: TInit) => boolean;
+
+  declare export var fireEvent: {
+    (element: HTMLElement, event: Event): boolean,
+    copy: FireEvent<Event$Init>,
+    cut: FireEvent<Event$Init>,
+    paste: FireEvent<Event$Init>,
+    compositionEnd: FireEvent<Event$Init>,
+    compositionStart: FireEvent<Event$Init>,
+    compositionUpdate: FireEvent<Event$Init>,
+    keyDown: FireEvent<Event$Init>,
+    keyPress: FireEvent<Event$Init>,
+    keyUp: FireEvent<Event$Init>,
+    focus: FireEvent<Event$Init>,
+    blur: FireEvent<Event$Init>,
+    change: FireEvent<Event$Init>,
+    input: FireEvent<Event$Init>,
+    invalid: FireEvent<Event$Init>,
+    submit: FireEvent<Event$Init>,
+    click: FireEvent<MouseEvent$MouseEventInit>,
+    contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+    dblClick: FireEvent<MouseEvent$MouseEventInit>,
+    doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+    drag: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+    dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+    dragExit: FireEvent<MouseEvent$MouseEventInit>,
+    dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+    dragOver: FireEvent<MouseEvent$MouseEventInit>,
+    dragStart: FireEvent<MouseEvent$MouseEventInit>,
+    drop: FireEvent<MouseEvent$MouseEventInit>,
+    mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+    mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+    mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+    mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+    mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+    mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+    select: FireEvent<Event$Init>,
+    touchCancel: FireEvent<Event$Init>,
+    touchEnd: FireEvent<Event$Init>,
+    touchMove: FireEvent<Event$Init>,
+    touchStart: FireEvent<Event$Init>,
+    scroll: FireEvent<Event$Init>,
+    wheel: FireEvent<MouseEvent$MouseEventInit>,
+    abort: FireEvent<Event$Init>,
+    canPlay: FireEvent<Event$Init>,
+    canPlayThrough: FireEvent<Event$Init>,
+    durationChange: FireEvent<Event$Init>,
+    emptied: FireEvent<Event$Init>,
+    encrypted: FireEvent<Event$Init>,
+    ended: FireEvent<Event$Init>,
+    loadedData: FireEvent<Event$Init>,
+    loadedMetadata: FireEvent<Event$Init>,
+    loadStart: FireEvent<Event$Init>,
+    pause: FireEvent<Event$Init>,
+    play: FireEvent<Event$Init>,
+    playing: FireEvent<Event$Init>,
+    progress: FireEvent<Event$Init>,
+    rateChange: FireEvent<Event$Init>,
+    seeked: FireEvent<Event$Init>,
+    seeking: FireEvent<Event$Init>,
+    stalled: FireEvent<Event$Init>,
+    suspend: FireEvent<Event$Init>,
+    timeUpdate: FireEvent<Event$Init>,
+    volumeChange: FireEvent<Event$Init>,
+    waiting: FireEvent<Event$Init>,
+    load: FireEvent<Event$Init>,
+    error: FireEvent<Event$Init>,
+    animationStart: FireEvent<Event$Init>,
+    animationEnd: FireEvent<Event$Init>,
+    animationIteration: FireEvent<Event$Init>,
+    transitionEnd: FireEvent<Event$Init>,
+    ...
+  };
+
+  declare export function renderIntoDocument(ui: React$Element<any>): RenderResult;
+  declare export function cleanup(): void;
+}
diff --git a/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/test_react-testing-library_v3.x.x.js b/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/test_react-testing-library_v3.x.x.js
new file mode 100644
index 0000000000..c2ef3d8269
--- /dev/null
+++ b/definitions/npm/react-testing-library_v3.x.x/flow_v0.201.x-/test_react-testing-library_v3.x.x.js
@@ -0,0 +1,329 @@
+// @flow
+
+import React from 'react';
+import { render, Simulate, wait, fireEvent, renderIntoDocument, cleanup, waitForElement } from 'react-testing-library';
+import { describe, it } from 'flow-typed-test';
+
+describe('wait', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError
+    wait(1);
+    // $FlowExpectedError
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError
+    waitForElement(1);
+    // $FlowExpectedError
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100
+    });
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    container,
+    unmount,
+    queryByTestId,
+    getByTestId,
+    queryByText,
+    getByText,
+    queryByPlaceholderText,
+    getByPlaceholderText,
+    queryByLabelText,
+    getByLabelText,
+    queryByAltText,
+    getByAltText
+  } = render(<Component/>);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('queryByTestId should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('getByTestId should return html element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('queryByText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryByText should return html element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('queryByPlaceholderText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('getByPlaceholderText should return html element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('queryByLabelText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('getByLabelText should return html element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('queryByAltText should return maybe html element', () => {
+    // $FlowExpectedError
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('getByAltText should return html element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+});
+
+describe('renderIntoDocument', () => {
+  class Component extends React.Component<{...}> {}
+  const renderResult = render(<Component/>);
+
+  it('return value should have the same signature as the value returned from render()', () => {
+    const renderIntoDocumentResult: typeof renderResult = renderIntoDocument(<Component/>);
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError
+    cleanup(1);
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(htmlEl, new MouseEvent('click', {
+      bubbles: true,
+      cancelable: true,
+    }));
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError
+    fireEvent(1);
+    // $FlowExpectedError
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    queryByTestId,
+    getByTestId,
+    queryByText,
+    getByText,
+    queryByPlaceholderText,
+    getByPlaceholderText,
+    queryByLabelText,
+    getByLabelText,
+    queryByAltText,
+    getByAltText
+  } = render(<Component/>);
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, { trim: true, collapseWhitespace: true, exact: true });
+  });
+});
diff --git a/definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-/react-testing-library_v5.x.x.js b/definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-v.200.x/react-testing-library_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-/react-testing-library_v5.x.x.js
rename to definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-v.200.x/react-testing-library_v5.x.x.js
diff --git a/definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-/test_react-testing-library_v5.x.x.js b/definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-v.200.x/test_react-testing-library_v5.x.x.js
similarity index 100%
rename from definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-/test_react-testing-library_v5.x.x.js
rename to definitions/npm/react-testing-library_v5.x.x/flow_v0.104.x-v.200.x/test_react-testing-library_v5.x.x.js
diff --git a/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/react-testing-library_v5.x.x.js b/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/react-testing-library_v5.x.x.js
new file mode 100644
index 0000000000..2f24878766
--- /dev/null
+++ b/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/react-testing-library_v5.x.x.js
@@ -0,0 +1,276 @@
+declare module 'react-testing-library' {
+  declare type TextMatch =
+    | string
+    | RegExp
+    | ((content: string, element: HTMLElement) => boolean);
+
+  declare type TextMatchOptions = {
+    exact?: boolean,
+    trim?: boolean,
+    collapseWhitespace?: boolean,
+    ...
+  };
+
+  declare type SelectorMatchOptions = { selector?: string, ... } & TextMatchOptions;
+
+  declare type GetByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByText = (
+    text: TextMatch,
+    options?: SelectorMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => HTMLElement;
+
+  declare type QueryByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => ?HTMLElement;
+
+  declare type AllByBoundAttribute = (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<HTMLElement>;
+
+  declare type GetsAndQueries = {|
+    getByAltText: GetByBoundAttribute,
+    getAllByAltText: AllByBoundAttribute,
+    queryByAltText: QueryByBoundAttribute,
+    queryAllByAltText: AllByBoundAttribute,
+
+    getByDisplayValue: GetByBoundAttribute,
+    getAllByDisplayValue: AllByBoundAttribute,
+    queryByDisplayValue: QueryByBoundAttribute,
+    queryAllByDisplayValue: AllByBoundAttribute,
+
+    getByLabelText: GetByText,
+    getAllByLabelText: AllByText,
+    queryByLabelText: QueryByText,
+    queryAllByLabelText: AllByText,
+
+    getByPlaceholderText: GetByBoundAttribute,
+    getAllByPlaceholderText: AllByBoundAttribute,
+    queryByPlaceholderText: QueryByBoundAttribute,
+    queryAllByPlaceholderText: AllByBoundAttribute,
+
+    getByRole: GetByBoundAttribute,
+    getAllByRole: AllByBoundAttribute,
+    queryByRole: QueryByBoundAttribute,
+    queryAllByRole: AllByBoundAttribute,
+
+    getBySelectText: GetByBoundAttribute,
+    getAllBySelectText: AllByBoundAttribute,
+    queryBySelectText: QueryByBoundAttribute,
+    queryAllBySelectText: AllByBoundAttribute,
+
+    getByTestId: GetByBoundAttribute,
+    getAllByTestId: AllByBoundAttribute,
+    queryByTestId: QueryByBoundAttribute,
+    queryAllByTestId: AllByBoundAttribute,
+
+    getByText: GetByText,
+    getAllByText: AllByText,
+    queryByText: QueryByText,
+    queryAllByText: AllByText,
+
+    getByTitle: GetByBoundAttribute,
+    getAllByTitle: AllByBoundAttribute,
+    queryByTitle: QueryByBoundAttribute,
+    queryAllByTitle: AllByBoundAttribute,
+
+    getByValue: GetByBoundAttribute,
+    getAllByValue: AllByBoundAttribute,
+    queryByValue: QueryByBoundAttribute,
+    queryAllByValue: AllByBoundAttribute,
+  |};
+
+  declare type RenderResult = {|
+    ...GetsAndQueries,
+    container: HTMLDivElement,
+    unmount: () => void,
+    baseElement: HTMLElement,
+    asFragment: () => DocumentFragment,
+    debug: (baseElement?: HTMLElement) => void,
+    rerender: (ui: React$Element<any>) => void,
+  |};
+
+  declare type FireEvent<TInit> = (
+    element: HTMLElement,
+    eventProperties?: TInit
+  ) => boolean;
+
+  declare module.exports: {
+    render: (
+      ui: React$Element<any>,
+      options?: {
+        container: HTMLElement,
+        baseElement?: HTMLElement,
+        ...
+      }
+    ) => RenderResult,
+    cleanup: () => void,
+    wait: (
+      callback?: () => void,
+      options?: {
+        timeout?: number,
+        interval?: number,
+        ...
+      }
+    ) => Promise<void>,
+    waitForDomChange: <T>(options?: {
+      container?: HTMLElement,
+      timeout?: number,
+      mutationObserverOptions?: MutationObserverInit,
+      ...
+    }) => Promise<T>,
+    waitForElement: <T>(
+      callback?: () => T,
+      options?: {
+        container?: HTMLElement,
+        timeout?: number,
+        mutationObserverOptions?: MutationObserverInit,
+        ...
+      }
+    ) => Promise<T>,
+    within: (
+      element: HTMLElement,
+      queriesToBind?: GetsAndQueries | Array<GetsAndQueries>
+    ) => GetsAndQueries,
+    fireEvent: {|
+      (element: HTMLElement, event: Event): void,
+
+      copy: FireEvent<Event$Init>,
+      cut: FireEvent<Event$Init>,
+      paste: FireEvent<Event$Init>,
+      compositionEnd: FireEvent<Event$Init>,
+      compositionStart: FireEvent<Event$Init>,
+      compositionUpdate: FireEvent<Event$Init>,
+      keyDown: FireEvent<Event$Init>,
+      keyPress: FireEvent<Event$Init>,
+      keyUp: FireEvent<Event$Init>,
+      focus: FireEvent<Event$Init>,
+      blur: FireEvent<Event$Init>,
+      change: FireEvent<Event$Init>,
+      input: FireEvent<Event$Init>,
+      invalid: FireEvent<Event$Init>,
+      submit: FireEvent<Event$Init>,
+      click: FireEvent<MouseEvent$MouseEventInit>,
+      contextMenu: FireEvent<MouseEvent$MouseEventInit>,
+      dblClick: FireEvent<MouseEvent$MouseEventInit>,
+      doubleClick: FireEvent<MouseEvent$MouseEventInit>,
+      drag: FireEvent<MouseEvent$MouseEventInit>,
+      dragEnd: FireEvent<MouseEvent$MouseEventInit>,
+      dragEnter: FireEvent<MouseEvent$MouseEventInit>,
+      dragExit: FireEvent<MouseEvent$MouseEventInit>,
+      dragLeave: FireEvent<MouseEvent$MouseEventInit>,
+      dragOver: FireEvent<MouseEvent$MouseEventInit>,
+      dragStart: FireEvent<MouseEvent$MouseEventInit>,
+      drop: FireEvent<MouseEvent$MouseEventInit>,
+      mouseDown: FireEvent<MouseEvent$MouseEventInit>,
+      mouseEnter: FireEvent<MouseEvent$MouseEventInit>,
+      mouseLeave: FireEvent<MouseEvent$MouseEventInit>,
+      mouseMove: FireEvent<MouseEvent$MouseEventInit>,
+      mouseOut: FireEvent<MouseEvent$MouseEventInit>,
+      mouseOver: FireEvent<MouseEvent$MouseEventInit>,
+      mouseUp: FireEvent<MouseEvent$MouseEventInit>,
+      select: FireEvent<Event$Init>,
+      touchCancel: FireEvent<Event$Init>,
+      touchEnd: FireEvent<Event$Init>,
+      touchMove: FireEvent<Event$Init>,
+      touchStart: FireEvent<Event$Init>,
+      scroll: FireEvent<Event$Init>,
+      wheel: FireEvent<MouseEvent$MouseEventInit>,
+      abort: FireEvent<Event$Init>,
+      canPlay: FireEvent<Event$Init>,
+      canPlayThrough: FireEvent<Event$Init>,
+      durationChange: FireEvent<Event$Init>,
+      emptied: FireEvent<Event$Init>,
+      encrypted: FireEvent<Event$Init>,
+      ended: FireEvent<Event$Init>,
+      loadedData: FireEvent<Event$Init>,
+      loadedMetadata: FireEvent<Event$Init>,
+      loadStart: FireEvent<Event$Init>,
+      pause: FireEvent<Event$Init>,
+      play: FireEvent<Event$Init>,
+      playing: FireEvent<Event$Init>,
+      progress: FireEvent<Event$Init>,
+      rateChange: FireEvent<Event$Init>,
+      seeked: FireEvent<Event$Init>,
+      seeking: FireEvent<Event$Init>,
+      stalled: FireEvent<Event$Init>,
+      suspend: FireEvent<Event$Init>,
+      timeUpdate: FireEvent<Event$Init>,
+      volumeChange: FireEvent<Event$Init>,
+      waiting: FireEvent<Event$Init>,
+      load: FireEvent<Event$Init>,
+      error: FireEvent<Event$Init>,
+      animationStart: FireEvent<Event$Init>,
+      animationEnd: FireEvent<Event$Init>,
+      animationIteration: FireEvent<Event$Init>,
+      transitionEnd: FireEvent<Event$Init>,
+    |},
+    // dom-testing-library re-exports
+    queryByTestId: (
+      container: HTMLElement,
+      id: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByTestId: (
+      container: HTMLElement,
+      id: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    queryByText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: { selector?: string, ... } & TextMatchOptions
+    ) => HTMLElement,
+    queryByPlaceholderText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByPlaceholderText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    queryByLabelText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByLabelText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: { selector?: string, ... } & TextMatchOptions
+    ) => HTMLElement,
+    queryByAltText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => ?HTMLElement,
+    getByAltText: (
+      container: HTMLElement,
+      text: TextMatch,
+      options?: TextMatchOptions
+    ) => HTMLElement,
+    ...
+  };
+}
diff --git a/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/test_react-testing-library_v5.x.x.js b/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/test_react-testing-library_v5.x.x.js
new file mode 100644
index 0000000000..ff62c9df95
--- /dev/null
+++ b/definitions/npm/react-testing-library_v5.x.x/flow_v0.201.x-/test_react-testing-library_v5.x.x.js
@@ -0,0 +1,1081 @@
+// @flow
+
+import React from 'react';
+import {
+  render,
+  wait,
+  fireEvent,
+  cleanup,
+  waitForDomChange,
+  waitForElement,
+  within,
+} from 'react-testing-library';
+import { describe, it } from 'flow-typed-test';
+
+describe('wait', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    wait(1);
+    // $FlowExpectedError[incompatible-call]
+    wait(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    wait(() => {});
+    wait(() => {}, { timeout: 1 });
+  });
+});
+
+describe('waitForDomChange', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForDomChange('1');
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForDomChange({ container: document.createElement('div') });
+    waitForDomChange({ timeout: 1 });
+  });
+});
+
+describe('waitForElement', () => {
+  it('should fail on invalid inputs', () => {
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(1);
+    // $FlowExpectedError[incompatible-call]
+    waitForElement(() => {}, 1);
+  });
+
+  it('should pass on correct inputs', () => {
+    waitForElement(() => document.createElement('div'));
+    waitForElement(() => document.createElement('div'), {
+      container: document.createElement('div'),
+      timeout: 100,
+    });
+  });
+
+  it('should return a usable value.', async n => {
+    const usernameElement = await waitForElement(() =>
+      document.createElement('input')
+    );
+
+    usernameElement.value = 'chucknorris';
+  });
+});
+
+describe('render', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    container,
+    unmount,
+    baseElement,
+    asFragment,
+    debug,
+    rerender,
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('unmount should has 0 arguments', () => {
+    unmount();
+    // $FlowExpectedError[extra-arg]
+    unmount(1);
+  });
+
+  it('container should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = container;
+    const b: HTMLElement = container;
+  });
+
+  it('baseElement should be an html element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: number = baseElement;
+    const b: HTMLElement = baseElement;
+  });
+
+  it('asFragment should return a document fragment', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = asFragment();
+    const b: DocumentFragment = asFragment();
+  })
+
+  it('debug maybe has 1 argument an html element', () => {
+    // $FlowExpectedError[incompatible-call]
+    debug(1);
+    debug(container);
+  });
+
+  it('rerender should has 1 argument an react element', () => {
+    // $FlowExpectedError[incompatible-call]
+    rerender();
+    rerender(<Component />);
+  });
+
+  it('getByAltText should return HTML element', () => {
+    const a: HTMLElement = getByAltText('1');
+  });
+
+  it('getAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByAltText('1');
+    const b: Array<HTMLElement> = getAllByAltText('2');
+  });
+
+  it('queryByAltText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByAltText('1');
+    const b: ?HTMLElement = queryByAltText('2');
+  });
+
+  it('queryAllByAltText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByAltText('1');
+    const b: Array<HTMLElement> = queryAllByAltText('2');
+  });
+
+  it('getByDisplayValue should return HTML element', () => {
+    const a: HTMLElement = getByDisplayValue('1');
+  });
+
+  it('getAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByDisplayValue('1');
+    const b: Array<HTMLElement> = getAllByDisplayValue('2');
+  });
+
+  it('queryByDisplayValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByDisplayValue('1');
+    const b: ?HTMLElement = queryByDisplayValue('2');
+  });
+
+  it('queryAllByDisplayValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByDisplayValue('1');
+    const b: Array<HTMLElement> = queryAllByDisplayValue('2');
+  });
+
+  it('getByLabelText should return HTML element', () => {
+    const a: HTMLElement = getByLabelText('1');
+  });
+
+  it('getAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByLabelText('1');
+    const b: Array<HTMLElement> = getAllByLabelText('2');
+  });
+
+  it('queryByLabelText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByLabelText('1');
+    const b: ?HTMLElement = queryByLabelText('2');
+  });
+
+  it('queryAllByLabelText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByLabelText('1');
+    const b: Array<HTMLElement> = queryAllByLabelText('2');
+  });
+
+  it('getByPlaceholderText should return HTML element', () => {
+    const a: HTMLElement = getByPlaceholderText('1');
+  });
+
+  it('getAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = getAllByPlaceholderText('2');
+  });
+
+  it('queryByPlaceholderText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByPlaceholderText('1');
+    const b: ?HTMLElement = queryByPlaceholderText('2');
+  });
+
+  it('queryAllByPlaceholderText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByPlaceholderText('1');
+    const b: Array<HTMLElement> = queryAllByPlaceholderText('2');
+  });
+
+  it('getByRole should return HTML element', () => {
+    const a: HTMLElement = getByRole('1');
+  });
+
+  it('getAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByRole('1');
+    const b: Array<HTMLElement> = getAllByRole('2');
+  });
+
+  it('queryByRole should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByRole('1');
+    const b: ?HTMLElement = queryByRole('2');
+  });
+
+  it('queryAllByRole should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByRole('1');
+    const b: Array<HTMLElement> = queryAllByRole('2');
+  });
+
+  it('getBySelectText should return HTML element', () => {
+    const a: HTMLElement = getBySelectText('1');
+  });
+
+  it('getAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllBySelectText('1');
+    const b: Array<HTMLElement> = getAllBySelectText('2');
+  });
+
+  it('queryBySelectText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryBySelectText('1');
+    const b: ?HTMLElement = queryBySelectText('2');
+  });
+
+  it('queryAllBySelectText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllBySelectText('1');
+    const b: Array<HTMLElement> = queryAllBySelectText('2');
+  });
+
+  it('getByTestId should return HTML element', () => {
+    const a: HTMLElement = getByTestId('1');
+  });
+
+  it('getAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTestId('1');
+    const b: Array<HTMLElement> = getAllByTestId('2');
+  });
+
+  it('queryByTestId should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTestId('1');
+    const b: ?HTMLElement = queryByTestId('2');
+  });
+
+  it('queryAllByTestId should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTestId('1');
+    const b: Array<HTMLElement> = queryAllByTestId('2');
+  });
+
+  it('getByText should return HTML element', () => {
+    const a: HTMLElement = getByText('1');
+  });
+
+  it('getAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByText('1');
+    const b: Array<HTMLElement> = getAllByText('2');
+  });
+
+  it('queryByText should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByText('1');
+    const b: ?HTMLElement = queryByText('2');
+  });
+
+  it('queryAllByText should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByText('1');
+    const b: Array<HTMLElement> = queryAllByText('2');
+  });
+
+  it('getByTitle should return HTML element', () => {
+    const a: HTMLElement = getByTitle('1');
+  });
+
+  it('getAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByTitle('1');
+    const b: Array<HTMLElement> = getAllByTitle('2');
+  });
+
+  it('queryByTitle should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByTitle('1');
+    const b: ?HTMLElement = queryByTitle('2');
+  });
+
+  it('queryAllByTitle should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByTitle('1');
+    const b: Array<HTMLElement> = queryAllByTitle('2');
+  });
+
+  it('getByValue should return HTML element', () => {
+    const a: HTMLElement = getByValue('1');
+  });
+
+  it('getAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = getAllByValue('1');
+    const b: Array<HTMLElement> = getAllByValue('2');
+  });
+
+  it('queryByValue should return maybe HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryByValue('1');
+    const b: ?HTMLElement = queryByValue('2');
+  });
+
+  it('queryAllByValue should return array of HTML element', () => {
+    // $FlowExpectedError[incompatible-type]
+    const a: HTMLElement = queryAllByValue('1');
+    const b: Array<HTMLElement> = queryAllByValue('2');
+  });
+});
+
+describe('cleanup', () => {
+  it('should be a function w/o arguments', () => {
+    cleanup();
+    // $FlowExpectedError[extra-arg]
+    cleanup(1);
+  });
+});
+
+describe('within', () => {
+  class Component extends React.Component<{...}> {}
+  const { container } = render(<Component />);
+
+  it('should has html element as argument', () => {
+    // $FlowExpectedError[incompatible-call]
+    within();
+    within(container);
+  });
+
+  it('should have getByAltText', () => {
+    within(container).getByAltText('1');
+  });
+
+  it('should have getAllByAltText', () => {
+    within(container).getAllByAltText('1');
+  });
+
+  it('should have queryByAltText', () => {
+    within(container).queryByAltText('1');
+  });
+
+  it('should have queryAllByAltText', () => {
+    within(container).queryAllByAltText('1');
+  });
+
+  it('should have getByDisplayValue', () => {
+    within(container).getByDisplayValue('1');
+  });
+
+  it('should have getAllByDisplayValue', () => {
+    within(container).getAllByDisplayValue('1');
+  });
+
+  it('should have queryByDisplayValue', () => {
+    within(container).queryByDisplayValue('1');
+  });
+
+  it('should have queryAllByDisplayValue', () => {
+    within(container).queryAllByDisplayValue('1');
+  });
+
+  it('should have getByLabelText', () => {
+    within(container).getByLabelText('1');
+  });
+
+  it('should have getAllByLabelText', () => {
+    within(container).getAllByLabelText('1');
+  });
+
+  it('should have queryByLabelText', () => {
+    within(container).queryByLabelText('1');
+  });
+
+  it('should have queryAllByLabelText', () => {
+    within(container).queryAllByLabelText('1');
+  });
+
+  it('should have getByPlaceholderText', () => {
+    within(container).getByPlaceholderText('1');
+  });
+
+  it('should have getAllByPlaceholderText', () => {
+    within(container).getAllByPlaceholderText('1');
+  });
+
+  it('should have queryByPlaceholderText', () => {
+    within(container).queryByPlaceholderText('1');
+  });
+
+  it('should have queryAllByPlaceholderText', () => {
+    within(container).queryAllByPlaceholderText('1');
+  });
+
+  it('should have getByRole', () => {
+    within(container).getByRole('1');
+  });
+
+  it('should have getAllByRole', () => {
+    within(container).getAllByRole('1');
+  });
+
+  it('should have queryByRole', () => {
+    within(container).queryByRole('1');
+  });
+
+  it('should have queryAllByRole', () => {
+    within(container).queryAllByRole('1');
+  });
+
+  it('should have getBySelectText', () => {
+    within(container).getBySelectText('1');
+  });
+
+  it('should have getAllBySelectText', () => {
+    within(container).getAllBySelectText('1');
+  });
+
+  it('should have queryBySelectText', () => {
+    within(container).queryBySelectText('1');
+  });
+
+  it('should have queryAllBySelectText', () => {
+    within(container).queryAllBySelectText('1');
+  });
+
+  it('should have getByTestId', () => {
+    within(container).getByTestId('1');
+  });
+
+  it('should have getAllByTestId', () => {
+    within(container).getAllByTestId('1');
+  });
+
+  it('should have queryByTestId', () => {
+    within(container).queryByTestId('1');
+  });
+
+  it('should have queryAllByTestId', () => {
+    within(container).queryAllByTestId('1');
+  });
+
+  it('should have getByText', () => {
+    within(container).getByText('1');
+  });
+
+  it('should have getAllByText', () => {
+    within(container).getAllByText('1');
+  });
+
+  it('should have queryByText', () => {
+    within(container).queryByText('1');
+  });
+
+  it('should have queryAllByText', () => {
+    within(container).queryAllByText('1');
+  });
+
+  it('should have getByTitle', () => {
+    within(container).getByTitle('1');
+  });
+
+  it('should have getAllByTitle', () => {
+    within(container).getAllByTitle('1');
+  });
+
+  it('should have queryByTitle', () => {
+    within(container).queryByTitle('1');
+  });
+
+  it('should have queryAllByTitle', () => {
+    within(container).queryAllByTitle('1');
+  });
+
+  it('should have getByValue', () => {
+    within(container).getByValue('1');
+  });
+
+  it('should have getAllByValue', () => {
+    within(container).getAllByValue('1');
+  });
+
+  it('should have queryByValue', () => {
+    within(container).queryByValue('1');
+  });
+
+  it('should have queryAllByValue', () => {
+    within(container).queryAllByValue('1');
+  });
+});
+
+describe('fireEvent', () => {
+  const htmlEl = document.createElement('div');
+
+  it('should be callable', () => {
+    fireEvent(
+      htmlEl,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+  });
+
+  it('should throw on invalid arguments', () => {
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(1);
+    // $FlowExpectedError[incompatible-call]
+    fireEvent(htmlEl, 1);
+  });
+
+  it('should expose fire event helpers', () => {
+    fireEvent.copy(htmlEl);
+    fireEvent.cut(htmlEl);
+    fireEvent.paste(htmlEl);
+    fireEvent.compositionEnd(htmlEl);
+    fireEvent.compositionStart(htmlEl);
+    fireEvent.compositionUpdate(htmlEl);
+    fireEvent.keyDown(htmlEl);
+    fireEvent.keyPress(htmlEl);
+    fireEvent.keyUp(htmlEl);
+    fireEvent.focus(htmlEl);
+    fireEvent.blur(htmlEl);
+    fireEvent.change(htmlEl);
+    fireEvent.input(htmlEl);
+    fireEvent.invalid(htmlEl);
+    fireEvent.submit(htmlEl);
+    fireEvent.click(htmlEl);
+    fireEvent.contextMenu(htmlEl);
+    fireEvent.dblClick(htmlEl);
+    fireEvent.doubleClick(htmlEl);
+    fireEvent.drag(htmlEl);
+    fireEvent.dragEnd(htmlEl);
+    fireEvent.dragEnter(htmlEl);
+    fireEvent.dragExit(htmlEl);
+    fireEvent.dragLeave(htmlEl);
+    fireEvent.dragOver(htmlEl);
+    fireEvent.dragStart(htmlEl);
+    fireEvent.drop(htmlEl);
+    fireEvent.mouseDown(htmlEl);
+    fireEvent.mouseEnter(htmlEl);
+    fireEvent.mouseLeave(htmlEl);
+    fireEvent.mouseMove(htmlEl);
+    fireEvent.mouseOut(htmlEl);
+    fireEvent.mouseOver(htmlEl);
+    fireEvent.mouseUp(htmlEl);
+    fireEvent.select(htmlEl);
+    fireEvent.touchCancel(htmlEl);
+    fireEvent.touchEnd(htmlEl);
+    fireEvent.touchMove(htmlEl);
+    fireEvent.touchStart(htmlEl);
+    fireEvent.scroll(htmlEl);
+    fireEvent.wheel(htmlEl);
+    fireEvent.abort(htmlEl);
+    fireEvent.canPlay(htmlEl);
+    fireEvent.canPlayThrough(htmlEl);
+    fireEvent.durationChange(htmlEl);
+    fireEvent.emptied(htmlEl);
+    fireEvent.encrypted(htmlEl);
+    fireEvent.ended(htmlEl);
+    fireEvent.loadedData(htmlEl);
+    fireEvent.loadedMetadata(htmlEl);
+    fireEvent.loadStart(htmlEl);
+    fireEvent.pause(htmlEl);
+    fireEvent.play(htmlEl);
+    fireEvent.playing(htmlEl);
+    fireEvent.progress(htmlEl);
+    fireEvent.rateChange(htmlEl);
+    fireEvent.seeked(htmlEl);
+    fireEvent.seeking(htmlEl);
+    fireEvent.stalled(htmlEl);
+    fireEvent.suspend(htmlEl);
+    fireEvent.timeUpdate(htmlEl);
+    fireEvent.volumeChange(htmlEl);
+    fireEvent.waiting(htmlEl);
+    fireEvent.load(htmlEl);
+    fireEvent.error(htmlEl);
+    fireEvent.animationStart(htmlEl);
+    fireEvent.animationEnd(htmlEl);
+    fireEvent.animationIteration(htmlEl);
+    fireEvent.transitionEnd(htmlEl);
+  });
+});
+
+describe('text matching API', () => {
+  class Component extends React.Component<{...}> {}
+  const {
+    getByAltText,
+    getAllByAltText,
+    queryByAltText,
+    queryAllByAltText,
+    getByDisplayValue,
+    getAllByDisplayValue,
+    queryByDisplayValue,
+    queryAllByDisplayValue,
+    getByLabelText,
+    getAllByLabelText,
+    queryByLabelText,
+    queryAllByLabelText,
+    getByPlaceholderText,
+    getAllByPlaceholderText,
+    queryByPlaceholderText,
+    queryAllByPlaceholderText,
+    getByRole,
+    getAllByRole,
+    queryByRole,
+    queryAllByRole,
+    getBySelectText,
+    getAllBySelectText,
+    queryBySelectText,
+    queryAllBySelectText,
+    getByTestId,
+    getAllByTestId,
+    queryByTestId,
+    queryAllByTestId,
+    getByText,
+    getAllByText,
+    queryByText,
+    queryAllByText,
+    getByTitle,
+    getAllByTitle,
+    queryByTitle,
+    queryAllByTitle,
+    getByValue,
+    getAllByValue,
+    queryByValue,
+    queryAllByValue,
+  } = render(<Component />);
+
+  it('getByAltText should accept text match arguments', () => {
+    getByAltText('1');
+    getByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText(/1/);
+    getByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByAltText((content: string, element) => true);
+    getByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByAltText('1');
+  });
+
+  it('queryByAltText should accept text match arguments', () => {
+    queryByAltText('1');
+    queryByAltText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText(/1/);
+    queryByAltText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByAltText((content: string, element) => true);
+    queryByAltText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByAltText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByAltText('1');
+  });
+
+  it('getByDisplayValue should accept text match arguments', () => {
+    getByDisplayValue('1');
+    getByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue(/1/);
+    getByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByDisplayValue((content: string, element) => true);
+    getByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByDisplayValue('1');
+  });
+
+  it('queryByDisplayValue should accept text match arguments', () => {
+    queryByDisplayValue('1');
+    queryByDisplayValue('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue(/1/);
+    queryByDisplayValue(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByDisplayValue((content: string, element) => true);
+    queryByDisplayValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByDisplayValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByDisplayValue('1');
+  });
+
+  it('getByLabelText should accept text match arguments', () => {
+    getByLabelText('1');
+    getByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText(/1/);
+    getByLabelText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByLabelText((content: string, element) => true);
+    getByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByLabelText('1');
+  });
+
+  it('queryByLabelText should accept text match arguments', () => {
+    queryByLabelText('1');
+    queryByLabelText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByLabelText(/1/);
+    queryByLabelText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+    queryByLabelText((content: string, element) => true);
+    queryByLabelText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByLabelText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByLabelText('1');
+  });
+
+  it('getByPlaceholderText should accept text match arguments', () => {
+    getByPlaceholderText('1');
+    getByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText(/1/);
+    getByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    getByPlaceholderText((content: string, element) => true);
+    getByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByPlaceholderText('1');
+  });
+
+  it('queryByPlaceholderText should accept text match arguments', () => {
+    queryByPlaceholderText('1');
+    queryByPlaceholderText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText(/1/);
+    queryByPlaceholderText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryByPlaceholderText((content: string, element) => true);
+    queryByPlaceholderText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByPlaceholderText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByPlaceholderText('1');
+  });
+
+  it('getByRole should accept text match arguments', () => {
+    getByRole('1');
+    getByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByRole(/1/);
+    getByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByRole((content: string, element) => true);
+    getByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByRole('1');
+  });
+
+  it('queryByRole should accept text match arguments', () => {
+    queryByRole('1');
+    queryByRole('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole(/1/);
+    queryByRole(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByRole((content: string, element) => true);
+    queryByRole((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByRole should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByRole('1');
+  });
+
+  it('getBySelectText should accept text match arguments', () => {
+    getBySelectText('1');
+    getBySelectText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText(/1/);
+    getBySelectText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getBySelectText((content: string, element) => true);
+    getBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllBySelectText('1');
+  });
+
+  it('queryBySelectText should accept text match arguments', () => {
+    queryBySelectText('1');
+    queryBySelectText('1', {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText(/1/);
+    queryBySelectText(/1/, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+    queryBySelectText((content: string, element) => true);
+    queryBySelectText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllBySelectText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllBySelectText('1');
+  });
+
+  it('getByTestId should accept text match arguments', () => {
+    getByTestId('1');
+    getByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId(/1/);
+    getByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTestId((content: string, element) => true);
+    getByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTestId('1');
+  });
+
+  it('queryByTestId should accept text match arguments', () => {
+    queryByTestId('1');
+    queryByTestId('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId(/1/);
+    queryByTestId(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTestId((content: string, element) => true);
+    queryByTestId((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTestId should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTestId('1');
+  });
+
+  it('getByText should accept text match arguments', () => {
+    getByText('1');
+    getByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByText(/1/);
+    getByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByText((content: string, element) => true);
+    getByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('getAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByText('1');
+  });
+
+  it('queryByText should accept text match arguments', () => {
+    queryByText('1');
+    queryByText('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByText(/1/);
+    queryByText(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByText((content: string, element) => true);
+    queryByText((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+      selector: 'A',
+    });
+  });
+
+  it('queryAllByText should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByText('1');
+  });
+
+  it('getByTitle should accept text match arguments', () => {
+    getByTitle('1');
+    getByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle(/1/);
+    getByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByTitle((content: string, element) => true);
+    getByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByTitle('1');
+  });
+
+  it('queryByTitle should accept text match arguments', () => {
+    queryByTitle('1');
+    queryByTitle('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle(/1/);
+    queryByTitle(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByTitle((content: string, element) => true);
+    queryByTitle((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByTitle should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByTitle('1');
+  });
+
+  it('getByValue should accept text match arguments', () => {
+    getByValue('1');
+    getByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    getByValue(/1/);
+    getByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    getByValue((content: string, element) => true);
+    getByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('getAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = getAllByValue('1');
+  });
+
+  it('queryByValue should accept text match arguments', () => {
+    queryByValue('1');
+    queryByValue('1', { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue(/1/);
+    queryByValue(/1/, { trim: true, collapseWhitespace: true, exact: true });
+    queryByValue((content: string, element) => true);
+    queryByValue((content: string, element) => true, {
+      trim: true,
+      collapseWhitespace: true,
+      exact: true,
+    });
+  });
+
+  it('queryAllByValue should accept text match arguments', () => {
+    const result: Array<HTMLElement> = queryAllByValue('1');
+  });
+});
diff --git a/definitions/npm/react-toggle_v4.0.x/flow_v0.104.x-/react-toggle_v4.0.x.js b/definitions/npm/react-toggle_v4.0.x/flow_v0.104.x-v.200.x/react-toggle_v4.0.x.js
similarity index 100%
rename from definitions/npm/react-toggle_v4.0.x/flow_v0.104.x-/react-toggle_v4.0.x.js
rename to definitions/npm/react-toggle_v4.0.x/flow_v0.104.x-v.200.x/react-toggle_v4.0.x.js
diff --git a/definitions/npm/react-toggle_v4.0.x/flow_v0.201.x-/react-toggle_v4.0.x.js b/definitions/npm/react-toggle_v4.0.x/flow_v0.201.x-/react-toggle_v4.0.x.js
new file mode 100644
index 0000000000..e8870886ee
--- /dev/null
+++ b/definitions/npm/react-toggle_v4.0.x/flow_v0.201.x-/react-toggle_v4.0.x.js
@@ -0,0 +1,25 @@
+declare module "react-toggle" {
+  declare type Icons = {
+    checked?: React$Node,
+    unchecked?: React$Node,
+    ...
+  };
+
+  declare type Props = {
+    checked?: boolean,
+    defaultChecked?: boolean,
+    onChange?: (e: SyntheticInputEvent<any>) => void,
+    onFocus?: (e: SyntheticInputEvent<any>) => void,
+    onBlur?: (e: SyntheticInputEvent<any>) => void,
+    name?: string,
+    value?: string,
+    id?: string,
+    icons?: Icons | boolean,
+    "aria-labelledby"?: string,
+    "aria-label"?: string,
+    disabled?: boolean,
+    ...
+  };
+
+  declare export default class Toggle extends React$Component<Props> {}
+}
diff --git a/definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-/react-with-separator_v1.x.x.js b/definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-v.200.x/react-with-separator_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-/react-with-separator_v1.x.x.js
rename to definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-v.200.x/react-with-separator_v1.x.x.js
diff --git a/definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-/test_react-with-separator_v1.x.x.js b/definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-v.200.x/test_react-with-separator_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-/test_react-with-separator_v1.x.x.js
rename to definitions/npm/react-with-separator_v1.x.x/flow_v0.104.x-v.200.x/test_react-with-separator_v1.x.x.js
diff --git a/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/react-with-separator_v1.x.x.js b/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/react-with-separator_v1.x.x.js
new file mode 100644
index 0000000000..33e53bea11
--- /dev/null
+++ b/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/react-with-separator_v1.x.x.js
@@ -0,0 +1,9 @@
+declare module "react-with-separator" {
+  declare module.exports: React$StatelessFunctionalComponent<{
+    children?: React$Node,
+    leading?: boolean,
+    separator: string | React$Element<any>,
+    trailing?: boolean,
+    ...
+  }>;
+}
diff --git a/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/test_react-with-separator_v1.x.x.js b/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/test_react-with-separator_v1.x.x.js
new file mode 100644
index 0000000000..5c5ef57917
--- /dev/null
+++ b/definitions/npm/react-with-separator_v1.x.x/flow_v0.201.x-/test_react-with-separator_v1.x.x.js
@@ -0,0 +1,59 @@
+import React from "react";
+import { describe, it } from "flow-typed-test";
+import WithSeparator from "react-with-separator";
+
+describe("react-with-separator", () => {
+  describe("default export WithSeparator", () => {
+    describe("Valid usage", () => {
+      it("Accepts a string as a separator", () => {
+        <WithSeparator separator="|" />;
+      });
+
+      it("Accepts a React Element as a `separator`", () => {
+        <WithSeparator separator={<div />} />;
+      });
+
+      it("Accepts all defined props", () => {
+        <WithSeparator separator="|" leading trailing>
+          {"Hello"}
+        </WithSeparator>;
+      });
+    });
+
+    describe("Invalid usage", () => {
+      it("Rejects usage without `separator` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator />;
+      });
+
+      it("Rejects usage with invalid `Object` `separator` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator={{}} />;
+      });
+      it("Rejects usage with invalid `null` `separator` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator={null} />;
+      });
+      it("Rejects usage with invalid `void` `separator` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator={void 0} />;
+      });
+      it(" Rejects usage with invalid `boolean` `separator` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator={true} />;
+      });
+      it("Rejects usage with invalid `children` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator="|" children={{}} />;
+      });
+      it("Rejects usage with invalid `leading` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator="|" leading={1} />;
+      });
+      it("Rejects usage with invalid `trailing` prop", () => {
+        // $FlowExpectedError
+        <WithSeparator separator="|" trailing={1} />;
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/redux-actions_v2.x.x.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/redux-actions_v2.x.x.js
similarity index 100%
rename from definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/redux-actions_v2.x.x.js
rename to definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/redux-actions_v2.x.x.js
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_createAction.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_createAction.js
similarity index 100%
rename from definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_createAction.js
rename to definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_createAction.js
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_handleAction.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_handleAction.js
similarity index 100%
rename from definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_handleAction.js
rename to definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_handleAction.js
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_handleActions.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_handleActions.js
similarity index 100%
rename from definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-/test_handleActions.js
rename to definitions/npm/redux-actions_v2.x.x/flow_v0.104.x-v.200.x/test_handleActions.js
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/redux-actions_v2.x.x.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/redux-actions_v2.x.x.js
new file mode 100644
index 0000000000..8fe49f6715
--- /dev/null
+++ b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/redux-actions_v2.x.x.js
@@ -0,0 +1,157 @@
+declare module "redux-actions" {
+  /*
+   * Use `ActionType` to get the type of the action created by a given action
+   * creator. For example:
+   *
+   *     import { createAction, type ActionType } from 'redux-actions'
+   *
+   *     const increment = createAction(INCREMENT, (count: number) => count)
+   *
+   *     function myReducer(state: State = initState, action: ActionType<typeof increment>): State {
+   *       // Flow will infer that the type of `action.payload` is `number`
+   *     }
+   */
+  declare type ActionType<ActionCreator> = _ActionType<any, ActionCreator>;
+  declare type _ActionType<R, Fn: (...rest: any) => R> = R;
+
+  /*
+   * To get the most from Flow type checking use a `payloadCreator` argument
+   * with `createAction`. Make sure that Flow can infer the argument type of the
+   * `payloadCreator`. That will allow Flow to infer the payload type of actions
+   * created by that action creator in other parts of the program. For example:
+   *
+   *     const increment = createAction(INCREMENT, (count: number) => count)
+   *
+   */
+  declare function createAction<T, P>(
+    type: T,
+    $?: empty // hack to force Flow to not use this signature when more than one argument is given
+  ): {
+    (payload: P, ...rest: any[]): {
+      type: T,
+      payload: P,
+      error?: boolean,
+      ...
+    },
+    +toString: () => T,
+    ...
+  };
+
+  declare function createAction<T, A, P>(
+    type: T,
+    payloadCreator: (...rest: A) => Promise<P> | P,
+    $?: empty
+  ): {
+    (...rest: A): {
+      type: T,
+      payload: P,
+      error?: boolean,
+      ...
+    },
+    +toString: () => T,
+    ...
+  };
+
+  declare function createAction<T, A, P, M>(
+    type: T,
+    payloadCreator: (...rest: A) => Promise<P> | P,
+    metaCreator: (...rest: A) => M
+  ): {
+    (...rest: A): {
+      type: T,
+      payload: P,
+      error?: boolean,
+      meta: M,
+      ...
+    },
+    +toString: () => T,
+    ...
+  };
+
+  declare function createAction<T, P, M>(
+    type: T,
+    payloadCreator: null | void,
+    metaCreator: (payload: P, ...rest: any[]) => M
+  ): {
+    (
+        payload: P,
+        ...rest: any[]
+      ): {
+      type: T,
+      payload: P,
+      error?: boolean,
+      meta: M,
+      ...
+    },
+    +toString: () => T,
+    ...
+  };
+
+  // `createActions` is quite difficult to write a type for. Maybe try not to
+  // use this one?
+  declare function createActions(
+    actionMap: Object,
+    ...identityActions: string[]
+  ): Object;
+  declare function createActions(...identityActions: string[]): Object;
+
+  /*
+   * The semantics of the reducer (i.e. ReduxReducer<S, A>) returned by either
+   * `handleAction` or `handleActions` are actually different from the semantics
+   * of the reducer (i.e. Reducer<S, A>) that are consumed by either `handleAction`
+   * or `handleActions`.
+   *
+   * Reducers (i.e. Reducer<S, A>) consumed by either `handleAction` or `handleActions`
+   * are assumed to be given the actual `State` type, since internally,
+   * `redux-actions` will perform the action type matching for us, and will always
+   * provide the expected state type.
+   *
+   * The reducers returned by either `handleAction` or `handleActions` will be
+   * compatible with the `redux` library.
+  */
+  declare type Reducer<S, A> = (state: S, action: A) => S;
+  declare type ReduxReducer<S, A> = (state: S | void, action: A) => S;
+
+  declare type ReducerMap<S, A> =
+    | { next: Reducer<S, A>, ... }
+    | { throw: Reducer<S, A>, ... }
+    | {
+    next: Reducer<S, A>,
+    throw: Reducer<S, A>,
+    ...
+  };
+
+  /*
+   * To get full advantage from Flow, use a type annotation on the action
+   * argument to your reducer when creating a reducer with `handleAction` or
+   * `handleActions`. For example:
+   *
+   *     import { type Reducer } from 'redux'
+   *     import { createAction, handleAction, type ActionType } from 'redux-actions'
+   *
+   *     const increment = createAction(INCREMENT, (count: number) => count)
+   *
+   *     const reducer = handleAction(INCREMENT, (state, { payload }: ActionType<typeof increment>) => {
+   *       // Flow infers that the type of `payload` is number
+   *     }, defaultState)
+   */
+
+  declare type ReducerDefinition<State, Action> = { [key: string]:
+    | (Reducer<State, Action> | ReducerDefinition<State, Action>)
+    | ReducerMap<State, Action>, ... };
+
+  declare function handleAction<State, Action: { type: any, ... }>(
+    type: $ElementType<Action, 'type'>,
+    reducer: ReducerDefinition<State, Action>,
+    defaultState: State,
+  ): ReduxReducer<State, Action>;
+
+  declare function handleActions<State, Action>(
+    reducers: { [key: string]: Reducer<State, Action> | ReducerMap<State, Action>, ... },
+    defaultState?: State
+  ): ReduxReducer<State, Action>;
+
+  declare function combineActions(
+    ...types: (string | Symbol | Function)[]
+  ): string;
+}
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_createAction.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_createAction.js
new file mode 100644
index 0000000000..084bebfab4
--- /dev/null
+++ b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_createAction.js
@@ -0,0 +1,128 @@
+/* @flow */
+
+import { createAction } from "redux-actions";
+
+const INCREMENT = "INCREMENT";
+
+function test_createAction() {
+  const action = createAction(INCREMENT);
+  const a = action("foo");
+
+  assert(a.payload, (x: string) => {});
+
+  // $FlowExpectedError
+  assert(a.payload, (x: number) => {});
+
+  // Verify that Flow can refine types based on the `type` property of the
+  // action
+  if (a.type === "NOT INCREMENT") {
+    // This assertion passes type-checking because Flow knows that this block is
+    // not reachable.
+    assert(a.payload, (x: number) => {});
+  }
+
+  if (a.type === INCREMENT) {
+    // $FlowExpectedError
+    assert(a.payload, (x: number) => {});
+  }
+
+  (action.toString(): 'INCREMENT');
+  // $FlowExpectedError wrong type
+  (action.toString(): 'DECREMENT');
+}
+
+function test_createAction_givenPayloadType() {
+  const action = createAction(INCREMENT, (x: Date) => x);
+  const a = action(new Date());
+
+  // $FlowExpectedError
+  action("foo");
+
+  assert(a.payload, (x: Date) => {});
+
+  // $FlowExpectedError
+  assert(a.payload, (x: string) => {});
+
+  const action2 = createAction(INCREMENT, (x: Date) => x, x => x);
+  const a2 = action2(new Date());
+
+  assert(a2.meta, (x: Date) => {});
+
+  // $FlowExpectedError
+  assert(a2.meta, (x: string) => {});
+
+  (action.toString(): 'INCREMENT');
+  // $FlowExpectedError wrong type
+  (action.toString(): 'DECREMENT');
+}
+
+function test_createAction_withPayloadCreator() {
+  const action = createAction(INCREMENT, x => [x, x]);
+  const a = action("foo");
+
+  assert(a.payload, (x: [string, string]) => {});
+
+  // $FlowExpectedError
+  assert(a.payload, (x: string) => {});
+
+  // Accept multiple arguments to the action creator
+  const action2 = createAction(INCREMENT, (x: string, y: number, z: number) => [
+    x,
+    x
+  ]);
+  const a2 = action2("foo", 2, 3);
+
+  assert(a2.payload, (x: [string, string]) => {});
+
+  // $FlowExpectedError
+  assert(a2.payload, (x: string) => {});
+
+  // In case redux-actions is used in combination with redux-thunk,
+  // the `payloadCreator` can return a promise.
+  const action3 = createAction(INCREMENT, (x: string, y: number, z: number) => Promise.resolve([
+    x,
+    x
+  ]));
+  const a3 = action3("foo", 2, 3);
+
+  assert(a3.payload, (x: [string, string]) => {});
+
+  // $FlowExpectedError
+  assert(a3.payload, (x: string) => {});
+
+  (action.toString(): 'INCREMENT');
+  // $FlowExpectedError wrong type
+  (action.toString(): 'DECREMENT');
+}
+
+function test_createAction_withPayloadCreatorAndMeta() {
+  const action = createAction(INCREMENT, x => [x, x], x => 1);
+  const a = action("foo");
+
+  assert(a.meta, (x: number) => {});
+
+  // $FlowExpectedError
+  assert(a.meta, (x: string) => {});
+
+  (action.toString(): 'INCREMENT');
+  // $FlowExpectedError wrong type
+  (action.toString(): 'DECREMENT');
+}
+
+function test_createAction_withMeta() {
+  const action = createAction(INCREMENT, null, x => 1);
+  const a = action("foo");
+
+  assert(a.meta, (x: number) => {});
+
+  // $FlowExpectedError
+  assert(a.meta, (x: string) => {});
+
+  (action.toString(): 'INCREMENT');
+  // $FlowExpectedError wrong type
+  (action.toString(): 'DECREMENT');
+}
+
+// Helper to assert that the type of the first argument is compatible with the
+// argument type of the second argument.
+function assert<T>(actual: T, expected: (_: T) => void) {}
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleAction.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleAction.js
new file mode 100644
index 0000000000..e3a89aa925
--- /dev/null
+++ b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleAction.js
@@ -0,0 +1,51 @@
+/* @flow */
+
+import { createAction, handleAction } from 'redux-actions'
+import type { ActionType, Reducer } from 'redux-actions'
+
+const INCREMENT = 'INCREMENT'
+const NOT_INCREMENT = 'NOT_INCREMENT'
+
+const increment = createAction(INCREMENT, (x: number) => x)
+
+// In case redux-actions is used in combination with redux-thunk,
+// the `payloadCreator` can return a promise.
+const incrementThunk = createAction(INCREMENT, (x: number) => Promise.resolve(x))
+
+const initState = { count: 0 }
+
+function test_handleAction() {
+  const reducer = handleAction(INCREMENT, (state, action: ActionType<typeof increment>) => {
+    assert(action.payload, (x: number) => {})
+
+    // $FlowExpectedError
+    assert(action.payload, (x: string) => {})
+  }, initState)
+}
+
+function test_handleAction_thunk() {
+  const reducer = handleAction(INCREMENT, (state, action: ActionType<typeof incrementThunk>) => {
+    assert(action.payload, (x: number) => {})
+
+    // $FlowExpectedError
+    assert(action.payload, (x: string) => {})
+  }, initState)
+}
+
+function test_handleAction_typeMismatch() {
+  // For the moment Flow is only able to detect a mismatch between the `type`
+  // argument to `handleAction` and the action type in this very specific
+  // scenario. Unfortunately Flow does not detect the mismatch when the action
+  // type is given using the `ActionType` helper.
+  const reducer: Reducer<any, {
+    type: 'INCREMENT',
+    payload: number,
+    ...
+  }> =
+    // $FlowExpectedError
+    handleAction(NOT_INCREMENT, () => ({}), {})
+}
+
+// Helper to assert that the type of the first argument is compatible with the
+// argument type of the second argument.
+function assert<T>(actual: T, expected: (_: T) => void) {}
diff --git a/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleActions.js b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleActions.js
new file mode 100644
index 0000000000..cd03bdcfec
--- /dev/null
+++ b/definitions/npm/redux-actions_v2.x.x/flow_v0.201.x-/test_handleActions.js
@@ -0,0 +1,81 @@
+/* @flow */
+
+import { createAction, handleActions } from "redux-actions";
+import type { ActionType, Reducer } from "redux-actions";
+
+const INCREMENT = "INCREMENT";
+const INCREMENT2 = "INCREMENT2";
+const INCREMENT3 = "INCREMENT3";
+
+const increment = createAction(INCREMENT, (x: number) => x);
+const increment2 = createAction(INCREMENT2, (x: number, y: string) => x);
+const increment3 = createAction(INCREMENT3, (x: number, y: string) => Promise.resolve(x));
+const decrement = createAction("DECREMENT", (x: number) => x);
+
+type StateType = { count: number, ... };
+const initState: StateType = { count: 0 };
+
+function test_handleActions() {
+  handleActions(
+    {
+      [INCREMENT]: (state: StateType, action: ActionType<typeof increment>): StateType => {
+        return { count: state.count + 1 };
+      },
+
+      [String(increment2)]: (state: StateType, action: ActionType<typeof increment2>): StateType => {
+        assert(action.payload, (x: number) => {});
+        return {
+          count: state.count + action.payload
+        };
+      },
+
+      [INCREMENT3]: (state: StateType, action: ActionType<typeof increment3>): StateType => {
+        assert(action.payload, (x: number) => {});
+        return {
+          count: state.count + action.payload
+        };
+      },
+
+      [decrement.toString()]: (state: StateType, action: ActionType<typeof decrement>): StateType => {
+        assert(action.payload, (x: number) => {});
+        const decrementCount: number = action.payload;
+        return { count: state.count - decrementCount };
+      },
+
+      INFERS_STATE_TYPE: (state, action) => {
+        assert(state.count, (x: number) => {});
+
+        // $FlowExpectedError
+        assert(state.count, (x: string) => {});
+
+        return state;
+      },
+
+      // Errors happen if this is uncommented
+      // 'CHECKS_REDUCER_RETURN_TYPE': (state, action) => {
+      //   return { foo: 1 }
+      // },
+
+      // $FlowExpectedError
+      REQUIRERS_REDUCER_VALUE: {},
+
+      ACCEPTS_REDUCER_MAP: {
+        next: (state, action) => state,
+        throw: (state, action) => state
+      }
+    },
+    initState
+  );
+}
+
+// Helper to assert that the type of the first argument is compatible with the
+// argument type of the second argument.
+function assert<T>(actual: T, expected: (_: T) => void) {}
+
+increment2(1, "2");
+// $FlowExpectedError
+increment2("1", 0);
+// $FlowExpectedError
+increment2("1", "1");
+// $FlowExpectedError
+increment2(1, 1);
diff --git a/definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.104.x-/redux-devtools-extension_v2.x.x.js b/definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.104.x-v.200.x/redux-devtools-extension_v2.x.x.js
similarity index 100%
rename from definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.104.x-/redux-devtools-extension_v2.x.x.js
rename to definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.104.x-v.200.x/redux-devtools-extension_v2.x.x.js
diff --git a/definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.201.x-/redux-devtools-extension_v2.x.x.js b/definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.201.x-/redux-devtools-extension_v2.x.x.js
new file mode 100644
index 0000000000..ff2a143b1d
--- /dev/null
+++ b/definitions/npm/redux-devtools-extension_v2.x.x/flow_v0.201.x-/redux-devtools-extension_v2.x.x.js
@@ -0,0 +1,154 @@
+declare type DispatchAPI<A> = (action: A) => A;
+
+declare type Dispatch<A: { type: any, ... }> = DispatchAPI<A>;
+
+declare type Store<S, A, D = Dispatch<A>> = {
+  dispatch: D,
+  getState(): S,
+  subscribe(listener: () => void): () => void,
+  replaceReducer(nextReducer: Reducer<S, A>): void,
+  ...
+};
+
+declare type Reducer<S, A> = (state: S | void, action: A) => S;
+
+declare type StoreCreator<S, A, D = Dispatch<A>> = {
+  (reducer: Reducer<S, A>, enhancer?: StoreEnhancer<S, A, D>): Store<S, A, D>,
+  (
+    reducer: Reducer<S, A>,
+    preloadedState: S,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>,
+  ...
+};
+
+declare type StoreEnhancer<S, A, D = Dispatch<A>> = (
+  next: StoreCreator<S, A, D>
+) => StoreCreator<S, A, D>;
+
+declare type ActionCreator<A, B> = (...args: Array<B>) => A;
+
+declare type $npm$ReduxDevtoolsExtension$DevToolsOptions = {
+  name?: string,
+  actionCreators?: Array<ActionCreator<any>> | { [string]: ActionCreator<any>, ... },
+  latency?: number,
+  maxAge?: number,
+  serialize?: boolean | {
+    date?: boolean,
+    regex?: boolean,
+    undefined?: boolean,
+    error?: boolean,
+    symbol?: boolean,
+    map?: boolean,
+    set?: boolean,
+    function?: boolean | Function,
+    ...
+  },
+  actionSanitizer?: <A: { type: string, ... }>(action: A, id: number) => A,
+  stateSanitizer?: <S>(state: S, index: number) => S,
+  actionsBlacklist?: string | string[],
+  actionsWhitelist?: string | string[],
+  predicate?: <S, A: { type: string, ... }>(state: S, action: A) => boolean,
+  shouldRecordChanges?: boolean,
+  pauseActionType?: string,
+  autoPause?: boolean,
+  shouldStartLocked?: boolean,
+  shouldHotReload?: boolean,
+  shouldCatchErrors?: boolean,
+  features?: {
+    pause?: boolean,
+    lock?: boolean,
+    persist?: boolean,
+    export?: boolean | "custom",
+    import?: boolean | "custom",
+    jump?: boolean,
+    skip?: boolean,
+    reorder?: boolean,
+    dispatch?: boolean,
+    test?: boolean,
+    ...
+  },
+  ...
+};
+
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B>(ab: A => B): A => B;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools(options: $npm$ReduxDevtoolsExtension$DevToolsOptions): (...args: Array<any>) => any;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C>(
+  bc: B => C,
+  ab: A => B
+): A => C;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D>(
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => D;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D, E>(
+  de: D => E,
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => E;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D, E, F>(
+  ef: E => F,
+  de: D => E,
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => F;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D, E, F, G>(
+  fg: F => G,
+  ef: E => F,
+  de: D => E,
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => G;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D, E, F, G, H>(
+  gh: G => H,
+  fg: F => G,
+  ef: E => F,
+  de: D => E,
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => H;
+declare function $npm$ReduxDevtoolsExtension$composeWithDevTools<A, B, C, D, E, F, G, H, I>(
+  hi: H => I,
+  gh: G => H,
+  fg: F => G,
+  ef: E => F,
+  de: D => E,
+  cd: C => D,
+  bc: B => C,
+  ab: A => B
+): A => H;
+
+declare function $npm$ReduxDevtoolsExtension$devToolsEnhancer<S, A>(options?: $npm$ReduxDevtoolsExtension$DevToolsOptions): StoreEnhancer<S, A>;
+
+declare module 'redux-devtools-extension' {
+  declare export type DevToolsOptions = $npm$ReduxDevtoolsExtension$DevToolsOptions;
+
+  declare export var composeWithDevTools: typeof $npm$ReduxDevtoolsExtension$composeWithDevTools;
+  declare export var devToolsEnhancer: typeof $npm$ReduxDevtoolsExtension$devToolsEnhancer;
+}
+
+declare module 'redux-devtools-extension/developmentOnly' {
+  declare export type DevToolsOptions = $npm$ReduxDevtoolsExtension$DevToolsOptions;
+
+  declare export var composeWithDevTools: typeof $npm$ReduxDevtoolsExtension$composeWithDevTools;
+  declare export var devToolsEnhancer: typeof $npm$ReduxDevtoolsExtension$devToolsEnhancer;
+}
+
+declare module 'redux-devtools-extension/logOnly' {
+  declare export type DevToolsOptions = $npm$ReduxDevtoolsExtension$DevToolsOptions;
+
+  declare export var composeWithDevTools: typeof $npm$ReduxDevtoolsExtension$composeWithDevTools;
+  declare export var devToolsEnhancer: typeof $npm$ReduxDevtoolsExtension$devToolsEnhancer;
+}
+
+declare module 'redux-devtools-extension/logOnlyInProduction' {
+  declare export type DevToolsOptions = $npm$ReduxDevtoolsExtension$DevToolsOptions;
+
+  declare export var composeWithDevTools: typeof $npm$ReduxDevtoolsExtension$composeWithDevTools;
+  declare export var devToolsEnhancer: typeof $npm$ReduxDevtoolsExtension$devToolsEnhancer;
+}
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/redux-exr_v0.4.x.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/redux-exr_v0.4.x.js
similarity index 100%
rename from definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/redux-exr_v0.4.x.js
rename to definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/redux-exr_v0.4.x.js
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_exCombineReducers.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_exCombineReducers.js
similarity index 100%
rename from definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_exCombineReducers.js
rename to definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_exCombineReducers.js
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_makeExReducer.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_makeExReducer.js
similarity index 100%
rename from definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_makeExReducer.js
rename to definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_makeExReducer.js
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_makePlainReducer.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_makePlainReducer.js
similarity index 100%
rename from definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-/test_makePlainReducer.js
rename to definitions/npm/redux-exr_v0.4.x/flow_v0.104.x-v.200.x/test_makePlainReducer.js
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/redux-exr_v0.4.x.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/redux-exr_v0.4.x.js
new file mode 100644
index 0000000000..ad7ab7032c
--- /dev/null
+++ b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/redux-exr_v0.4.x.js
@@ -0,0 +1,28 @@
+
+declare module 'redux-exr'
+{
+  declare type Reducer<S, A> = (state: S, action: A) => S;
+
+  declare export function makePlainReducer<S, A>(initialState: S, reducer: Reducer<S, A>): Reducer<S, A>;
+
+  declare type ExReducerDependencies = Object; // TODO
+  declare type ExReducerDependenciesChanges = Object; // TODO
+  declare type ExReducerDependenciesSpec = Object; // TODO
+
+  declare type ExReducer<S, A> = (
+    state: S,
+    action: A,
+    dependencies: ExReducerDependencies,
+    changes: ExReducerDependenciesChanges,
+  ) => S;
+
+  declare export function makeExReducer<S, A>(
+    initialState: S,
+    dependenciesSpec: ExReducerDependenciesSpec,
+    reducer: ExReducer<S, A>,
+  ): ExReducer<S, A>;
+
+  declare type ExReducerTree = { [key: string]: Reducer<any, any> | ExReducer<any, any> | ExReducerTree, ... };
+
+  declare export function exCombineReducers(tree: ExReducerTree): <S, A>(rootState: S, action: A) => S;
+};
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_exCombineReducers.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_exCombineReducers.js
new file mode 100644
index 0000000000..137c94bb5c
--- /dev/null
+++ b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_exCombineReducers.js
@@ -0,0 +1,9 @@
+/* @flow */
+
+import {exCombineReducers} from 'redux-exr';
+
+// TODO: extend tests
+
+const reducer = exCombineReducers({});
+reducer();
+
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makeExReducer.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makeExReducer.js
new file mode 100644
index 0000000000..8df4daec6a
--- /dev/null
+++ b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makeExReducer.js
@@ -0,0 +1,15 @@
+/* @flow */
+
+import {makeExReducer} from 'redux-exr';
+
+const reducer = makeExReducer(
+  '',
+  {},
+  (s, a) => s,
+);
+
+// TODO: extend tests
+reducer('', {}, {}, {});
+
+// $FlowExpectedError
+reducer();
diff --git a/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makePlainReducer.js b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makePlainReducer.js
new file mode 100644
index 0000000000..1de9dc3090
--- /dev/null
+++ b/definitions/npm/redux-exr_v0.4.x/flow_v0.201.x-/test_makePlainReducer.js
@@ -0,0 +1,37 @@
+/* @flow */
+/* eslint-disable */
+
+// TODO: follow https://github.com/facebook/flow/issues/5788
+
+import {makePlainReducer} from "redux-exr";
+
+type MyAction = { type: 'MY_ACTION1', ... } | {
+  type: 'MY_ACTION2',
+  payload: string,
+  ...
+} | {
+  type: 'MY_ACTION3',
+  payload: number,
+  ...
+};
+
+const reducer = makePlainReducer('', (s, a) => (a.type === 'MY_ACTION' ? a.type : s));
+reducer('foo', {type: 'MY_ACTION'});
+// reducer(1, 1); // TODO: should return error (see issue above)
+// reducer(); // TODO: should return error (see issue above)
+// reducer(1); // TODO: should return error (see issue above)
+
+const reducer2 = makePlainReducer('', (s, a) => {
+  switch (a.type) {
+    case 'MY_ACTION1': return `${s} + ${a.type}`;
+    case 'MY_ACTION2': return `${s} - ${a.type}`;
+    case 'MY_ACTION3': return `${s} = ${a.type}`;
+    default: break;
+  }
+  return s;
+});
+// TODO
+// reducer2(undefined, {type: 'MY_ACTION1'});
+reducer2('', {type: 'MY_ACTION1'});
+// reducer2(1, {type: 'MY_ACTION1'}); // TODO
+reducer2('', {type: 'DUMMY_ACTION'});
diff --git a/definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-/redux-oidc_v3.x.x.js b/definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-v.200.x/redux-oidc_v3.x.x.js
similarity index 100%
rename from definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-/redux-oidc_v3.x.x.js
rename to definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-v.200.x/redux-oidc_v3.x.x.js
diff --git a/definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-/test_redux-oidc.js b/definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-v.200.x/test_redux-oidc.js
similarity index 100%
rename from definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-/test_redux-oidc.js
rename to definitions/npm/redux-oidc_v3.x.x/flow_v0.104.x-v.200.x/test_redux-oidc.js
diff --git a/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/redux-oidc_v3.x.x.js b/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/redux-oidc_v3.x.x.js
new file mode 100644
index 0000000000..67e7e0e496
--- /dev/null
+++ b/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/redux-oidc_v3.x.x.js
@@ -0,0 +1,67 @@
+import type { Reducer, Store } from "redux";
+
+declare module "redux-oidc" {
+  declare type UserManager = {
+    getUser: () => Promise<User<any>>,
+    removeUser: () => Promise<any>,
+    signinRedirect: (data?: { data: { redirectUrl: string, ... }, ... }) => Promise<any>,
+    signinSilent: () => Promise<any>,
+    signinPopup: () => Promise<any>,
+    signoutRedirect: () => Promise<any>,
+    signoutPopup: () => Promise<any>,
+    querySessionStatus: () => Promise<any>,
+    startSilentRenew: () => Promise<any>,
+    stopSilentRenew: () => Promise<any>,
+    clearStaleState: () => Promise<any>,
+    ...
+  };
+  declare type User<P> = {
+    id_token: string,
+    access_token: string,
+    token_type: string,
+    scope: string,
+    expires_at: number,
+    +expires_in: ?boolean,
+    +expired: ?boolean,
+    +scopes: Array<string>,
+    profile: P,
+    state: { redirectUrl: string, ... },
+    ...
+  };
+  declare type UserManagerSettings = {|
+    client_id: string,
+    authority: string,
+    redirect_uri: string,
+    response_type?: string,
+    scope?: string,
+    loadUserInfo?: boolean,
+    silent_redirect_uri?: string,
+    automaticSilentRenew?: boolean,
+    accessTokenExpiringNotificationTime?: number,
+    silentRequestTimeout?: number,
+    filterProtocolClaims?: boolean,
+    post_logout_redirect_uri?: string
+  |};
+  declare type OidcReducerState = { user: ?User<any>, ... };
+  declare type OidcReducer = Reducer<OidcReducerState, any>;
+
+  declare function createUserManager(
+    settings: UserManagerSettings
+  ): UserManager;
+  declare var reducer: OidcReducer;
+
+  declare class CallbackComponent extends React$Component<{
+    userManager: UserManager,
+    successCallback: (user?: User<any>) => mixed,
+    errorCallback?: () => mixed,
+    ...
+  }> {}
+
+  declare class OidcProvider extends React$Component<{
+    store: Store<any, any>,
+    userManager: UserManager,
+    ...
+  }> {}
+
+  declare function processSilentRenew(): void;
+}
diff --git a/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/test_redux-oidc.js b/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/test_redux-oidc.js
new file mode 100644
index 0000000000..a47d873112
--- /dev/null
+++ b/definitions/npm/redux-oidc_v3.x.x/flow_v0.201.x-/test_redux-oidc.js
@@ -0,0 +1,99 @@
+// @flow
+
+"use strict";
+import type { OidcReducerState, User } from "redux-oidc";
+import React from "react";
+import reduxOidc from "redux-oidc";
+// $FlowExpectedError: flow-typed doesn't support pulling in _other_ modules yet?
+const redux = require("redux");
+// This was also attempted, but still no joy.
+// See https://github.com/flowtype/flow-typed/issues/1331
+// const redux = require('../../redux_v3.x.x/flow_v0.33.x-/redux_v3.x.x.js')
+
+const CallbackComponent = reduxOidc.CallbackComponent;
+const OidcProvider = reduxOidc.OidcProvider;
+
+// createUserManager takes a config.
+const userManagerConfig = {
+  client_id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  authority: "https://some-authority.org/oidc",
+  redirect_uri: "http://base/#/callback",
+  response_type: "token id_token",
+  scope: "openid profile email",
+  loadUserInfo: false,
+  silent_redirect_uri: "http://base/oidc-silent-renew.html",
+  automaticSilentRenew: true,
+  accessTokenExpiringNotificationTime: 598,
+  silentRequestTimeout: 10,
+  filterProtocolClaims: true,
+  post_logout_redirect_uri: "http://base/login"
+};
+
+const userManager = reduxOidc.createUserManager(userManagerConfig);
+
+// The UserManager can do different signins/outs and has other helpers.
+userManager.getUser();
+userManager.removeUser();
+userManager.signinRedirect();
+userManager.signinSilent();
+userManager.signinPopup();
+userManager.signoutRedirect();
+userManager.signoutPopup();
+userManager.querySessionStatus();
+userManager.startSilentRenew();
+userManager.stopSilentRenew();
+userManager.clearStaleState();
+
+userManager.signinRedirect({
+  data: { redirectUrl: "https://www.duckduckgo.com" }
+});
+
+// The reducer state can have a nullable user
+const state: OidcReducerState = {
+  user: null
+};
+
+// $FlowExpectedError: The user could be null/undefined.
+console.log(state.user.expired);
+
+if (state.user) {
+  console.log(state.user.expired);
+}
+
+type Action = { type: "foo", ... };
+type State = { foo: string, ... };
+
+// redux-oidc provides some components.
+const reducer = (state: State, action: Action) => action;
+const store = redux.createStore(redux.combineReducers([reducer]));
+
+const StatelessComponent = () => {
+  return (
+    <div>
+      <CallbackComponent
+        userManager={userManager}
+        successCallback={() => console.log("success!")}
+        errorCallback={() => console.log("error!")}
+      />
+      <OidcProvider store={store} userManager={userManager} />
+    </div>
+  );
+};
+
+type Props = { redirectToLink: (user?: User<any>) => void, ... };
+
+const ExampleComponent = ({ redirectToLink }: Props) => {
+  return (
+    <div>
+      <CallbackComponent
+        userManager={userManager}
+        successCallback={redirectToLink}
+        errorCallback={() => console.log("error!")}
+      />
+      <OidcProvider store={store} userManager={userManager} />
+    </div>
+  );
+};
+
+// There's a utility function for silent renews.
+reduxOidc.processSilentRenew();
diff --git a/definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-/redux-reactors_v1.x.x.js b/definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-v.200.x/redux-reactors_v1.x.x.js
similarity index 100%
rename from definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-/redux-reactors_v1.x.x.js
rename to definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-v.200.x/redux-reactors_v1.x.x.js
diff --git a/definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-/test_redux-reactors_v1.x.x.js b/definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-v.200.x/test_redux-reactors_v1.x.x.js
similarity index 100%
rename from definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-/test_redux-reactors_v1.x.x.js
rename to definitions/npm/redux-reactors_v1.x.x/flow_v0.104.x-v.200.x/test_redux-reactors_v1.x.x.js
diff --git a/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/redux-reactors_v1.x.x.js b/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/redux-reactors_v1.x.x.js
new file mode 100644
index 0000000000..39e5b0a026
--- /dev/null
+++ b/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/redux-reactors_v1.x.x.js
@@ -0,0 +1,61 @@
+declare module 'redux-reactors' {
+  /* Helper types from 'redux'
+  *
+  * NOTE THAT THE BELOW TYPES ARE COPIED DIRECTLY FROM THE LIBDEF
+  * FOR 'redux'.  CHANGES SHOULD BE MIRRORED BACK HERE TO ENSURE
+  * CONSISTENCY ACROSS VERSIONS.
+  *
+  * Equivalent to:
+  *    import type { StoreCreator, Action } from 'redux';
+  */
+  declare type Action<T> = { type: T, ... };
+
+  declare type DispatchAPI<A> = (action: A) => A;
+
+  declare type Dispatch<A: { type: any, ... }> = DispatchAPI<A>;
+
+  declare type Reducer<S, A> = (state: S | void, action: A) => S;
+
+  declare type StoreEnhancer<S, A, D = Dispatch<A>> = (
+    next: StoreCreator<S, A, D>
+  ) => StoreCreator<S, A, D>;
+
+  declare type Store<S, A, D = Dispatch<A>> = {
+    // rewrite MiddlewareAPI members in order to get nicer error messages (intersections produce long messages)
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Reducer<S, A>): void,
+    ...
+  };
+
+  declare type StoreCreator<S, A, D = Dispatch<A>> = {
+    (reducer: Reducer<S, A>, enhancer?: StoreEnhancer<S, A, D>): Store<S, A, D>,
+    (
+      reducer: Reducer<S, A>,
+      preloadedState: S,
+      enhancer?: StoreEnhancer<S, A, D>
+    ): Store<S, A, D>,
+    ...
+  };
+  /* END OF COPIED 'redux' TYPES */
+
+
+  declare export type ReactorAction<S, T> = {|
+    type: T,
+    payload: mixed,
+    __REACTOR__: Reducer<S, ReactorAction<S, T>>,
+  |};
+
+  declare export function reactorEnhancer<
+    S,
+    ActionType,
+    A: Action<ActionType> | ReactorAction<S, ActionType>,
+    D
+  >(createStore: StoreCreator<S, A, D>): StoreCreator<S, A, D>;
+
+  declare export function createReactor<S, T>(
+    type: T,
+    __REACTOR__: Reducer<S, ReactorAction<S, T>>
+  ): (payload: mixed) => ReactorAction<S, T>;
+}
diff --git a/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/test_redux-reactors_v1.x.x.js b/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/test_redux-reactors_v1.x.x.js
new file mode 100644
index 0000000000..002ffe4b65
--- /dev/null
+++ b/definitions/npm/redux-reactors_v1.x.x/flow_v0.201.x-/test_redux-reactors_v1.x.x.js
@@ -0,0 +1,123 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import { reactorEnhancer, createReactor } from 'redux-reactors';
+import type { ReactorAction } from 'redux-reactors';
+
+/* Helper types from 'redux'
+*
+* NOTE THAT THE BELOW TYPES ARE COPIED DIRECTLY FROM THE LIBDEF
+* FOR 'redux'.  CHANGES SHOULD BE MIRRORED BACK HERE TO ENSURE
+* CONSISTENCY ACROSS VERSIONS.
+*
+* Equivalent to:
+*    import type { StoreCreator, Action } from 'redux';
+*/
+type Action<T> = { type: T, ... };
+
+type DispatchAPI<A> = (action: A) => A;
+
+type Dispatch<A: { type: any, ... }> = DispatchAPI<A>;
+
+type Reducer<S, A> = (state: S | void, action: A) => S;
+
+type StoreEnhancer<S, A, D = Dispatch<A>> = (
+  next: StoreCreator<S, A, D>
+) => StoreCreator<S, A, D>;
+
+type Store<S, A, D = Dispatch<A>> = {
+  // rewrite MiddlewareAPI members in order to get nicer error messages (intersections produce long messages)
+  dispatch: D,
+  getState(): S,
+  subscribe(listener: () => void): () => void,
+  replaceReducer(nextReducer: Reducer<S, A>): void,
+  ...
+};
+
+type StoreCreator<S, A, D = Dispatch<A>> = {
+  (reducer: Reducer<S, A>, enhancer?: StoreEnhancer<S, A, D>): Store<S, A, D>,
+  (
+    reducer: Reducer<S, A>,
+    preloadedState: S,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>,
+  ...
+};
+/* END OF COPIED 'redux' TYPES */
+
+describe('Test reactorEnhancer', () => {
+  it('should pass when used properly', () => {
+    type State = {|
+      counter: number,
+      initialCount: number,
+    |};
+
+    // with Redux's 'Action' type
+    type StoreTypeWithActions = StoreCreator<State, Action<'INCREMENT'>, any>;
+    const enhancedCreateStoreWithActions = reactorEnhancer((({}: any): StoreTypeWithActions));
+    (enhancedCreateStoreWithActions: StoreTypeWithActions);
+
+    // with 'ReactorAction' type
+    type StoreTypeWithReactors = StoreCreator<State, ReactorAction<State, 'INCREMENT'>, any>;
+    let enhancedCreateStoreWithReactors = reactorEnhancer((({}: any): StoreTypeWithReactors));
+    (enhancedCreateStoreWithReactors: StoreTypeWithReactors);
+
+    // with 'Action' and ReactorAction' types
+    type StoreType = StoreCreator<State, Action<'INCREMENT'> | ReactorAction<State, 'INCREMENT'>, any>;
+    let enhancedCreateStore = reactorEnhancer((({}: any): StoreType));
+    (enhancedCreateStore: StoreType);
+  });
+
+  it('raise an error with malformed inputs', () => {
+    type StoreType = StoreCreator<{||}, Action<'INCREMENT'>, any>;
+    const enhancedCreateStore = reactorEnhancer((({}: any): StoreType));
+    // $FlowExpectedError - should be 'StoreType'
+    (enhancedCreateStore: string);
+  });
+});
+
+describe('Test createReactor', () => {
+  if('should pass when used properly', () => {
+    type State = {
+      counter: number,
+      initialCount: number,
+      ...
+    };
+
+    const incrementReactor = createReactor<State, 'INCREMENT'>('INCREMENT', (state, action) => {
+      if(!state) return {};
+      if(typeof action.payload !== 'number') return state;
+
+      return Object.assign({}, {
+        counter: state.counter + action.payload,
+        state,
+      });
+    });
+
+    (incrementReactor: (payload: string) => ReactorAction<State, 'INCREMENT'>);
+    const instance = incrementReactor(5);
+    (instance: ReactorAction<State, 'INCREMENT'>);
+  });
+
+  it('raise an error with malformed inputs', () => {
+    // Missing property in state
+    type State = {|
+      counter: number,
+      initialCount: number,
+    |};
+
+    const incrementReactor = createReactor<State, 'INCREMENT'>(
+      // $FlowExpectedError - mismatch to generic for 'INCREMENT'
+      'DECREMENT',
+      (state, action) => {
+        if (!state) throw new Error('Missing state!');
+        if (typeof action.payload !== 'number') return state;
+
+        // $FlowExpectedError - missing 'initialCount'
+        return {
+          counter: state.counter + action.payload,
+        };
+      }
+    );
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/redux-saga_v1.x.x.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/redux-saga_v1.x.x.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/redux-saga_v1.x.x.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/redux-saga_v1.x.x.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_END.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_END.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_END.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_END.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_MulticastChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_MulticastChannel.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_MulticastChannel.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_MulticastChannel.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_SAGA_LOCATION.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_SAGA_LOCATION.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_SAGA_LOCATION.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_SAGA_LOCATION.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_actionChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_actionChannel.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_actionChannel.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_actionChannel.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_all.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_all.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_all.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_all.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_apply.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_apply.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_apply.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_apply.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_buffers.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_buffers.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_buffers.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_buffers.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_async.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_async.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_async.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_async.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_async.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_async.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_async.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_async.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_generator.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_generator.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_generator.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_generator.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_normal.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_normal.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_context_normal.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_context_normal.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_generator.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_generator.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_generator.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_generator.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_normal.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_normal.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_call_normal.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_call_normal.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancel-symbol.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancel-symbol.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancel-symbol.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancel-symbol.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancel.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancel.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancel.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancelled.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancelled.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cancelled.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cancelled.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_channel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_channel.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_channel.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_channel.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cps.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cps.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_cps.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_cps.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_createSagaMiddleware.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_createSagaMiddleware.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_createSagaMiddleware.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_createSagaMiddleware.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_debounce.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_debounce.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_debounce.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_debounce.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_default.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_default.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_default.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_default.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_delay.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_delay.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_delay.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_delay.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_detach.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_detach.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_detach.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_detach.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_eventChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_eventChannel.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_eventChannel.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_eventChannel.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_flush.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_flush.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_flush.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_flush.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_fork.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_fork.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_fork.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_fork.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_getContext.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_getContext.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_getContext.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_getContext.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_high-level-api-takes.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_high-level-api-takes.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_high-level-api-takes.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_high-level-api-takes.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_isEnd.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_isEnd.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_isEnd.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_isEnd.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_join.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_join.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_join.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_join.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_put.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_put.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_put.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_put.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_putResolve.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_putResolve.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_putResolve.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_putResolve.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_race.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_race.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_race.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_race.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_retry.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_retry.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_retry.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_retry.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_runSaga.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_runSaga.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_runSaga.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_runSaga.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_select.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_select.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_select.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_select.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_setContext.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_setContext.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_setContext.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_setContext.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_spawn.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_spawn.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_spawn.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_spawn.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_take.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_take.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_take.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_take.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_takeMaybe.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_takeMaybe.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_takeMaybe.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_takeMaybe.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_throttle.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_throttle.js
similarity index 100%
rename from definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-/test_redux-saga_1.x.x_throttle.js
rename to definitions/npm/redux-saga_v1.x.x/flow_v0.104.x-v.200.x/test_redux-saga_1.x.x_throttle.js
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/redux-saga_v1.x.x.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/redux-saga_v1.x.x.js
new file mode 100644
index 0000000000..65ceae1e44
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/redux-saga_v1.x.x.js
@@ -0,0 +1,2243 @@
+declare module "redux-saga" {
+  // These types are copied directly from the redux libdef.
+  // Importing them in this libdef causes a loss in type coverage.
+
+  // * uncomment next line:
+  // import type { Middleware} from 'redux';
+
+  // * remove next types
+  declare type DispatchAPI<A> = (action: A) => A;
+  declare type Dispatch<A: { type: string, ... }> = DispatchAPI<A>;
+
+  declare type MiddlewareAPI<S, A, D = Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    ...
+  };
+
+  declare type Middleware<S, A, D = Dispatch<A>> = (api: MiddlewareAPI<S, A, D>) => (next: D) => D;
+
+  //////////////////////////////////////////////////////////////////////////
+
+  declare export var SAGA_LOCATION: "@@redux-saga/LOCATION";
+
+  declare export var CANCEL: "@@redux-saga/CANCEL_PROMISE";
+
+  declare export type TEnd = {| +type: "@@redux-saga/CHANNEL_END" |};
+
+  declare export var END: TEnd;
+
+  declare export var isEnd: {
+    (input: TEnd): true,
+    (input: mixed): false,
+    ...
+  };
+
+  declare export type Predicate<T> = (arg: T) => boolean;
+
+  declare export type MulticastChannel<T> = $ReadOnly<{|
+    take(cb: (message: T | TEnd) => void, matcher?: Predicate<T>): void,
+    put(message: T | TEnd): void,
+    close(): void
+  |}>;
+
+  declare export interface Buffer<T> {
+    isEmpty(): boolean;
+    put(message: T): void;
+    take(): T | void;
+    flush(): Array<T>;
+  }
+
+  declare export interface Task<RT> {
+    isRunning: () => boolean;
+    isCancelled: () => boolean;
+    result: () => RT | void;
+    error: () => Error | void;
+    cancel: () => void;
+    toPromise(): Promise<RT>;
+    setContext<C: {...}>(props: $Shape<C>): void;
+  }
+
+  declare export interface SagaMonitor {
+    effectTriggered?: (desc: {
+      +effectId: number,
+      +parentEffectId: number,
+      +label: string,
+      +root?: boolean,
+      +effect: Effect,
+      ...
+    }) => void;
+    effectResolved?: (effectId: number, result: mixed) => void;
+    effectRejected?: (effectId: number, error: any) => void;
+    effectCancelled?: (effectId: number) => void;
+
+    actionDispatched?: (action: { [key: string]: any, ... }) => void;
+  }
+
+  declare export type Saga<T> = Generator<Effect, T, any>;
+
+  declare export type Unsubscribe = () => void;
+
+  declare export type Subscribe<T> = (cb: (input: T | TEnd) => void) => Unsubscribe;
+
+  declare export interface TakeableChannel<T> {
+    take(cb: (message: T | TEnd) => void): void
+  }
+
+  declare export interface PuttableChannel<T> {
+    put(message: T | TEnd): void
+  }
+
+  declare export interface FlushableChannel<T> {
+    flush(cb: (items: Array<T> | TEnd) => void): void
+  }
+
+
+  declare export interface EventChannel<T> {
+    take(cb: (message: T | TEnd) => void): void;
+    flush(cb: (items: Array<T> | TEnd) => void): void;
+    close(): void;
+  }
+
+  declare export var eventChannel: <T>(
+    subscribe: Subscribe<T>,
+    buffer?: Buffer<T>
+  ) => EventChannel<T>;
+
+  declare export interface Channel<T> {
+    take(cb: (message: T | TEnd) => void): void;
+    put(message: T | TEnd): void;
+    flush(cb: (items: Array<T> | TEnd) => void): void;
+    close(): void;
+  }
+
+  declare export function channel<T>(buffer?: Buffer<T>): Channel<T>;
+
+  declare export var buffers: $ReadOnly<{|
+    none: <T>() => Buffer<T>,
+    fixed: <T>(limit?: number) => Buffer<T>,
+    dropping: <T>(limit?: number) => Buffer<T>,
+    sliding: <T>(limit?: number) => Buffer<T>,
+    expanding: <T>(initialSize?: number) => Buffer<T>
+  |}>;
+
+  declare export function multicastChannel<T>(): MulticastChannel<T>;
+
+  declare export function stdChannel<T>(): MulticastChannel<T>;
+
+  declare export type Logger = (level: "info" | "warning" | "error", ...args: Array<any>) => void;
+
+  declare export type EffectMiddleware = (next: (effect: mixed) => void) => (effect: mixed) => void;
+
+  declare export interface PredicateTakeableChannel<T> {
+    take(cb: (message: T | TEnd) => void, matcher?: Predicate<T>): void;
+  }
+
+  declare type RunSagaOptions<A, S> = {|
+    channel?: PredicateTakeableChannel<A>,
+    dispatch?: (input: A) => mixed,
+    getState?: () => S,
+    context?: {...},
+    sagaMonitor?: SagaMonitor,
+    logger?: Logger,
+    effectMiddlewares?: Array<EffectMiddleware>,
+    onError?: (error: Error) => void
+  |};
+
+  declare export var runSaga: {
+    <A, S, R, Fn: () => Saga<R>>(options: RunSagaOptions<A, S>, saga: Fn): Task<R>,
+    <A, S, R, T1, Fn: T1 => Saga<R>>(options: RunSagaOptions<A, S>, saga: Fn, T1): Task<R>,
+    <A, S, R, T1, T2, Fn: (T1, T2) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, Fn: (T1, T2, T3) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): Task<R>,
+    <A, S, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => Saga<R>>(
+      options: RunSagaOptions<A, S>,
+      saga: Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): Task<R>,
+    ...
+  };
+
+  declare export type SagaMiddleware<C: {...}> =
+    {
+      <S, A, D>(api: MiddlewareAPI<S, A, D>): (next: D) => D,
+      run: {
+        <R, Fn: () => Saga<R>>(saga: Fn): Task<R>,
+        <R, T1, Fn: T1 => Saga<R>>(saga: Fn, T1): Task<R>,
+        <R, T1, T2, Fn: (T1, T2) => Saga<R>>(saga: Fn, T1, T2): Task<R>,
+        <R, T1, T2, T3, Fn: (T1, T2, T3) => Saga<R>>(saga: Fn, T1, T2, T3): Task<R>,
+        <R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => Saga<R>>(saga: Fn, T1, T2, T3, T4): Task<R>,
+        <R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => Saga<R>>(
+          saga: Fn,
+          T1,
+          T2,
+          T3,
+          T4,
+          T5
+        ): Task<R>,
+        <R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => Saga<R>>(
+          saga: Fn,
+          T1,
+          T2,
+          T3,
+          T4,
+          T5,
+          T6
+        ): Task<R>,
+        <R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => Saga<R>>(
+          saga: Fn,
+          T1,
+          T2,
+          T3,
+          T4,
+          T5,
+          T6,
+          T7
+        ): Task<R>,
+        <R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => Saga<R>>(
+          saga: Fn,
+          T1,
+          T2,
+          T3,
+          T4,
+          T5,
+          T6,
+          T7,
+          T8
+        ): Task<R>,
+        ...
+      },
+      setContext: (props: $Shape<C>) => void,
+      ...
+    };
+
+  declare export type Emit<T> = (input: T) => void;
+
+  declare export type SagaMiddlewareOptions<C: {...}> = {|
+    context?: C,
+    sagaMonitor?: SagaMonitor,
+    logger?: Logger,
+    effectMiddlewares?: Array<EffectMiddleware>,
+    emitter?: <A>(emit: Emit<A>) => Emit<any>,
+    onError?: (error: Error) => void
+  |};
+
+  declare function sagaMiddlewareFactory<C>(options?: SagaMiddlewareOptions<C>): SagaMiddleware<C>;
+
+  declare export default typeof sagaMiddlewareFactory;
+
+  // Effect types
+  declare export type SubPattern = string | (any => any);
+
+  declare export type Pattern = SubPattern | Array<SubPattern>;
+
+  declare export interface IEffect<T, P, C: boolean> {
+    +type: T;
+    +payload: P;
+    +combinator: C;
+  }
+
+  declare export type AllTakeEffect<
+    M: { maybe: true, ... } | void
+  > = IEffect<
+    "TAKE",
+    $ReadOnly<{|
+      pattern: '*',
+      ...$Exact<M>
+    |}>,
+    false
+  >;
+
+  declare export type TakeEffect<
+    P: { pattern: Pattern, ... } | void,
+    C: { channel: TakeableChannel<any>, ... } | void,
+    M: { maybe: true, ... } | void
+  > = IEffect<
+    "TAKE",
+    $ReadOnly<{|
+      ...$Exact<P>,
+      ...$Exact<C>,
+      ...$Exact<M>
+    |}>,
+    false
+  >;
+
+  declare export type PutEffect<
+    A: {...},
+    C: PuttableChannel<any> | null,
+    R: { resolve: true, ... } | void
+  > = IEffect<
+    "PUT",
+    $ReadOnly<{|
+      action: A,
+      channel: C,
+      ...$Exact<R>
+    |}>,
+    false
+  >;
+
+  declare export type CallEffect<Ctx, Fn: Function | string, Args: $ReadOnlyArray<any>> = IEffect<
+    "CALL",
+    $ReadOnly<{|
+      context: Ctx,
+      fn: Fn,
+      args: Args
+    |}>,
+    false
+  >;
+
+  declare export type ForkEffect<
+    Ctx,
+    Fn: : (...args: Array<any>) => any,
+    D: { detached: true, ... } | void,
+    Args: $ReadOnlyArray<any>
+  > = IEffect<
+    "FORK",
+    $ReadOnly<{|
+      context: Ctx,
+      fn: Fn,
+      args: Args,
+      ...$Exact<D>
+    |}>,
+    false
+  >;
+
+  declare export function detach<T1, T2, T3>(
+    effect: ForkEffect<T1, T2, any, T3>
+  ): ForkEffect<T1, T2, { detached: true, ... }, T3>;
+
+  declare export type CpsEffect<Ctx, Fn: : (...args: Array<any>) => any, Args: $ReadOnlyArray<any>> = IEffect<
+    "CPS",
+    $ReadOnly<{|
+      context: Ctx,
+      fn: Fn,
+      args: Args
+    |}>,
+    false
+  >;
+
+  declare export type JoinEffect<T: Task<any> | Array<Task<any>>> = IEffect<"JOIN", T, false>;
+
+  declare export type SELF_CANCELLATION = "@@redux-saga/SELF_CANCELLATION";
+
+  declare export type CancelEffect<
+    T: Task<any> | $ReadOnlyArray<Task<any>> | SELF_CANCELLATION
+  > = IEffect<"CANCEL", T, false>;
+
+  declare export type SelectEffect<Fn: Function | void, Args: $ReadOnlyArray<any>> = IEffect<
+    "SELECT",
+    $ReadOnly<{|
+      selector: Fn,
+      args: Args
+    |}>,
+    false
+  >;
+
+  declare export type ActionChannelEffect<T, P: Pattern | void, B: Buffer<T> | void> = IEffect<
+    "ACTION_CHANNEL",
+    $ReadOnly<{|
+      buffer: B,
+      pattern: P
+    |}>,
+    false
+  >;
+
+  declare export type FlushEffect<CH: FlushableChannel<any>> = IEffect<"FLUSH", CH, false>;
+
+  declare export type CancelledEffect = IEffect<"CANCELLED", {||}, false>;
+
+  declare export type SetContextEffect<T: {...}> = IEffect<"SET_CONTEXT", T, false>;
+
+  declare export type GetContextEffect<T> = IEffect<"GET_CONTEXT", T, false>;
+
+  declare export type RaceEffect<R: { +[name: string]: Effect, ... } | $ReadOnlyArray<Effect>> = IEffect<
+    "RACE",
+    R,
+    true
+  >;
+
+  declare export type AllEffect = IEffect<
+    "ALL",
+    { +[name: string]: Effect, ... } | $ReadOnlyArray<Effect>,
+    true
+  >;
+
+  declare export type Effect =
+    | ActionChannelEffect<any, any, any>
+    | AllEffect
+    | CallEffect<any, any, any>
+    | CancelEffect<any>
+    | CancelledEffect
+    | CpsEffect<any, any, any>
+    | FlushEffect<any>
+    | ForkEffect<any, any, any, any>
+    | GetContextEffect<any>
+    | JoinEffect<any>
+    | PutEffect<any, any, any>
+    | RaceEffect<any>
+    | SelectEffect<any, any>
+    | SetContextEffect<any>
+    | TakeEffect<any, any, any>
+    | AllTakeEffect<any>;
+}
+
+declare module "redux-saga/effects" {
+  import type {
+    ActionChannelEffect,
+    AllEffect,
+    Buffer,
+    CallEffect,
+    CancelEffect,
+    CancelledEffect,
+    Channel,
+    CpsEffect,
+    Effect,
+    FlushEffect,
+    ForkEffect,
+    GetContextEffect,
+    JoinEffect,
+    Pattern,
+    PutEffect,
+    RaceEffect,
+    Saga,
+    SelectEffect,
+    SetContextEffect,
+    TakeEffect,
+    Task,
+    TakeableChannel,
+    PuttableChannel,
+    FlushableChannel,
+    AllTakeEffect,
+  } from "redux-saga";
+
+  declare export var effectTypes: $ReadOnly<{|
+    TAKE: 'TAKE',
+    PUT: 'PUT',
+    ALL: 'ALL',
+    RACE: 'RACE',
+    CALL: 'CALL',
+    CPS: 'CPS',
+    FORK: 'FORK',
+    JOIN: 'JOIN',
+    CANCEL: 'CANCEL',
+    SELECT: 'SELECT',
+    ACTION_CHANNEL: 'ACTION_CHANNEL',
+    CANCELLED: 'CANCELLED',
+    FLUSH: 'FLUSH',
+    GET_CONTEXT: 'GET_CONTEXT',
+    SET_CONTEXT: 'SET_CONTEXT'
+  |}>;
+
+  declare export var put: {
+    <A: {...}>(action: A): PutEffect<A, null, void>,
+    <A: {...}, T, CH: PuttableChannel<T>>(channel: CH, action: A): PutEffect<A, CH, void>,
+    ...
+  };
+
+  declare export var putResolve: {
+    <A: {...}>(action: A): PutEffect<A, null, { resolve: true, ... }>,
+    <A: {...}, T, CH: PuttableChannel<T>>(channel: CH, action: A): PutEffect<A, CH, { resolve: true, ... }>,
+    ...
+  };
+
+  declare export var call: {
+    // call(fn, ...args)
+    <R, Fn: () => R>(Fn): CallEffect<null, Fn, []>,
+    <R, T1, Fn: T1 => R>(Fn, T1): CallEffect<null, Fn, [T1]>,
+    <R, T1, T2, Fn: (T1, T2) => R>(Fn, T1, T2): CallEffect<null, Fn, [T1, T2]>,
+    <R, T1, T2, T3, Fn: (T1, T2, T3) => R>(Fn, T1, T2, T3): CallEffect<null, Fn, [T1, T2, T3]>,
+    <R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<null, Fn, [T1, T2, T3, T4]>,
+    <R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<null, Fn, [T1, T2, T3, T4, T5]>,
+    <R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<null, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<null, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<null, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // call([context, fn], ...args)
+    <Ctx, R, Fn: () => R>(cfn: [Ctx, Fn]): CallEffect<Ctx, Fn, []>,
+    <Ctx, R, T1, Fn: T1 => R>(cfn: [Ctx, Fn], T1): CallEffect<Ctx, Fn, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(cfn: [Ctx, Fn], T1, T2): CallEffect<Ctx, Fn, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3
+    ): CallEffect<Ctx, Fn, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // call([context, fnName], ...args)
+    <R, FnName: string, Fn: () => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName]
+    ): CallEffect<Ctx, Fn, []>,
+    <R, FnName: string, T1, Fn: T1 => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName],
+      T1
+    ): CallEffect<Ctx, Fn, [T1]>,
+    <R, FnName: string, T1, T2, Fn: (T1, T2) => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName],
+      T1,
+      T2
+    ): CallEffect<Ctx, Fn, [T1, T2]>,
+    <R, FnName: string, T1, T2, T3, Fn: (T1, T2, T3) => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3
+    ): CallEffect<Ctx, Fn, [T1, T2, T3]>,
+    <R, FnName: string, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <R, FnName: string, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R, Ctx: { [FnName]: Fn, ... }>(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <
+      R,
+      FnName: string,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      Fn: (T1, T2, T3, T4, T5, T6) => R,
+      Ctx: { [FnName]: Fn, ... }
+    >(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <
+      R,
+      FnName: string,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7) => R,
+      Ctx: { [FnName]: Fn, ... }
+    >(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      R,
+      FnName: string,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R,
+      Ctx: { [FnName]: Fn, ... }
+    >(
+      cfn: [Ctx, FnName],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // call({context, fn}, ...args)
+    <Ctx, R, Fn: () => R>(cfn: {
+      context: Ctx,
+      fn: Fn,
+      ...
+    }): CallEffect<Ctx, Fn, []>,
+    <Ctx, R, T1, Fn: T1 => R>(cfn: {
+      context: Ctx,
+      fn: Fn,
+      ...
+    }, T1): CallEffect<Ctx, Fn, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2
+    ): CallEffect<Ctx, Fn, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3
+    ): CallEffect<Ctx, Fn, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var apply: {
+    // apply(context, fn, args)
+    <Ctx, R, Fn: () => R>(Ctx, Fn): CallEffect<Ctx, Fn, []>,
+    <Ctx, R, T1, Fn: T1 => R>(Ctx, Fn, T1): CallEffect<Ctx, Fn, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(Ctx, Fn, T1, T2): CallEffect<Ctx, Fn, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): CallEffect<Ctx, Fn, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      Ctx,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare type NodeCallback<R> = {
+    (err: Error): void,
+    (err: null | void | false, result: R): void,
+    ...
+  };
+
+  declare export var cps: {
+    // cps(fn, ...args)
+    <R, Fn: (NodeCallback<R>) => void>(Fn): CpsEffect<null, Fn, []>,
+    <R, T1, Fn: (T1, NodeCallback<R>) => void>(Fn, T1): CpsEffect<null, Fn, [T1]>,
+    <R, T1, T2, Fn: (T1, T2, NodeCallback<R>) => void>(Fn, T1, T2): CpsEffect<null, Fn, [T1, T2]>,
+    <R, T1, T2, T3, Fn: (T1, T2, T3, NodeCallback<R>) => void>(
+      Fn,
+      T1,
+      T2,
+      T3
+    ): CpsEffect<null, Fn, [T1, T2, T3]>,
+    <R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, NodeCallback<R>) => void>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): CpsEffect<null, Fn, [T1, T2, T3, T4]>,
+    <R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, NodeCallback<R>) => void>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CpsEffect<null, Fn, [T1, T2, T3, T4, T5]>,
+    <R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, NodeCallback<R>) => void>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CpsEffect<null, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7, NodeCallback<R>) => void>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CpsEffect<null, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, NodeCallback<R>) => void
+    >(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CpsEffect<null, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // cps([context, fn], ...args)
+    <Ctx, R, Fn: (NodeCallback<R>) => void>(cfn: [Ctx, Fn]): CpsEffect<Ctx, Fn, []>,
+    <Ctx, R, T1, Fn: (T1, NodeCallback<R>) => void>(cfn: [Ctx, Fn], T1): CpsEffect<Ctx, Fn, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2
+    ): CpsEffect<Ctx, Fn, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7, NodeCallback<R>) => void>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      Ctx,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, NodeCallback<R>) => void
+    >(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // cps({context, fn}, ...args)
+    <Ctx, R, Fn: (NodeCallback<R>) => void>(cfn: {
+      context: Ctx,
+      fn: Fn,
+      ...
+    }): CpsEffect<Ctx, Fn, []>,
+    <Ctx, R, T1, Fn: (T1, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1
+    ): CpsEffect<Ctx, Fn, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2
+    ): CpsEffect<Ctx, Fn, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7, NodeCallback<R>) => void>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      Ctx,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, NodeCallback<R>) => void
+    >(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CpsEffect<Ctx, Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var fork: {
+    // fork(fn, ...args)
+    <R, Fn: () => R>(Fn): ForkEffect<null, Fn, void, []>,
+    <R, T1, Fn: T1 => R>(Fn, T1): ForkEffect<null, Fn, void, [T1]>,
+    <R, T1, T2, Fn: (T1, T2) => R>(Fn, T1, T2): ForkEffect<null, Fn, void, [T1, T2]>,
+    <R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [T1, T2, T3]>,
+    <R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [T1, T2, T3, T4]>,
+    <R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [T1, T2, T3, T4, T5]>,
+    <R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [T1, T2, T3, T4, T5, T6]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [T1, T2, T3, T4, T5, T6, T7]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // fork([context, fn], ...args)
+    <Ctx, R, Fn: () => R>(cfn: [Ctx, Fn]): ForkEffect<Ctx, Fn, void, []>,
+    <Ctx, R, T1, Fn: T1 => R>(cfn: [Ctx, Fn], T1): ForkEffect<Ctx, Fn, void, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2
+    ): ForkEffect<Ctx, Fn, void, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // fork({context, fn}, ...args)
+    <Ctx, R, Fn: () => R>(cfn: {
+      context: Ctx,
+      fn: Fn,
+      ...
+    }): ForkEffect<Ctx, Fn, void, []>,
+    <Ctx, R, T1, Fn: T1 => R>(cfn: {
+      context: Ctx,
+      fn: Fn,
+      ...
+    }, T1): ForkEffect<Ctx, Fn, void, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2
+    ): ForkEffect<Ctx, Fn, void, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      cfn: {
+        context: Ctx,
+        fn: Fn,
+        ...
+      },
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<Ctx, Fn, void, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var spawn: {
+    // spawn(fn, ...args)
+    <R, Fn: () => R>(Fn): ForkEffect<null, Fn, { detached: true, ... }, []>,
+    <R, T1, Fn: T1 => R>(Fn, T1): ForkEffect<null, Fn, { detached: true, ... }, [T1]>,
+    <R, T1, T2, Fn: (T1, T2) => R>(Fn, T1, T2): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2]>,
+    <R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3]>,
+    <R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3, T4]>,
+    <R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5]>,
+    <R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6, T7]>,
+    <R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    // spawn([context, fn], ...args)
+    <Ctx, R, Fn: () => R>(cfn: [Ctx, Fn]): ForkEffect<Ctx, Fn, { detached: true, ... }, []>,
+    <Ctx, R, T1, Fn: T1 => R>(cfn: [Ctx, Fn], T1): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1]>,
+    <Ctx, R, T1, T2, Fn: (T1, T2) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2]>,
+    <Ctx, R, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3]>,
+    <Ctx, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3, T4]>,
+    <Ctx, R, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6, T7]>,
+    <Ctx, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      cfn: [Ctx, Fn],
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<Ctx, Fn, { detached: true, ... }, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var join: {
+    // join(task)
+    // join([...tasks])
+    <T: Task<any>>(task: T): JoinEffect<T>,
+    <T: Array<Task<any>>>(tasks: T): JoinEffect<T>,
+    ...
+  };
+
+  declare export var cancel: {
+    // cancel()
+    // cancel(task)
+    // cancel([...tasks])
+    (): CancelEffect<"@@redux-saga/SELF_CANCELLATION">,
+    <T: Task<any>>(task: T): CancelEffect<T>,
+    <T: Task<any>>(tasks: Array<T>): CancelEffect<$ReadOnlyArray<T>>,
+    ...
+  };
+
+  declare export var select: {
+    // select(selector, ...args)
+    (): SelectEffect<void, []>,
+    <S, R, Fn: S => R>(Fn): SelectEffect<Fn, []>,
+    <S, R, T1, Fn: (S, T1) => R>(Fn, T1): SelectEffect<Fn, [T1]>,
+    <S, R, T1, T2, Fn: (S, T1, T2) => R>(Fn, T1, T2): SelectEffect<Fn, [T1, T2]>,
+    <S, R, T1, T2, T3, Fn: (S, T1, T2, T3) => R>(Fn, T1, T2, T3): SelectEffect<Fn, [T1, T2, T3]>,
+    <S, R, T1, T2, T3, T4, Fn: (S, T1, T2, T3, T4) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): SelectEffect<Fn, [T1, T2, T3, T4]>,
+    <S, R, T1, T2, T3, T4, T5, Fn: (S, T1, T2, T3, T4, T5) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): SelectEffect<Fn, [T1, T2, T3, T4, T5]>,
+    <S, R, T1, T2, T3, T4, T5, T6, Fn: (S, T1, T2, T3, T4, T5, T6) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): SelectEffect<Fn, [T1, T2, T3, T4, T5, T6]>,
+    <S, R, T1, T2, T3, T4, T5, T6, T7, Fn: (S, T1, T2, T3, T4, T5, T6, T7) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): SelectEffect<Fn, [T1, T2, T3, T4, T5, T6, T7]>,
+    <S, R, T1, T2, T3, T4, T5, T6, T7, T8, Fn: (S, T1, T2, T3, T4, T5, T6, T7, T8) => R>(
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): SelectEffect<Fn, [T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var actionChannel: {
+    // actionChannel(pattern, [buffer])
+    <BT>(): ActionChannelEffect<BT, void, void>,
+    <BT, P: Pattern>(pattern: P): ActionChannelEffect<BT, P, void>,
+    <BT, T, P: Pattern, B: Buffer<T>>(pattern: P, buffer: B): ActionChannelEffect<BT, P, B>,
+    ...
+  };
+
+  declare export var flush: { // flush(channel)
+  <T, CH: FlushableChannel<T>>(channel: CH): FlushEffect<CH>, ... };
+
+  declare export var cancelled: { // cancelled()
+  (): CancelledEffect, ... };
+
+  declare export var setContext: { // setContext(props)
+  <T: {...}>(props: T): SetContextEffect<T>, ... };
+
+  declare export var getContext: { // getContext(prop)
+  <T: string>(prop: T): GetContextEffect<T>, ... };
+
+  declare export var race: {
+    // race(effects)
+    // race([...effects])
+    <R: { +[name: string]: Effect, ... }>(effects: R): RaceEffect<R>,
+    <R: $ReadOnlyArray<Effect>>(effects: R): RaceEffect<R>,
+    ...
+  };
+
+  declare export var all: {
+    // all(effects)
+    // all([...effects])
+    (effects: { +[name: string]: Effect, ... }): AllEffect,
+    (effects: $ReadOnlyArray<Effect>): AllEffect,
+    ...
+  };
+
+  declare export var take: {
+    // take(pattern)
+    // take(channel)
+    (): AllTakeEffect<void>,
+    <T, CH: TakeableChannel<T>>(channel: CH): TakeEffect<void, { channel: CH, ... }, void>,
+    <P: Pattern>(pattern: P): TakeEffect<{ pattern: P, ... }, void, void>,
+    ...
+  };
+
+  declare export var takeMaybe: {
+    // takeMaybe(pattern)
+    // takeMaybe(channel)
+    (): AllTakeEffect<{ maybe: true, ... }>,
+    <T, CH: TakeableChannel<T>>(channel: CH): TakeEffect<void, { channel: CH, ... }, { maybe: true, ... }>,
+    <P: Pattern>(pattern: P): TakeEffect<{ pattern: P, ... }, void, { maybe: true, ... }>,
+    ...
+  };
+
+  declare export var takeEvery: {
+    // takeEvery(pattern, saga, ...args)
+    // takeEvery(channel, saga, ...args)
+    <A, R, P: TakeableChannel<any> | Pattern, Fn: A => R>(P, Fn): ForkEffect<null, Fn, void, [P, Fn]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, Fn: (T1, A) => R>(
+      P,
+      Fn,
+      T1
+    ): ForkEffect<null, Fn, void, [P, Fn, T1]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, Fn: (T1, T2, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, Fn: (T1, T2, T3, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var takeLatest: {
+    // takeLatest(pattern, saga, ...args)
+    // takeLatest(channel, saga, ...args)
+    <A, R, P: TakeableChannel<any> | Pattern, Fn: A => R>(P, Fn): ForkEffect<null, Fn, void, [P, Fn]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, Fn: (T1, A) => R>(
+      P,
+      Fn,
+      T1
+    ): ForkEffect<null, Fn, void, [P, Fn, T1]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, Fn: (T1, T2, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, Fn: (T1, T2, T3, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var takeLeading: {
+    // takeLeading(pattern, saga, ...args)
+    // takeLeading(channel, saga, ...args)
+    <A, R, P: TakeableChannel<any> | Pattern, Fn: A => R>(P, Fn): ForkEffect<null, Fn, void, [P, Fn]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, Fn: (T1, A) => R>(
+      P,
+      Fn,
+      T1
+    ): ForkEffect<null, Fn, void, [P, Fn, T1]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, Fn: (T1, T2, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, Fn: (T1, T2, T3, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5]>,
+    <A, R, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6, A) => R>(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      A,
+      R,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, A) => R
+    >(
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [P, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var delay: {
+    // delay(ms, [val])
+    <T1: number>(timeout: T1): CallEffect<null, (ms: T1) => Promise<true>, [T1]>,
+    <T1: number, T2>(timeout: T1, T2): CallEffect<null, (ms: T1) => Promise<true>, [T1, T2]>,
+    ...
+  };
+
+  declare export var throttle: {
+    // throttle(ms, pattern, saga, ...args)
+    // throttle(ms, channel, saga, ...args)
+    <MS: number, P: TakeableChannel<any> | Pattern, A, R, Fn: A => R>(
+      MS,
+      P,
+      Fn
+    ): ForkEffect<null, Fn, void, [MS, P, Fn]>,
+    <MS: number, P: TakeableChannel<any> | Pattern, A, R, T1, Fn: (T1, A) => R>(
+      MS,
+      P,
+      Fn,
+      T1
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1]>,
+    <MS: number, P: TakeableChannel<any> | Pattern, A, R, T1, T2, Fn: (T1, T2, A) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2]>,
+    <MS: number, P: TakeableChannel<any> | Pattern, A, R, T1, T2, T3, Fn: (T1, T2, T3, A) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3]>,
+    <MS: number, P: TakeableChannel<any> | Pattern, A, R, T1, T2, T3, T4, Fn: (T1, T2, T3, T4, A) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4]>,
+    <
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      A,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      Fn: (T1, T2, T3, T4, T5, A) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5]>,
+    <
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      A,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      Fn: (T1, T2, T3, T4, T5, T6, A) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6]>,
+    <
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      A,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, A) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      A,
+      R,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8, A) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var debounce: {
+    // debounce(ms, pattern, saga, ...args)
+    // debounce(ms, channel, saga, ...args)
+    <R, MS: number, P: TakeableChannel<any> | Pattern, Fn: () => R>(
+      MS,
+      P,
+      Fn
+    ): ForkEffect<null, Fn, void, [MS, P, Fn]>,
+    <R, MS: number, P: TakeableChannel<any> | Pattern, T1, Fn: T1 => R>(
+      MS,
+      P,
+      Fn,
+      T1
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1]>,
+    <R, MS: number, P: TakeableChannel<any> | Pattern, T1, T2, Fn: (T1, T2) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2]>,
+    <R, MS: number, P: TakeableChannel<any> | Pattern, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3]>,
+    <R, MS: number, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4]>,
+    <R, MS: number, P: TakeableChannel<any> | Pattern, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5]>,
+    <
+      R,
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      Fn: (T1, T2, T3, T4, T5, T6) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6]>,
+    <
+      R,
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      Fn: (T1, T2, T3, T4, T5, T6, T7) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      R,
+      MS: number,
+      P: TakeableChannel<any> | Pattern,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R
+    >(
+      MS,
+      P,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): ForkEffect<null, Fn, void, [MS, P, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+
+  declare export var retry: {
+    // retry(maxTries, delay, fn, ...args)
+    <R, MT: number, D: number, Fn: () => R>(MT, D, Fn): CallEffect<null, Function, [MT, D, Fn]>,
+    <R, MT: number, D: number, T1, Fn: T1 => R>(
+      MT,
+      D,
+      Fn,
+      T1
+    ): CallEffect<null, Function, [MT, D, Fn, T1]>,
+    <R, MT: number, D: number, T1, T2, Fn: (T1, T2) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2]>,
+    <R, MT: number, D: number, T1, T2, T3, Fn: (T1, T2, T3) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3]>,
+    <R, MT: number, D: number, T1, T2, T3, T4, Fn: (T1, T2, T3, T4) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3, T4]>,
+    <R, MT: number, D: number, T1, T2, T3, T4, T5, Fn: (T1, T2, T3, T4, T5) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3, T4, T5]>,
+    <R, MT: number, D: number, T1, T2, T3, T4, T5, T6, Fn: (T1, T2, T3, T4, T5, T6) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3, T4, T5, T6]>,
+    <R, MT: number, D: number, T1, T2, T3, T4, T5, T6, T7, Fn: (T1, T2, T3, T4, T5, T6, T7) => R>(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3, T4, T5, T6, T7]>,
+    <
+      R,
+      MT: number,
+      D: number,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8,
+      Fn: (T1, T2, T3, T4, T5, T6, T7, T8) => R
+    >(
+      MT,
+      D,
+      Fn,
+      T1,
+      T2,
+      T3,
+      T4,
+      T5,
+      T6,
+      T7,
+      T8
+    ): CallEffect<null, Function, [MT, D, Fn, T1, T2, T3, T4, T5, T6, T7, T8]>,
+    ...
+  };
+}
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_END.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_END.js
new file mode 100644
index 0000000000..4d9bf0d28f
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_END.js
@@ -0,0 +1,19 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { END } from "redux-saga";
+
+describe("END", () => {
+  it("must import END object with type property", () => {
+    (END.type: "@@redux-saga/CHANNEL_END");
+  });
+
+  it("property 'type' must be read-only", () => {
+    // $FlowExpectedError[cannot-write] - type is read-only
+    END.type = "Mur Amur";
+  });
+
+  it("object END must be exact", () => {
+    // $FlowExpectedError[prop-missing] - exact type
+    END.abc = "Mur Amur";
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_MulticastChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_MulticastChannel.js
new file mode 100644
index 0000000000..39a894833b
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_MulticastChannel.js
@@ -0,0 +1,64 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { multicastChannel, stdChannel, END, type TEnd } from "redux-saga";
+
+const simpleMatcher = arg => !!arg;
+
+describe("multicastChannel", () => {
+  it("must create MulticastChannel", () => {
+    const channel = multicastChannel();
+
+    (channel.take((msg: string | TEnd) => {}): void);
+    (channel.take((msg: string | TEnd) => {}, simpleMatcher): void);
+    (channel.put("message"): void);
+    (channel.close(): void);
+  });
+
+  it("created channel must be read only", () => {
+    const channel = multicastChannel();
+
+    // $FlowExpectedError[cannot-write] - take is read-only
+    channel.take = 69;
+    // $FlowExpectedError[cannot-write] - put is read-only
+    channel.put = 69;
+    // $FlowExpectedError[cannot-write] - close is read-only
+    channel.close = 69;
+  });
+
+  it("created channel must be exact", () => {
+    const channel = multicastChannel();
+
+    // $FlowExpectedError[prop-missing] - exact type
+    channel.abc = 69;
+  });
+});
+
+describe("stdChannel", () => {
+  /* all the tests that below is copy-paste */
+  it("must create MulticastChannel", () => {
+    const channel = stdChannel();
+
+    (channel.take((msg: string | TEnd) => {}): void);
+    (channel.take((msg: string | TEnd) => {}, simpleMatcher): void);
+    (channel.put("message"): void);
+    (channel.close(): void);
+  });
+
+  it("created channel must be read only", () => {
+    const channel = stdChannel();
+
+    // $FlowExpectedError[cannot-write] - take is read-only
+    channel.take = 69;
+    // $FlowExpectedError[cannot-write] - put is read-only
+    channel.put = 69;
+    // $FlowExpectedError[cannot-write] - close is read-only
+    channel.close = 69;
+  });
+
+  it("created channel must be exact", () => {
+    const channel = stdChannel();
+
+    // $FlowExpectedError[prop-missing] - exact type
+    channel.abc = 69;
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_SAGA_LOCATION.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_SAGA_LOCATION.js
new file mode 100644
index 0000000000..d8a5975dc5
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_SAGA_LOCATION.js
@@ -0,0 +1,9 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { SAGA_LOCATION } from "redux-saga";
+
+describe("SAGA_LOCATION", () => {
+  it("must import SAGA_LOCATION string", () => {
+    (SAGA_LOCATION: "@@redux-saga/LOCATION");
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_actionChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_actionChannel.js
new file mode 100644
index 0000000000..55d06e2bee
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_actionChannel.js
@@ -0,0 +1,64 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { buffers, type Buffer } from "redux-saga";
+import { actionChannel } from "redux-saga/effects";
+
+describe("actionChannel(Pattern, ?Buffer) effect", () => {
+  describe("structure", () => {
+    const ach = actionChannel("");
+
+    it('type must be equal "ACTION_CHANNEL"', () => {
+      (ach.type: "ACTION_CHANNEL");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      ach.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      ach.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      ach.abc = 69;
+    });
+  });
+
+  describe("actionChannel(Pattern)", () => {
+    const ach0 = actionChannel();
+    const ach1 = actionChannel("TEST");
+    const ach2 = actionChannel(["SIGN_IN", "SIGN_OUT"]);
+    const ach3 = actionChannel(() => true);
+    const ach4 = actionChannel([b => true, a => false]);
+
+    it("must passes when used properly", () => {
+      (ach0.payload.buffer: void);
+      (ach1.payload.buffer: void);
+      (ach2.payload.buffer: void);
+      (ach3.payload.buffer: void);
+      (ach4.payload.buffer: void);
+
+      (ach0.payload.pattern: void);
+      (ach1.payload.pattern: string);
+      (ach2.payload.pattern[0]: string);
+      (ach3.payload.pattern: Function);
+      (ach4.payload.pattern[0]: Function);
+    });
+
+    it("must rises an error", () => {
+      // $FlowExpectedError[incompatible-cast]
+      (ach2.payload.pattern[99]: number);
+      // $FlowExpectedError[incompatible-cast]
+      (ach4.payload.pattern[2]: string);
+    });
+  });
+
+  describe("actionChannel(Pattern, Buffer)", () => {
+    const ach0 = actionChannel("TEST", buffers.none());
+
+    it("must passes when used properly", () => {
+      (ach0.payload.buffer: Buffer<any>);
+      (ach0.payload.pattern: string);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_all.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_all.js
new file mode 100644
index 0000000000..cceef02a08
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_all.js
@@ -0,0 +1,51 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import type { AllEffect } from "redux-saga";
+import { all, take, put } from "redux-saga/effects";
+
+describe("all effect", () => {
+  describe("structure", () => {
+    const c = all([]);
+
+    it('type must be equal "ALL"', () => {
+      (c.type: "ALL");
+    });
+
+    it('combinator must be equal true', () => {
+      (c.combinator: true);
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("all(Array<Effect>)", () => {
+    it("passes when used properly", () => {
+      const e1 = take("FETCH_STATS");
+      const e2 = put({ type: "FETCH_USER" });
+
+      (all([e1, e2]): AllEffect);
+    });
+  });
+
+  describe("all({[key: string]: Effect})", () => {
+    it("passes when used properly", () => {
+      const e1 = take("FETCH_STATS");
+      const e2 = put({ type: "FETCH_USER" });
+
+      (all({
+        isLogOut: e1,
+        fetchUser: e2
+      }): AllEffect);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_apply.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_apply.js
new file mode 100644
index 0000000000..6932e84bd1
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_apply.js
@@ -0,0 +1,116 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { apply } from "redux-saga/effects";
+
+describe("apply(context, fn, [args])", () => {
+  const context = { some: "contextObject" };
+
+  const fn0 = (): Promise<number> => Promise.resolve(1);
+  const fn1 = (a: string): Promise<number> => Promise.resolve(1);
+  const fn2 = (a: string, b: number): Promise<number> => Promise.resolve(1);
+  const fn3 = (a: string, b: number, c: string): Promise<number> => Promise.resolve(1);
+  const fn4 = (a: string, b: number, c: string, d: number): Promise<number> => Promise.resolve(1);
+  const fn5 = (a: string, b: number, c: string, d: number, e: string): Promise<number> =>
+    Promise.resolve(1);
+  const fn6 = (a: string, b: number, c: string, d: number, e: string, f: number): Promise<number> =>
+    Promise.resolve(1);
+  const fn7 = (
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string
+  ): Promise<number> => Promise.resolve(1);
+  const fn8 = (
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string,
+    h: number
+  ): Promise<number> => Promise.resolve(1);
+
+  const c0 = apply(context, fn0);
+  const c1 = apply(context, fn1, "1");
+  const c2 = apply(context, fn2, "1", 2);
+  const c3 = apply(context, fn3, "1", 2, "3");
+  const c4 = apply(context, fn4, "1", 2, "3", 4);
+  const c5 = apply(context, fn5, "1", 2, "3", 4, "5");
+  const c6 = apply(context, fn6, "1", 2, "3", 4, "5", 6);
+  const c7 = apply(context, fn6, "1", 2, "3", 4, "5", 6, "7");
+  const c8 = apply(context, fn6, "1", 2, "3", 4, "5", 6, "7", 8);
+
+  describe("arguments tests", () => {
+    it("must passes when used properly", () => {
+      (c0.payload.args: []);
+      (c1.payload.args: [string]);
+      (c2.payload.args: [string, number]);
+      (c3.payload.args: [string, number, string]);
+      (c4.payload.args: [string, number, string, number]);
+      (c5.payload.args: [string, number, string, number, string]);
+      (c6.payload.args: [string, number, string, number, string, number]);
+      (c7.payload.args: [string, number, string, number, string, number, string]);
+      (c8.payload.args: [string, number, string, number, string, number, string, number]);
+    });
+
+    it("must raises an error", () => {
+      // $FlowExpectedError[incompatible-call]: Too few arguments
+      apply(context, fn6, "1", 2, "3", 4);
+
+      // $FlowExpectedError[incompatible-call]: Wrong argument types
+      apply(context, fn1, 1);
+
+      // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+      (c1.payload.args: [number]);
+    });
+  });
+
+  describe("function test", () => {
+    it("must passes when used properly", () => {
+      (c1.payload.fn: typeof fn1);
+      (c2.payload.fn: typeof fn2);
+      (c3.payload.fn: typeof fn3);
+      (c4.payload.fn: typeof fn4);
+      (c5.payload.fn: typeof fn5);
+      (c6.payload.fn: typeof fn6);
+      (c7.payload.fn: typeof fn7);
+      (c8.payload.fn: typeof fn8);
+    });
+
+    it("must raises an error", () => {
+      // NOTE: This should actually fail, but apparently more parameter are fine..
+      (c1.payload.fn: typeof fn6);
+
+      // $FlowExpectedError[incompatible-cast]: fn returns a Promise<string> not Promise<number>
+      (c1.payload.fn: (a: boolean) => Promise<number>);
+
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c4.payload.fn: (a: number, b: number) => Promise<string>);
+
+      // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+      (c6.payload.fn: typeof fn1);
+    });
+  });
+
+  describe("context tests", () => {
+    it("must haven't context", () => {
+      (c1.payload.context: typeof context);
+      (c2.payload.context: typeof context);
+      (c3.payload.context: typeof context);
+      (c4.payload.context: typeof context);
+      (c5.payload.context: typeof context);
+      (c6.payload.context: typeof context);
+      (c7.payload.context: typeof context);
+      (c8.payload.context: typeof context);
+    });
+
+    it("must raises an error when lead context to null", () => {
+      // $FlowExpectedError[incompatible-cast]
+      (c1.payload.context: null);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_buffers.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_buffers.js
new file mode 100644
index 0000000000..d1b6b71e82
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_buffers.js
@@ -0,0 +1,89 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { buffers, type Buffer } from "redux-saga";
+
+describe("buffers", () => {
+  it("must be read only object", () => {
+    // $FlowExpectedError[cannot-write]
+    buffers.none = "hi belarus";
+    // $FlowExpectedError[cannot-write]
+    buffers.fixed = "hi belarus";
+    // $FlowExpectedError[cannot-write]
+    buffers.dropping = "hi belarus";
+    // $FlowExpectedError[cannot-write]
+    buffers.sliding = "hi belarus";
+    // $FlowExpectedError[cannot-write]
+    buffers.expanding = "hi belarus";
+  });
+
+  it("must be exact type", () => {
+    // $FlowExpectedError[prop-missing]
+    buffers.anyOtherProp = "anyValue";
+  });
+
+  describe("buffers.none", () => {
+    it("must return Buffer when call it without args", () => {
+      (buffers.none(): Buffer<any>);
+    });
+  });
+
+  describe("buffers.fixed", () => {
+    it("must return Buffer when call it without args", () => {
+      (buffers.fixed(): Buffer<any>);
+    });
+
+    it("must return Buffer when first argument is number", () => {
+      (buffers.fixed(5): Buffer<any>);
+    });
+
+    it("must raises an error when first argument isn't number", () => {
+      // $FlowExpectedError[incompatible-call]: limit parameter must be given as a number
+      (buffers.fixed("five"): Buffer<any>);
+    });
+  });
+
+  describe("buffers.dropping", () => {
+    it("must return Buffer when call it without args", () => {
+      (buffers.dropping(): Buffer<any>);
+    });
+
+    it("must return Buffer when first argument is number", () => {
+      (buffers.dropping(6): Buffer<any>);
+    });
+
+    it("must raises an error when first argument isn't number", () => {
+      // $FlowExpectedError[incompatible-call]: limit parameter must be given as a number
+      (buffers.dropping("six"): Buffer<any>);
+    });
+  });
+
+  describe("buffers.sliding", () => {
+    it("must return Buffer when call it without args", () => {
+      (buffers.sliding(): Buffer<any>);
+    });
+
+    it("must return Buffer when first argument is number", () => {
+      (buffers.sliding(7): Buffer<any>);
+    });
+
+    it("must raises an error when first argument isn't number", () => {
+      // $FlowExpectedError[incompatible-call]: limit parameter must be given as a number
+      (buffers.sliding("seven"): Buffer<any>);
+    });
+  });
+
+  describe("buffers.expanding", () => {
+    it("must return Buffer when call it without args", () => {
+      (buffers.expanding(): Buffer<any>);
+    });
+
+    it("must return Buffer when first argument is number", () => {
+      (buffers.expanding(8): Buffer<any>);
+    });
+
+    it("must raises an error when first argument isn't number", () => {
+      // $FlowExpectedError[incompatible-call]: limit parameter must be given as a number
+      (buffers.expanding("eight"): Buffer<any>);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call.js
new file mode 100644
index 0000000000..f1730ecd7d
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call.js
@@ -0,0 +1,25 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { call } from "redux-saga/effects";
+
+describe("call effect", () => {
+  describe("structure", () => {
+    const c = call(() => {});
+
+    it('type must be equal "CALL"', () => {
+      (c.type: "CALL");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_async.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_async.js
new file mode 100644
index 0000000000..7bc67a3732
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_async.js
@@ -0,0 +1,96 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with async functions and without context", () => {
+  const fn0 = (): Promise<number> => Promise.resolve(1);
+  const fn1 = (a: string): Promise<number> => Promise.resolve(1);
+  const fn2 = (a: string, b: number): Promise<number> => Promise.resolve(1);
+  const fn3 = (a: string, b: number, c: string): Promise<number> => Promise.resolve(1);
+  const fn4 = (a: string, b: number, c: string, d: number): Promise<number> => Promise.resolve(1);
+  const fn5 = (a: string, b: number, c: string, d: number, e: string): Promise<number> =>
+    Promise.resolve(1);
+  const fn6 = (a: string, b: number, c: string, d: number, e: string, f: number): Promise<number> =>
+    Promise.resolve(1);
+
+  const c0 = call(fn0);
+  const c1 = call(fn1, "1");
+  const c2 = call(fn2, "1", 2);
+  const c3 = call(fn3, "1", 2, "3");
+  const c4 = call(fn4, "1", 2, "3", 4);
+  const c5 = call(fn5, "1", 2, "3", 4, "5");
+  const c6 = call(fn6, "1", 2, "3", 4, "5", 6);
+
+  describe("context tests", () => {
+    it("must haven't context", () => {
+      (c1.payload.context: null);
+      (c2.payload.context: null);
+      (c3.payload.context: null);
+      (c4.payload.context: null);
+      (c5.payload.context: null);
+      (c6.payload.context: null);
+    });
+
+    it("must raises an error when lead context to Object", () => {
+      // $FlowExpectedError[incompatible-cast]
+      (c1.payload.context: {...});
+    });
+  });
+
+  describe("arguments tests", () => {
+    it("must passes when used properly", () => {
+      (c0.payload.args: []);
+      (c1.payload.args: [string]);
+      (c2.payload.args: [string, number]);
+      (c3.payload.args: [string, number, string]);
+      (c4.payload.args: [string, number, string, number]);
+      (c5.payload.args: [string, number, string, number, string]);
+      (c6.payload.args: [string, number, string, number, string, number]);
+    });
+
+    it("must raises an error when passed number but need string", () => {
+      // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+      (c1.payload.args: [number]);
+    });
+
+    it("must raises an error when passed too few arguments", () => {
+      // $FlowExpectedError[incompatible-call]: too few arguments
+      call(fn6, "1", 2, "3", 4);
+    });
+
+    it("must raises an error when passed wrong argument types", () => {
+      // $FlowExpectedError[incompatible-call]: wrong argument types
+      call(fn1, 1);
+    });
+  });
+
+  describe("function test", () => {
+    it("must passes when used properly", () => {
+      (c1.payload.fn: typeof fn1);
+      (c2.payload.fn: typeof fn2);
+      (c3.payload.fn: typeof fn3);
+      (c4.payload.fn: typeof fn4);
+      (c5.payload.fn: typeof fn5);
+      (c6.payload.fn: typeof fn6);
+    });
+
+    it("should actually fail, but apparently more parameter are fine", () => {
+      (c1.payload.fn: typeof fn6);
+    });
+
+    it("must raises an error when Function return no Promise< number>", () => {
+      // $FlowExpectedError[incompatible-cast]: fn returns a Promise<string> not Promise<number>
+      (c1.payload.fn: (a: boolean) => Promise<number>);
+    });
+
+    it(`must raises an error when "a" argument isn't string`, () => {
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c4.payload.fn: (a: number, b: number) => Promise<string>);
+    });
+
+    it("must raises an error when less parameter are noticed", () => {
+      // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+      (c6.payload.fn: typeof fn1);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_async.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_async.js
new file mode 100644
index 0000000000..9078b741ca
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_async.js
@@ -0,0 +1,325 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with async functions and context", () => {
+  describe("call([context, fn], ...args)", () => {
+    const context = { some: "contextObject" };
+    const fn0 = (): Promise<number> => Promise.resolve(1);
+    const fn1 = (a: string): Promise<number> => Promise.resolve(1);
+    const fn2 = (a: string, b: number): Promise<number> => Promise.resolve(1);
+    const fn3 = (a: string, b: number, c: string): Promise<number> => Promise.resolve(1);
+    const fn4 = (a: string, b: number, c: string, d: number): Promise<number> => Promise.resolve(1);
+    const fn5 = (a: string, b: number, c: string, d: number, e: string): Promise<number> =>
+      Promise.resolve(1);
+    const fn6 = (
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number
+    ): Promise<number> => Promise.resolve(1);
+
+    const c0 = call([context, fn0]);
+    const c1 = call([context, fn1], "1");
+    const c2 = call([context, fn2], "1", 2);
+    const c3 = call([context, fn3], "1", 2, "3");
+    const c4 = call([context, fn4], "1", 2, "3", 4);
+    const c5 = call([context, fn5], "1", 2, "3", 4, "5");
+    const c6 = call([context, fn6], "1", 2, "3", 4, "5", 6);
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: too few arguments
+        call([context, fn6], "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: wrong argument types
+        call([context, fn1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof fn1);
+        (c2.payload.fn: typeof fn2);
+        (c3.payload.fn: typeof fn3);
+        (c4.payload.fn: typeof fn4);
+        (c5.payload.fn: typeof fn5);
+        (c6.payload.fn: typeof fn6);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof fn6);
+      });
+
+      it("must raises an error when Function return no Promise< number>", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Promise<string> not Promise<number>
+        (c1.payload.fn: (a: boolean) => Promise<number>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Promise<string>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof fn1);
+      });
+    });
+  });
+
+  describe("call([context, fnName], ...args)", () => {
+    const context0 = {
+      someFn0(): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context1 = {
+      someFn1(a: string): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context2 = {
+      someFn2(a: string, b: number): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context3 = {
+      someFn3(a: string, b: number, c: string): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context4 = {
+      someFn4(a: string, b: number, c: string, d: number): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context5 = {
+      someFn5(a: string, b: number, c: string, d: number, e: string): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+    const context6 = {
+      someFn6(a: string, b: number, c: string, d: number, e: string, f: number): Promise<number> {
+        return Promise.resolve(1);
+      }
+    };
+
+    const c0 = call([context0, "someFn0"]);
+    const c1 = call([context1, "someFn1"], "1");
+    const c2 = call([context2, "someFn2"], "1", 2);
+    const c3 = call([context3, "someFn3"], "1", 2, "3");
+    const c4 = call([context4, "someFn4"], "1", 2, "3", 4);
+    const c5 = call([context5, "someFn5"], "1", 2, "3", 4, "5");
+    const c6 = call([context6, "someFn6"], "1", 2, "3", 4, "5", 6);
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context1);
+        (c2.payload.context: typeof context2);
+        (c3.payload.context: typeof context3);
+        (c4.payload.context: typeof context4);
+        (c5.payload.context: typeof context5);
+        (c6.payload.context: typeof context6);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[cannot-resolve-name]: too few arguments
+        call([context, fn6], "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[cannot-resolve-name]: wrong argument types
+        call([context, fn1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: $PropertyType<typeof context1, "someFn1">);
+        (c2.payload.fn: $PropertyType<typeof context2, "someFn2">);
+        (c3.payload.fn: $PropertyType<typeof context3, "someFn3">);
+        (c4.payload.fn: $PropertyType<typeof context4, "someFn4">);
+        (c5.payload.fn: $PropertyType<typeof context5, "someFn5">);
+        (c6.payload.fn: $PropertyType<typeof context6, "someFn6">);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: $PropertyType<typeof context6, "someFn6">);
+      });
+
+      it("must raises an error when Function return no Promise< number>", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Promise<string> not Promise<number>
+        (c1.payload.fn: (a: boolean) => Promise<number>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Promise<string>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: $PropertyType<typeof context1, "someFn1">);
+      });
+    });
+  });
+
+  describe("call({context, fn}, ...args)", () => {
+    const context = { some: "contextObject" };
+
+    const fn0 = (): Promise<number> => Promise.resolve(1);
+    const fn1 = (a: string): Promise<number> => Promise.resolve(1);
+    const fn2 = (a: string, b: number): Promise<number> => Promise.resolve(1);
+    const fn3 = (a: string, b: number, c: string): Promise<number> => Promise.resolve(1);
+    const fn4 = (a: string, b: number, c: string, d: number): Promise<number> => Promise.resolve(1);
+    const fn5 = (a: string, b: number, c: string, d: number, e: string): Promise<number> =>
+      Promise.resolve(1);
+    const fn6 = (
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number
+    ): Promise<number> => Promise.resolve(1);
+
+    const c0 = call({ context, fn: fn0 });
+    const c1 = call({ context, fn: fn1 }, "1");
+    const c2 = call({ context, fn: fn2 }, "1", 2);
+    const c3 = call({ context, fn: fn3 }, "1", 2, "3");
+    const c4 = call({ context, fn: fn4 }, "1", 2, "3", 4);
+    const c5 = call({ context, fn: fn5 }, "1", 2, "3", 4, "5");
+    const c6 = call({ context, fn: fn6 }, "1", 2, "3", 4, "5", 6);
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: too few arguments
+        call({ context, fn: fn6 }, "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: wrong argument types
+        call({ context, fn: fn1 }, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof fn1);
+        (c2.payload.fn: typeof fn2);
+        (c3.payload.fn: typeof fn3);
+        (c4.payload.fn: typeof fn4);
+        (c5.payload.fn: typeof fn5);
+        (c6.payload.fn: typeof fn6);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof fn6);
+      });
+
+      it("must raises an error when Function return no Promise< number>", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Promise<string> not Promise<number>
+        (c1.payload.fn: (a: boolean) => Promise<number>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Promise<string>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof fn1);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_generator.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_generator.js
new file mode 100644
index 0000000000..67c336f3d1
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_generator.js
@@ -0,0 +1,454 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import type { Saga } from "redux-saga";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with normal function and without context", () => {
+  describe("call([context, fn], ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function* s0(): Saga<number> {
+      return 1;
+    }
+    function* s1(a: string): Saga<number> {
+      return 1;
+    }
+    function* s2(a: string, b: number): Saga<number> {
+      return 1;
+    }
+    function* s3(a: string, b: number, c: string): Saga<number> {
+      return 1;
+    }
+    function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+      return 1;
+    }
+    function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+      return 1;
+    }
+    function* s6(a: string, b: number, c: string, d: number, e: string, f: number): Saga<number> {
+      return 1;
+    }
+    function* s7(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string
+    ): Saga<number> {
+      return 1;
+    }
+    function* s8(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      h: number
+    ): Saga<number> {
+      return 1;
+    }
+
+    const c0 = call([context, s0]);
+    const c1 = call([context, s1], "1");
+    const c2 = call([context, s2], "1", 2);
+    const c3 = call([context, s3], "1", 2, "3");
+    const c4 = call([context, s4], "1", 2, "3", 4);
+    const c5 = call([context, s5], "1", 2, "3", 4, "5");
+    const c6 = call([context, s6], "1", 2, "3", 4, "5", 6);
+    const c7 = call([context, s7], "1", 2, "3", 4, "5", 6, "7");
+    const c8 = call([context, s8], "1", 2, "3", 4, "5", 6, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+        (c7.payload.args: [string, number, string, number, string, number, string]);
+        (c8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call([context, s6], "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call([context, s1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof s1);
+        (c2.payload.fn: typeof s2);
+        (c3.payload.fn: typeof s3);
+        (c4.payload.fn: typeof s4);
+        (c5.payload.fn: typeof s5);
+        (c6.payload.fn: typeof s6);
+        (c7.payload.fn: typeof s7);
+        (c8.payload.fn: typeof s8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof s6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Saga<number> not Saga<string>
+        (c1.payload.fn: (a: string) => Saga<string>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => Saga<number>);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Saga<number>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof s1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+        (c7.payload.context: typeof context);
+        (c8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+
+  describe("call([context, fnName], ...args)", () => {
+    const context = { some: "contextObject" };
+
+    const context0 = {
+      someFn0: function* s0(): Saga<number> {
+        return 1;
+      }
+    };
+    const context1 = {
+      someFn1: function* s1(a: string): Saga<number> {
+        return 1;
+      }
+    };
+    const context2 = {
+      someFn2: function* s2(a: string, b: number): Saga<number> {
+        return 1;
+      }
+    };
+    const context3 = {
+      someFn3: function* s3(a: string, b: number, c: string): Saga<number> {
+        return 1;
+      }
+    };
+    const context4 = {
+      someFn4: function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+        return 1;
+      }
+    };
+    const context5 = {
+      someFn5: function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+        return 1;
+      }
+    };
+    const context6 = {
+      someFn6: function* s6(
+        a: string,
+        b: number,
+        c: string,
+        d: number,
+        e: string,
+        f: number
+      ): Saga<number> {
+        return 1;
+      }
+    };
+    const context7 = {
+      someFn7: function* s7(
+        a: string,
+        b: number,
+        c: string,
+        d: number,
+        e: string,
+        f: number,
+        g: string
+      ): Saga<number> {
+        return 1;
+      }
+    };
+    const context8 = {
+      someFn8: function* s8(
+        a: string,
+        b: number,
+        c: string,
+        d: number,
+        e: string,
+        f: number,
+        g: string,
+        h: number
+      ): Saga<number> {
+        return 1;
+      }
+    };
+
+    const c0 = call([context0, "someFn0"]);
+    const c1 = call([context1, "someFn1"], "1");
+    const c2 = call([context2, "someFn2"], "1", 2);
+    const c3 = call([context3, "someFn3"], "1", 2, "3");
+    const c4 = call([context4, "someFn4"], "1", 2, "3", 4);
+    const c5 = call([context5, "someFn5"], "1", 2, "3", 4, "5");
+    const c6 = call([context6, "someFn6"], "1", 2, "3", 4, "5", 6);
+    const c7 = call([context7, "someFn7"], "1", 2, "3", 4, "5", 6, "7");
+    const c8 = call([context8, "someFn8"], "1", 2, "3", 4, "5", 6, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+        (c7.payload.args: [string, number, string, number, string, number, string]);
+        (c8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call([context6, "someFn6"], "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call([context1, "someFn1"], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: $PropertyType<typeof context1, "someFn1">);
+        (c2.payload.fn: $PropertyType<typeof context2, "someFn2">);
+        (c3.payload.fn: $PropertyType<typeof context3, "someFn3">);
+        (c4.payload.fn: $PropertyType<typeof context4, "someFn4">);
+        (c5.payload.fn: $PropertyType<typeof context5, "someFn5">);
+        (c6.payload.fn: $PropertyType<typeof context6, "someFn6">);
+        (c7.payload.fn: $PropertyType<typeof context7, "someFn7">);
+        (c8.payload.fn: $PropertyType<typeof context8, "someFn8">);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: $PropertyType<typeof context6, "someFn6">);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Saga<number> not Saga<string>
+        (c1.payload.fn: (a: string) => Saga<string>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => Saga<number>);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Saga<number>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: $PropertyType<typeof context1, "someFn1">);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context1);
+        (c2.payload.context: typeof context2);
+        (c3.payload.context: typeof context3);
+        (c4.payload.context: typeof context4);
+        (c5.payload.context: typeof context5);
+        (c6.payload.context: typeof context6);
+        (c7.payload.context: typeof context7);
+        (c8.payload.context: typeof context8);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+
+  describe("call({context, fn}, ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function* s0(): Saga<number> {
+      return 1;
+    }
+    function* s1(a: string): Saga<number> {
+      return 1;
+    }
+    function* s2(a: string, b: number): Saga<number> {
+      return 1;
+    }
+    function* s3(a: string, b: number, c: string): Saga<number> {
+      return 1;
+    }
+    function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+      return 1;
+    }
+    function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+      return 1;
+    }
+    function* s6(a: string, b: number, c: string, d: number, e: string, f: number): Saga<number> {
+      return 1;
+    }
+    function* s7(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string
+    ): Saga<number> {
+      return 1;
+    }
+    function* s8(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      h: number
+    ): Saga<number> {
+      return 1;
+    }
+
+    const c0 = call({ context, fn: s0 });
+    const c1 = call({ context, fn: s1 }, "1");
+    const c2 = call({ context, fn: s2 }, "1", 2);
+    const c3 = call({ context, fn: s3 }, "1", 2, "3");
+    const c4 = call({ context, fn: s4 }, "1", 2, "3", 4);
+    const c5 = call({ context, fn: s5 }, "1", 2, "3", 4, "5");
+    const c6 = call({ context, fn: s6 }, "1", 2, "3", 4, "5", 6);
+    const c7 = call({ context, fn: s7 }, "1", 2, "3", 4, "5", 6, "7");
+    const c8 = call({ context, fn: s8 }, "1", 2, "3", 4, "5", 6, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, string]);
+        (c4.payload.args: [string, number, string, number]);
+        (c5.payload.args: [string, number, string, number, string]);
+        (c6.payload.args: [string, number, string, number, string, number]);
+        (c7.payload.args: [string, number, string, number, string, number, string]);
+        (c8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call({ context, fn: s6 }, "1", 2, "3", 4);
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call({ context, fn: s1 }, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof s1);
+        (c2.payload.fn: typeof s2);
+        (c3.payload.fn: typeof s3);
+        (c4.payload.fn: typeof s4);
+        (c5.payload.fn: typeof s5);
+        (c6.payload.fn: typeof s6);
+        (c7.payload.fn: typeof s7);
+        (c8.payload.fn: typeof s8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof s6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a Saga<number> not Saga<string>
+        (c1.payload.fn: (a: string) => Saga<string>);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => Saga<number>);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => Saga<number>);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof s1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+        (c7.payload.context: typeof context);
+        (c8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_normal.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_normal.js
new file mode 100644
index 0000000000..a806062d0d
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_context_normal.js
@@ -0,0 +1,444 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with normal function and without context", () => {
+  describe("call([context, fn], ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const c0 = call([context, nfn0]);
+    const c1 = call([context, nfn1], "1");
+    const c2 = call([context, nfn2], "1", 2);
+    const c3 = call([context, nfn3], "1", 2, true);
+    const c4 = call([context, nfn4], "1", 2, true, "4");
+    const c5 = call([context, nfn5], "1", 2, true, "4", 5);
+    const c6 = call([context, nfn6], "1", 2, true, "4", 5, false);
+    const c7 = call([context, nfn7], "1", 2, true, "4", 5, false, "7");
+    const c8 = call([context, nfn8], "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call([context, nfn6], "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call([context, nfn1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof nfn1);
+        (c2.payload.fn: typeof nfn2);
+        (c3.payload.fn: typeof nfn3);
+        (c4.payload.fn: typeof nfn4);
+        (c5.payload.fn: typeof nfn5);
+        (c6.payload.fn: typeof nfn6);
+        (c7.payload.fn: typeof nfn7);
+        (c8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+        (c7.payload.context: typeof context);
+        (c8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+
+  describe("call([context, fnName], ...args)", () => {
+    const context0 = {
+      someFn0(): number {
+        return 1;
+      }
+    };
+    const context1 = {
+      someFn1(a: string): number {
+        return 1;
+      }
+    };
+    const context2 = {
+      someFn2(a: string, b: number): number {
+        return 1;
+      }
+    };
+    const context3 = {
+      someFn3(a: string, b: number, c: boolean): number {
+        return 1;
+      }
+    };
+    const context4 = {
+      someFn4(a: string, b: number, c: boolean, d: string): number {
+        return 1;
+      }
+    };
+    const context5 = {
+      someFn5(a: string, b: number, c: boolean, d: string, e: number): number {
+        return 1;
+      }
+    };
+    const context6 = {
+      someFn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+        return 1;
+      }
+    };
+    const context7 = {
+      someFn7(
+        a: string,
+        b: number,
+        c: boolean,
+        d: string,
+        e: number,
+        f: boolean,
+        g: string
+      ): number {
+        return 1;
+      }
+    };
+    const context8 = {
+      someFn8(
+        a: string,
+        b: number,
+        c: boolean,
+        d: string,
+        e: number,
+        f: boolean,
+        g: string,
+        h: number
+      ): number {
+        return 1;
+      }
+    };
+
+    const c0 = call([context0, "someFn0"]);
+    const c1 = call([context1, "someFn1"], "1");
+    const c2 = call([context2, "someFn2"], "1", 2);
+    const c3 = call([context3, "someFn3"], "1", 2, true);
+    const c4 = call([context4, "someFn4"], "1", 2, true, "4");
+    const c5 = call([context5, "someFn5"], "1", 2, true, "4", 5);
+    const c6 = call([context6, "someFn6"], "1", 2, true, "4", 5, false);
+    const c7 = call([context7, "someFn7"], "1", 2, true, "4", 5, false, "7");
+    const c8 = call([context8, "someFn8"], "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call([context6, "someFn6"], "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call([context1, "someFn1"], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: $PropertyType<typeof context1, "someFn1">);
+        (c2.payload.fn: $PropertyType<typeof context2, "someFn2">);
+        (c3.payload.fn: $PropertyType<typeof context3, "someFn3">);
+        (c4.payload.fn: $PropertyType<typeof context4, "someFn4">);
+        (c5.payload.fn: $PropertyType<typeof context5, "someFn5">);
+        (c6.payload.fn: $PropertyType<typeof context6, "someFn6">);
+        (c7.payload.fn: $PropertyType<typeof context7, "someFn7">);
+        (c8.payload.fn: $PropertyType<typeof context8, "someFn8">);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: $PropertyType<typeof context6, "someFn6">);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: $PropertyType<typeof context1, "someFn1">);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must haven't context", () => {
+        (c1.payload.context: typeof context1);
+        (c2.payload.context: typeof context2);
+        (c3.payload.context: typeof context3);
+        (c4.payload.context: typeof context4);
+        (c5.payload.context: typeof context5);
+        (c6.payload.context: typeof context6);
+        (c7.payload.context: typeof context7);
+        (c8.payload.context: typeof context8);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+
+  describe("call({context, fn}, ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const c0 = call({ context, fn: nfn0 });
+    const c1 = call({ context, fn: nfn1 }, "1");
+    const c2 = call({ context, fn: nfn2 }, "1", 2);
+    const c3 = call({ context, fn: nfn3 }, "1", 2, true);
+    const c4 = call({ context, fn: nfn4 }, "1", 2, true, "4");
+    const c5 = call({ context, fn: nfn5 }, "1", 2, true, "4", 5);
+    const c6 = call({ context, fn: nfn6 }, "1", 2, true, "4", 5, false);
+    const c7 = call({ context, fn: nfn7 }, "1", 2, true, "4", 5, false, "7");
+    const c8 = call({ context, fn: nfn8 }, "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        call({ context, fn: nfn6 }, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        call({ context, fn: nfn1 }, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof nfn1);
+        (c2.payload.fn: typeof nfn2);
+        (c3.payload.fn: typeof nfn3);
+        (c4.payload.fn: typeof nfn4);
+        (c5.payload.fn: typeof nfn5);
+        (c6.payload.fn: typeof nfn6);
+        (c7.payload.fn: typeof nfn7);
+        (c8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+        (c7.payload.context: typeof context);
+        (c8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_generator.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_generator.js
new file mode 100644
index 0000000000..353aa3bdf7
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_generator.js
@@ -0,0 +1,143 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import type { Saga } from "redux-saga";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with normal function and without context", () => {
+  function* s0(): Saga<number> {
+    return 1;
+  }
+  function* s1(a: string): Saga<number> {
+    return 1;
+  }
+  function* s2(a: string, b: number): Saga<number> {
+    return 1;
+  }
+  function* s3(a: string, b: number, c: string): Saga<number> {
+    return 1;
+  }
+  function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+    return 1;
+  }
+  function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+    return 1;
+  }
+  function* s6(a: string, b: number, c: string, d: number, e: string, f: number): Saga<number> {
+    return 1;
+  }
+  function* s7(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string
+  ): Saga<number> {
+    return 1;
+  }
+  function* s8(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string,
+    h: number
+  ): Saga<number> {
+    return 1;
+  }
+
+  const c0 = call(s0);
+  const c1 = call(s1, "1");
+  const c2 = call(s2, "1", 2);
+  const c3 = call(s3, "1", 2, "3");
+  const c4 = call(s4, "1", 2, "3", 4);
+  const c5 = call(s5, "1", 2, "3", 4, "5");
+  const c6 = call(s6, "1", 2, "3", 4, "5", 6);
+  const c7 = call(s7, "1", 2, "3", 4, "5", 6, "7");
+  const c8 = call(s8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+  describe("arguments tests", () => {
+    it("must passes when used properly", () => {
+      (c0.payload.args: []);
+      (c1.payload.args: [string]);
+      (c2.payload.args: [string, number]);
+      (c3.payload.args: [string, number, string]);
+      (c4.payload.args: [string, number, string, number]);
+      (c5.payload.args: [string, number, string, number, string]);
+      (c6.payload.args: [string, number, string, number, string, number]);
+      (c7.payload.args: [string, number, string, number, string, number, string]);
+      (c8.payload.args: [string, number, string, number, string, number, string, number]);
+    });
+
+    it("must raises an error when passed number but need string", () => {
+      // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+      (c1.payload.args: [number]);
+    });
+
+    it("must raises an error when passed too few arguments", () => {
+      // $FlowExpectedError[incompatible-call]: Too few arguments
+      call(s6, "1", 2, "3", 4);
+    });
+
+    it("must raises an error when passed wrong argument types", () => {
+      // $FlowExpectedError[incompatible-call]: Wrong argument types
+      call(s1, 1);
+    });
+  });
+
+  describe("function test", () => {
+    it("must passes when used properly", () => {
+      (c1.payload.fn: typeof s1);
+      (c2.payload.fn: typeof s2);
+      (c3.payload.fn: typeof s3);
+      (c4.payload.fn: typeof s4);
+      (c5.payload.fn: typeof s5);
+      (c6.payload.fn: typeof s6);
+      (c7.payload.fn: typeof s7);
+      (c8.payload.fn: typeof s8);
+    });
+
+    it("should actually fail, but apparently more parameter are fine", () => {
+      (c1.payload.fn: typeof s6);
+    });
+
+    it("must raises an error when Function return not string", () => {
+      // $FlowExpectedError[incompatible-cast]: fn returns a Saga<number> not Saga<string>
+      (c1.payload.fn: (a: string) => Saga<string>);
+    });
+
+    it(`must raises an error when "a" argument isn't string`, () => {
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c1.payload.fn: (a: boolean) => Saga<number>);
+
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c4.payload.fn: (a: number, b: number) => Saga<number>);
+    });
+
+    it("must raises an error when less parameter are noticed", () => {
+      // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+      (c6.payload.fn: typeof s1);
+    });
+  });
+
+  describe("context tests", () => {
+    it("must haven't context", () => {
+      (c1.payload.context: null);
+      (c2.payload.context: null);
+      (c3.payload.context: null);
+      (c4.payload.context: null);
+      (c5.payload.context: null);
+      (c6.payload.context: null);
+      (c7.payload.context: null);
+      (c8.payload.context: null);
+    });
+
+    it("must raises an error when lead context to Object", () => {
+      // $FlowExpectedError[incompatible-cast]
+      (c1.payload.context: {...});
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_normal.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_normal.js
new file mode 100644
index 0000000000..d303b57f37
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_call_normal.js
@@ -0,0 +1,142 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { call } from "redux-saga/effects";
+
+describe("call() effect with normal function and without context", () => {
+  function nfn0(): number {
+    return 1;
+  }
+  function nfn1(a: string): number {
+    return 1;
+  }
+  function nfn2(a: string, b: number): number {
+    return 1;
+  }
+  function nfn3(a: string, b: number, c: boolean): number {
+    return 1;
+  }
+  function nfn4(a: string, b: number, c: boolean, d: string): number {
+    return 1;
+  }
+  function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+    return 1;
+  }
+  function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+    return 1;
+  }
+  function nfn7(
+    a: string,
+    b: number,
+    c: boolean,
+    d: string,
+    e: number,
+    f: boolean,
+    g: string
+  ): number {
+    return 1;
+  }
+  function nfn8(
+    a: string,
+    b: number,
+    c: boolean,
+    d: string,
+    e: number,
+    f: boolean,
+    g: string,
+    h: number
+  ): number {
+    return 1;
+  }
+
+  const c0 = call(nfn0);
+  const c1 = call(nfn1, "1");
+  const c2 = call(nfn2, "1", 2);
+  const c3 = call(nfn3, "1", 2, true);
+  const c4 = call(nfn4, "1", 2, true, "4");
+  const c5 = call(nfn5, "1", 2, true, "4", 5);
+  const c6 = call(nfn6, "1", 2, true, "4", 5, false);
+  const c7 = call(nfn7, "1", 2, true, "4", 5, false, "7");
+  const c8 = call(nfn8, "1", 2, true, "4", 5, false, "7", 8);
+
+  describe("arguments tests", () => {
+    it("must passes when used properly", () => {
+      (c0.payload.args: []);
+      (c1.payload.args: [string]);
+      (c2.payload.args: [string, number]);
+      (c3.payload.args: [string, number, boolean]);
+      (c4.payload.args: [string, number, boolean, string]);
+      (c5.payload.args: [string, number, boolean, string, number]);
+      (c6.payload.args: [string, number, boolean, string, number, boolean]);
+      (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+      (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+    });
+
+    it("must raises an error when passed number but need string", () => {
+      // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+      (c1.payload.args: [number]);
+    });
+
+    it("must raises an error when passed too few arguments", () => {
+      // $FlowExpectedError[incompatible-call]: Too few arguments
+      call(nfn6, "1", 2, true, "4");
+    });
+
+    it("must raises an error when passed wrong argument types", () => {
+      // $FlowExpectedError[incompatible-call]: Wrong argument types
+      call(nfn1, 1);
+    });
+  });
+
+  describe("function test", () => {
+    it("must passes when used properly", () => {
+      (c1.payload.fn: typeof nfn1);
+      (c2.payload.fn: typeof nfn2);
+      (c3.payload.fn: typeof nfn3);
+      (c4.payload.fn: typeof nfn4);
+      (c5.payload.fn: typeof nfn5);
+      (c6.payload.fn: typeof nfn6);
+      (c7.payload.fn: typeof nfn7);
+      (c8.payload.fn: typeof nfn8);
+    });
+
+    it("should actually fail, but apparently more parameter are fine", () => {
+      (c1.payload.fn: typeof nfn6);
+    });
+
+    it("must raises an error when Function return not string", () => {
+      // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+      (c1.payload.fn: (a: boolean) => string);
+    });
+
+    it(`must raises an error when "a" argument isn't string`, () => {
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c1.payload.fn: (a: boolean) => number);
+
+      // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+      (c4.payload.fn: (a: number, b: number) => number);
+    });
+
+    it("must raises an error when less parameter are noticed", () => {
+      // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+      (c6.payload.fn: typeof nfn1);
+    });
+  });
+
+  describe("context tests", () => {
+    it("must haven't context", () => {
+      (c1.payload.context: null);
+      (c2.payload.context: null);
+      (c3.payload.context: null);
+      (c4.payload.context: null);
+      (c5.payload.context: null);
+      (c6.payload.context: null);
+      (c7.payload.context: null);
+      (c8.payload.context: null);
+    });
+
+    it("must raises an error when lead context to Object", () => {
+      // $FlowExpectedError[incompatible-cast]
+      (c1.payload.context: {...});
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel-symbol.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel-symbol.js
new file mode 100644
index 0000000000..a8c38ebde7
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel-symbol.js
@@ -0,0 +1,9 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { CANCEL } from "redux-saga";
+
+describe("CANCEL", () => {
+  it("must import CANCEL sting", () => {
+    (CANCEL: "@@redux-saga/CANCEL_PROMISE");
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel.js
new file mode 100644
index 0000000000..a350f26c8a
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancel.js
@@ -0,0 +1,47 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import type { Task } from "redux-saga";
+import { cancel } from "redux-saga/effects";
+
+describe("cancel(task)", () => {
+  describe("structure", () => {
+    const c = cancel();
+
+    it('type must be equal "CANCEL"', () => {
+      (c.type: "CANCEL");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("passes when used properly", () => {
+    it("must return self cancellation", () => {
+      const selfCancel = cancel();
+
+      (selfCancel.payload: "@@redux-saga/SELF_CANCELLATION");
+    });
+
+    it("must return task cancellation", () => {
+      declare var task1: Task<string>;
+      declare var task2: Task<number>;
+
+      const c1 = cancel(task1);
+      const c2 = cancel(task2);
+      const c3 = cancel([task1, task2]);
+
+      (c1.payload: typeof task1);
+      (c2.payload: typeof task2);
+      (c3.payload: $ReadOnlyArray<typeof task1 | typeof task2>);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancelled.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancelled.js
new file mode 100644
index 0000000000..f0f84077f6
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cancelled.js
@@ -0,0 +1,31 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { cancelled } from "redux-saga/effects";
+
+describe("cancelled()", () => {
+  describe("structure", () => {
+    const c = cancelled();
+
+    it("payload must be empty object", () => {
+      const a = {};
+
+      (c.payload: typeof a);
+    });
+
+    it('type must be equal "CANCELLED"', () => {
+      (c.type: "CANCELLED");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_channel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_channel.js
new file mode 100644
index 0000000000..9295128ce2
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_channel.js
@@ -0,0 +1,104 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { channel, buffers, END, type TEnd, type Channel, type Buffer } from "redux-saga";
+
+describe("channel", () => {
+  it("returned Channel must be read only object", () => {
+    const ch = channel();
+
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.close = "hi david";
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.take = "hi david";
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.put = "hi david";
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.flush = "hi david";
+  });
+
+  it("returned Channel must be exact type", () => {
+    const ch = channel();
+    // $FlowExpectedError[prop-missing]- exact type
+    ch.anyOtherProp = "anyValue";
+  });
+
+  it("must passes when first argument buffer or nothing", () => {
+    const ch = channel();
+
+    (ch: Channel<any>);
+
+    const ch2 = channel(buffers.none());
+
+    (ch2: Channel<any>);
+  });
+
+  it("must raises an error first argument isn't buffer or nothing", () => {
+    // $FlowExpectedError[prop-missing] number isn't Buffer
+    const ch = channel(1);
+
+    // $FlowExpectedError[prop-missing] object isn't Buffer
+    const ch2 = channel({});
+  });
+
+  it("must passes when used properly", () => {
+    type T = number;
+
+    declare var buffer: Buffer<T>;
+
+    const ch = channel(buffer);
+
+    (ch.close(): void);
+
+    const cbTake = (a: T | TEnd) => {};
+    (ch.take(cbTake): void);
+
+    const cbFlush = (a: Array<T> | TEnd) => {};
+    (ch.flush(cbFlush): void);
+
+    (ch.put(123): void);
+    (ch.put(END): void);
+  });
+
+  it("must raises an error when passed incompatible types", () => {
+    type T = number;
+
+    declare var buffer: Buffer<T>;
+
+    const ch = channel(buffer);
+
+    (ch.close(): void);
+
+    const cbTake = (a: string | TEnd) => {};
+    // $FlowExpectedError[incompatible-call]
+    (ch.take(cbTake): void);
+
+    const cbFlush = (a: Array<boolean> | TEnd) => {};
+    // $FlowExpectedError[incompatible-call]
+    (ch.flush(cbFlush): void);
+
+    // $FlowExpectedError[incompatible-call]
+    (ch.put("oppsss"): void);
+  });
+
+  it("must raises an error when call 'take' without args", () => {
+    const ch = channel();
+
+    // $FlowExpectedError[incompatible-call]
+    ch.take();
+  });
+
+  it("must raises an error when call 'flush' without args", () => {
+    const ch = channel();
+
+    // $FlowExpectedError[incompatible-call]
+    ch.flush();
+  });
+
+  it("must raises an error when call 'put' without args", () => {
+    declare var buffer: Buffer<number>;
+    const ch = channel(buffer);
+
+    // $FlowExpectedError[incompatible-call]
+    ch.put();
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cps.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cps.js
new file mode 100644
index 0000000000..c21ef6a7b7
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_cps.js
@@ -0,0 +1,232 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { cps } from "redux-saga/effects";
+
+describe("cps effect", () => {
+  describe("structure", () => {
+    const c = cps(() => {});
+
+    it('type must be equal "CPS"', () => {
+      (c.type: "CPS");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("all variants", () => {
+    declare type NodeCallback<R> = {
+      (err: Error): void,
+      (err: null | void | false, result: R): void,
+      ...
+    };
+
+    function cpsfn0(cb: NodeCallback<number>): void {}
+    function cpsfn1(a: string, cb: NodeCallback<number>): void {}
+    function cpsfn2(a: string, b: number, cb: NodeCallback<number>): void {}
+    function cpsfn3(a: string, b: number, c: string, cb: NodeCallback<number>): void {}
+    function cpsfn4(a: string, b: number, c: string, d: number, cb: NodeCallback<number>): void {}
+    function cpsfn5(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      cb: NodeCallback<number>
+    ): void {}
+    function cpsfn6(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      cb: NodeCallback<number>
+    ): void {}
+    function cpsfn7(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      cb: NodeCallback<number>
+    ): void {}
+    function cpsfn8(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      h: number,
+      cb: NodeCallback<number>
+    ): void {}
+
+    describe("cps(fn, ...args)", () => {
+      const e0 = cps(cpsfn0);
+      const e1 = cps(cpsfn1, "1");
+      const e2 = cps(cpsfn2, "1", 2);
+      const e3 = cps(cpsfn3, "1", 2, "3");
+      const e4 = cps(cpsfn4, "1", 2, "3", 4);
+      const e5 = cps(cpsfn5, "1", 2, "3", 4, "5");
+      const e6 = cps(cpsfn6, "1", 2, "3", 4, "5", 6);
+      const e7 = cps(cpsfn7, "1", 2, "3", 4, "5", 6, "7");
+      const e8 = cps(cpsfn8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+      it("must passes when correct arguments are passed", () => {
+        (e0.payload.args: []);
+        (e1.payload.args: [string]);
+        (e2.payload.args: [string, number]);
+        (e3.payload.args: [string, number, string]);
+        (e4.payload.args: [string, number, string, number]);
+        (e5.payload.args: [string, number, string, number, string]);
+        (e6.payload.args: [string, number, string, number, string, number]);
+        (e7.payload.args: [string, number, string, number, string, number, string]);
+        (e8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must passes when context is null", () => {
+        (e1.payload.context: null);
+        (e2.payload.context: null);
+        (e3.payload.context: null);
+        (e4.payload.context: null);
+        (e5.payload.context: null);
+        (e6.payload.context: null);
+        (e7.payload.context: null);
+        (e8.payload.context: null);
+      });
+
+      it("must passes when correct fn type", () => {
+        (e1.payload.fn: typeof cpsfn1);
+        (e2.payload.fn: typeof cpsfn2);
+        (e3.payload.fn: typeof cpsfn3);
+        (e4.payload.fn: typeof cpsfn4);
+        (e5.payload.fn: typeof cpsfn5);
+        (e6.payload.fn: typeof cpsfn6);
+        (e7.payload.fn: typeof cpsfn7);
+        (e8.payload.fn: typeof cpsfn8);
+
+        // $FlowExpectedError[incompatible-cast]: wrong fn
+        (e6.payload.fn: typeof cpsfn1);
+      });
+    });
+
+    describe("cps([context, fn], ...args)", () => {
+      const context = { some: "context" };
+      const e0 = cps([context, cpsfn0]);
+      const e1 = cps([context, cpsfn1], "1");
+      const e2 = cps([context, cpsfn2], "1", 2);
+      const e3 = cps([context, cpsfn3], "1", 2, "3");
+      const e4 = cps([context, cpsfn4], "1", 2, "3", 4);
+      const e5 = cps([context, cpsfn5], "1", 2, "3", 4, "5");
+      const e6 = cps([context, cpsfn6], "1", 2, "3", 4, "5", 6);
+      const e7 = cps([context, cpsfn7], "1", 2, "3", 4, "5", 6, "7");
+      const e8 = cps([context, cpsfn8], "1", 2, "3", 4, "5", 6, "7", 8);
+
+      it("must passes when correct arguments are passed", () => {
+        (e0.payload.args: []);
+        (e1.payload.args: [string]);
+        (e2.payload.args: [string, number]);
+        (e3.payload.args: [string, number, string]);
+        (e4.payload.args: [string, number, string, number]);
+        (e5.payload.args: [string, number, string, number, string]);
+        (e6.payload.args: [string, number, string, number, string, number]);
+        (e7.payload.args: [string, number, string, number, string, number, string]);
+        (e8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must passes when context isn't null", () => {
+        (e1.payload.context: typeof context);
+        (e2.payload.context: typeof context);
+        (e3.payload.context: typeof context);
+        (e4.payload.context: typeof context);
+        (e5.payload.context: typeof context);
+        (e6.payload.context: typeof context);
+        (e7.payload.context: typeof context);
+        (e8.payload.context: typeof context);
+
+        // $FlowExpectedError[incompatible-cast]: not null
+        (e8.payload.context: null);
+      });
+
+      it("must passes when correct fn equal", () => {
+        (e1.payload.fn: typeof cpsfn1);
+        (e2.payload.fn: typeof cpsfn2);
+        (e3.payload.fn: typeof cpsfn3);
+        (e4.payload.fn: typeof cpsfn4);
+        (e5.payload.fn: typeof cpsfn5);
+        (e6.payload.fn: typeof cpsfn6);
+        (e7.payload.fn: typeof cpsfn7);
+        (e8.payload.fn: typeof cpsfn8);
+
+        // $FlowExpectedError[incompatible-cast]: wrong fn
+        (e6.payload.fn: typeof cpsfn1);
+      });
+    });
+
+    describe("cps({context, fn}, ...args)", () => {
+      const context = { some: "context" };
+      const e0 = cps({ context, fn: cpsfn0 });
+      const e1 = cps({ context, fn: cpsfn1 }, "1");
+      const e2 = cps({ context, fn: cpsfn2 }, "1", 2);
+      const e3 = cps({ context, fn: cpsfn3 }, "1", 2, "3");
+      const e4 = cps({ context, fn: cpsfn4 }, "1", 2, "3", 4);
+      const e5 = cps({ context, fn: cpsfn5 }, "1", 2, "3", 4, "5");
+      const e6 = cps({ context, fn: cpsfn6 }, "1", 2, "3", 4, "5", 6);
+      const e7 = cps({ context, fn: cpsfn7 }, "1", 2, "3", 4, "5", 6, "7");
+      const e8 = cps({ context, fn: cpsfn8 }, "1", 2, "3", 4, "5", 6, "7", 8);
+
+      it("must passes when correct arguments are passed", () => {
+        (e0.payload.args: []);
+        (e1.payload.args: [string]);
+        (e2.payload.args: [string, number]);
+        (e3.payload.args: [string, number, string]);
+        (e4.payload.args: [string, number, string, number]);
+        (e5.payload.args: [string, number, string, number, string]);
+        (e6.payload.args: [string, number, string, number, string, number]);
+        (e7.payload.args: [string, number, string, number, string, number, string]);
+        (e8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must passes when context isn't null", () => {
+        (e1.payload.context: typeof context);
+        (e2.payload.context: typeof context);
+        (e3.payload.context: typeof context);
+        (e4.payload.context: typeof context);
+        (e5.payload.context: typeof context);
+        (e6.payload.context: typeof context);
+        (e7.payload.context: typeof context);
+        (e8.payload.context: typeof context);
+
+        // $FlowExpectedError[incompatible-cast]: not null
+        (e8.payload.context: null);
+      });
+
+      it("must passes when correct fn equal", () => {
+        (e1.payload.fn: typeof cpsfn1);
+        (e2.payload.fn: typeof cpsfn2);
+        (e3.payload.fn: typeof cpsfn3);
+        (e4.payload.fn: typeof cpsfn4);
+        (e5.payload.fn: typeof cpsfn5);
+        (e6.payload.fn: typeof cpsfn6);
+        (e7.payload.fn: typeof cpsfn7);
+        (e8.payload.fn: typeof cpsfn8);
+
+        // $FlowExpectedError[incompatible-cast]: wrong fn
+        (e6.payload.fn: typeof cpsfn1);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_createSagaMiddleware.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_createSagaMiddleware.js
new file mode 100644
index 0000000000..c648ce0cf8
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_createSagaMiddleware.js
@@ -0,0 +1,25 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import createSagaMiddleware from 'redux-saga';
+
+// Emulate redux
+type DispatchAPI<A> = (action: A) => A;
+type Dispatch<A: { type: string, ... }> = DispatchAPI<A>;
+type MiddlewareAPI<S, A, D = Dispatch<A>> = {
+  dispatch: D,
+  getState(): S,
+  ...
+};
+type Middleware<S, A, D = Dispatch<A>> = (
+  api: MiddlewareAPI<S, A, D>
+) => (next: D) => D;
+declare function applyMiddleware<S, A, D>(
+  ...middlewares: Array<Middleware<S, A, D>>
+): {...};
+
+describe('createSagaMiddleware', () => {
+  it('works with redux applyMiddleware', () => {
+    const sagaMiddleware = createSagaMiddleware();
+    const enhancer = applyMiddleware(sagaMiddleware);
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_debounce.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_debounce.js
new file mode 100644
index 0000000000..635973519c
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_debounce.js
@@ -0,0 +1,195 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { type Saga, type Channel } from "redux-saga";
+import { debounce } from "redux-saga/effects";
+
+describe("debounce effect", () => {
+  describe("structure", () => {
+    const c = debounce(0, "ACTION", () => {});
+
+    it('type must be equal "FORK"', () => {
+      (c.type: "FORK");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  function* s0(): Saga<number> {
+    return 69;
+  }
+
+  function* s1(a: number): Saga<number> {
+    return 69;
+  }
+
+  function* s2(a: number, b: string): Saga<number> {
+    return 69;
+  }
+
+  function* s3(a: number, b: string, c: number): Saga<number> {
+    return 69;
+  }
+
+  function* s4(a: number, b: string, c: number, d: string): Saga<number> {
+    return 69;
+  }
+
+  function* s5(a: number, b: string, c: number, d: string, e: number): Saga<number> {
+    return 69;
+  }
+
+  function* s6(a: number, b: string, c: number, d: string, e: number, f: string): Saga<number> {
+    return 69;
+  }
+
+  function* s7(
+    a: number,
+    b: string,
+    c: number,
+    d: string,
+    e: number,
+    f: string,
+    g: number
+  ): Saga<number> {
+    return 69;
+  }
+
+  function* s8(
+    a: number,
+    b: string,
+    c: number,
+    d: string,
+    e: number,
+    f: string,
+    g: number,
+    h: string
+  ): Saga<number> {
+    return 69;
+  }
+
+  describe("debounce(ms, pattern, saga, ...args)", () => {
+    it("passes when used properly", () => {
+      const fork0 = debounce(69, "TEST", s0);
+      const fork1 = debounce(69, "TEST", s1, 1);
+      const fork2 = debounce(69, "TEST", s2, 1, "2");
+      const fork3 = debounce(69, "TEST", s3, 1, "2", 3);
+      const fork4 = debounce(69, "TEST", s4, 1, "2", 3, "4");
+      const fork5 = debounce(69, "TEST", s5, 1, "2", 3, "4", 5);
+      const fork6 = debounce(69, "TEST", s6, 1, "2", 3, "4", 5, "6");
+      const fork7 = debounce(69, "TEST", s7, 1, "2", 3, "4", 5, "6", 7);
+      const fork8 = debounce(69, "TEST", s8, 1, "2", 3, "4", 5, "6", 7, "8");
+
+      (fork0.type: "FORK");
+
+      (fork0.payload.args: [number, string, typeof s0]);
+      (fork1.payload.args: [number, string, typeof s1, number]);
+      (fork2.payload.args: [number, string, typeof s2, number, string]);
+      (fork3.payload.args: [number, string, typeof s3, number, string, number]);
+      (fork4.payload.args: [number, string, typeof s4, number, string, number, string]);
+      (fork5.payload.args: [number, string, typeof s5, number, string, number, string, number]);
+      (fork6.payload.args: [
+        number,
+        string,
+        typeof s6,
+        number,
+        string,
+        number,
+        string,
+        number,
+        string
+      ]);
+      (fork7.payload.args: [
+        number,
+        string,
+        typeof s7,
+        number,
+        string,
+        number,
+        string,
+        number,
+        string,
+        number
+      ]);
+      (fork8.payload.args: [
+        number,
+        string,
+        typeof s8,
+        number,
+        string,
+        number,
+        string,
+        number,
+        string,
+        number,
+        string
+      ]);
+    });
+  });
+
+  describe("debounce(ms, channel, saga, ...args)", () => {
+    declare var ch: Channel<any>;
+
+    const fork0 = debounce(69, ch, s0);
+    const fork1 = debounce(69, ch, s1, 1);
+    const fork2 = debounce(69, ch, s2, 1, "2");
+    const fork3 = debounce(69, ch, s3, 1, "2", 3);
+    const fork4 = debounce(69, ch, s4, 1, "2", 3, "4");
+    const fork5 = debounce(69, ch, s5, 1, "2", 3, "4", 5);
+    const fork6 = debounce(69, ch, s6, 1, "2", 3, "4", 5, "6");
+    const fork7 = debounce(69, ch, s7, 1, "2", 3, "4", 5, "6", 7);
+    const fork8 = debounce(69, ch, s8, 1, "2", 3, "4", 5, "6", 7, "8");
+
+    (fork0.payload.args: [number, typeof ch, typeof s0]);
+    (fork1.payload.args: [number, typeof ch, typeof s1, number]);
+    (fork2.payload.args: [number, typeof ch, typeof s2, number, string]);
+    (fork3.payload.args: [number, typeof ch, typeof s3, number, string, number]);
+    (fork4.payload.args: [number, typeof ch, typeof s4, number, string, number, string]);
+    (fork5.payload.args: [number, typeof ch, typeof s5, number, string, number, string, number]);
+    (fork6.payload.args: [
+      number,
+      typeof ch,
+      typeof s6,
+      number,
+      string,
+      number,
+      string,
+      number,
+      string
+    ]);
+    (fork7.payload.args: [
+      number,
+      typeof ch,
+      typeof s7,
+      number,
+      string,
+      number,
+      string,
+      number,
+      string,
+      number
+    ]);
+    (fork8.payload.args: [
+      number,
+      typeof ch,
+      typeof s8,
+      number,
+      string,
+      number,
+      string,
+      number,
+      string,
+      number,
+      string
+    ]);
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_default.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_default.js
new file mode 100644
index 0000000000..a5e2e10d4b
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_default.js
@@ -0,0 +1,152 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import sagaMiddlewareFactory, {
+  type Task,
+  type Saga,
+  type SagaMonitor,
+  type EffectMiddleware,
+  type SagaMiddleware
+} from "redux-saga";
+
+describe("sagaMiddlewareFactory", () => {
+  function* s0(): Saga<number> {
+    return 1;
+  }
+  function* s1(a: string): Saga<number> {
+    return 1;
+  }
+  function* s2(a: string, b: number): Saga<number> {
+    return 1;
+  }
+  function* s3(a: string, b: number, c: string): Saga<number> {
+    return 1;
+  }
+  function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+    return 1;
+  }
+  function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+    return 1;
+  }
+  function* s6(a: string, b: number, c: string, d: number, e: string, f: number): Saga<number> {
+    return 1;
+  }
+  function* s7(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string
+  ): Saga<number> {
+    return 1;
+  }
+  function* s8(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string,
+    h: number
+  ): Saga<number> {
+    return 1;
+  }
+
+  it("must passes when don't pass an argument", () => {
+    (sagaMiddlewareFactory<Symbol>(): SagaMiddleware<Symbol>);
+  });
+
+  describe("run()", () => {
+    const middleware = sagaMiddlewareFactory();
+
+    it("must passes when used properly", () => {
+      middleware.run(s0);
+      middleware.run(s1, "1");
+      middleware.run(s2, "1", 2);
+      middleware.run(s3, "1", 2, "3");
+      middleware.run(s4, "1", 2, "3", 4);
+      middleware.run(s5, "1", 2, "3", 4, "5");
+      middleware.run(s6, "1", 2, "3", 4, "5", 6);
+      middleware.run(s7, "1", 2, "3", 4, "5", 6, "7");
+      middleware.run(s8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+      (middleware.run(s0): Task<number>);
+    });
+
+    it("must raises an error when argument type incompatible", () => {
+      // $FlowExpectedError[incompatible-call]: Boolean argument should be string
+      middleware.run(s3, true, 2, "3");
+    });
+
+    it("must raises an error when returned Task type incompatible", () => {
+      // $FlowExpectedError[incompatible-cast]: Number [1] is incompatible with string [2] in type argument
+      (middleware.run(s0): Task<string>);
+    });
+  });
+
+  describe("SagaMiddlewareOptions", () => {
+    const sagaMonitor: SagaMonitor = {
+      effectTriggered: _ => {},
+      effectResolved: (_, _2) => {},
+      effectRejected: (_, _2) => {},
+      effectCancelled: _ => {},
+      actionDispatched: _ => {}
+    };
+
+    const simpleEffectMiddleware: EffectMiddleware = (next: (e: mixed) => void) => effect => {};
+
+    it("must passes when used properly", () => {
+      const logger = level => {};
+      const error = (e: Error) => {};
+      const error2 = () => {};
+
+      sagaMiddlewareFactory({ sagaMonitor });
+      sagaMiddlewareFactory({ logger });
+      sagaMiddlewareFactory({ onError: error });
+      sagaMiddlewareFactory({ onError: error2 });
+      sagaMiddlewareFactory<{ someContext: string, ... }>({
+        context: { someContext: "data" }
+      });
+
+      sagaMiddlewareFactory({ effectMiddlewares: [] });
+      sagaMiddlewareFactory({ effectMiddlewares: [simpleEffectMiddleware] });
+    });
+
+    it("must raises an error when EffectMiddleware doesn't return function", () => {
+      // $FlowExpectedError[incompatible-call]
+      sagaMiddlewareFactory({ effectMiddlewares: [() => {}] });
+    });
+
+    it("must raises an error when Context type incompatible", () => {
+      type C = { test: number, ... };
+
+      sagaMiddlewareFactory<C>({ context: { test: 99 } });
+
+      // $FlowExpectedError[incompatible-call]: string [1] is incompatible with number
+      sagaMiddlewareFactory<C>({}).setContext({ test: "string" });
+
+      // $FlowExpectedError[incompatible-call]: string [1] is incompatible with number
+      sagaMiddlewareFactory<C>({ context: { test: "ops..." } });
+    });
+
+    it("must raises an error when passed an unrecognized field", () => {
+      // $FlowExpectedError[prop-missing]: `anyFields` is missing in  `SagaMiddlewareOptions`
+      sagaMiddlewareFactory({ anyFields: "ops" });
+    });
+
+    it("must raises an error when logger type invalid", () => {
+      // $FlowExpectedError[incompatible-call]: logger parameter should be Logger function
+      sagaMiddlewareFactory({ logger: "logger" });
+    });
+
+    it("must raises an error when onError type invalid", () => {
+      // $FlowExpectedError[incompatible-call]: onError parameter should be function
+      sagaMiddlewareFactory({ onError: "error" });
+
+      // $FlowExpectedError[incompatible-call]: Number incompatible Error
+      sagaMiddlewareFactory({ onError: (error: number) => {} });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_delay.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_delay.js
new file mode 100644
index 0000000000..52f6298549
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_delay.js
@@ -0,0 +1,38 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { delay } from "redux-saga/effects";
+
+describe("delay effect", () => {
+  describe("delay(number)", () => {
+    it("must passes when used properly", () => {
+      const callEffect = delay(1);
+
+      (callEffect.type: "CALL");
+      (callEffect.payload.context: null);
+      (callEffect.payload.fn: Function);
+      (callEffect.payload.args[0]: number);
+    });
+
+    it("must raises an error when pass multiple arguments", () => {
+      // $FlowExpectedError[incompatible-call]: No more than 1 argument is expected by function type
+      delay(1, 2, 3);
+    });
+
+    it("must raises an error when first argument isn't number", () => {
+      // $FlowExpectedError[incompatible-call]: string incompatible number
+      delay("1");
+    });
+  });
+
+  describe("delay(ms, [val])", () => {
+    it("must passes when used properly", () => {
+      const callEffect = delay(1, "returnValue");
+
+      (callEffect.type: "CALL");
+      (callEffect.payload.context: null);
+      (callEffect.payload.fn: Function);
+      (callEffect.payload.args[0]: number);
+      (callEffect.payload.args[1]: string);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_detach.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_detach.js
new file mode 100644
index 0000000000..fe5756a59c
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_detach.js
@@ -0,0 +1,22 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { detach, type ForkEffect } from "redux-saga";
+import { fork } from "redux-saga/effects";
+
+describe("detach(ForkEffect): ForkEffect*", () => {
+  const simpleForkEffect = fork(() => true);
+
+  it("must return detached ForkEffect", () => {
+    const detachedForkEffect = detach(simpleForkEffect);
+
+    // $FlowExpectedError[prop-missing]
+    (simpleForkEffect.payload.detached: true);
+
+    (detachedForkEffect.payload.detached: true);
+  });
+
+  it("must raises an error when first argument isn't ForkEffect", () => {
+    // $FlowExpectedError[prop-missing]
+    detach({ type: "FORK" });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_eventChannel.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_eventChannel.js
new file mode 100644
index 0000000000..999703a516
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_eventChannel.js
@@ -0,0 +1,77 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { eventChannel, buffers, type TEnd, type Subscribe } from "redux-saga";
+
+describe("eventChannel", () => {
+  const SimpleUnSubscribeFn = () => {};
+  const simpleSubscribeFn = () => {
+    return SimpleUnSubscribeFn;
+  };
+
+  it("returned Channel must be read only object", () => {
+    const ch = eventChannel(simpleSubscribeFn);
+
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.close = "hi belarus";
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.take = "hi belarus";
+    // $FlowExpectedError[cannot-write] - read-only
+    ch.flush = "hi belarus";
+  });
+
+  it("returned Channel must be exact type", () => {
+    const ch = eventChannel(simpleSubscribeFn);
+    // $FlowExpectedError[prop-missing]- exact type
+    ch.anyOtherProp = "anyValue";
+  });
+
+  it("must passes when used properly", () => {
+    type BASE_TYPE = {| +isActive: boolean |};
+
+    declare var subscribeFn: Subscribe<BASE_TYPE>;
+
+    const ch = eventChannel(subscribeFn, buffers.none());
+
+    (ch.close(): void);
+
+    const cbTake = (a: BASE_TYPE | TEnd) => {};
+    (ch.take(cbTake): void);
+
+    const cbFlush = (a: Array<BASE_TYPE> | TEnd) => {};
+    (ch.flush(cbFlush): void);
+  });
+
+  it("must raises an error when passed incompatible types", () => {
+    type T = string;
+
+    declare var subscribeFn: Subscribe<T>;
+
+    const ch = eventChannel(subscribeFn, buffers.none());
+
+    const cbTake = (a: number | TEnd) => {};
+    // $FlowExpectedError[incompatible-call]
+    (ch.take(cbTake): void);
+
+    const cbFlush = (a: Array<boolean> | TEnd) => {};
+    // $FlowExpectedError[incompatible-call]
+    (ch.flush(cbFlush): void);
+  });
+
+  it("must raises an error when call 'take' without args", () => {
+    declare var subscribeFn: Subscribe<string>;
+
+    const ch = eventChannel(subscribeFn, buffers.none());
+
+    // $FlowExpectedError[incompatible-call]
+    ch.take();
+  });
+
+  it("must raises an error when call 'flush' without args", () => {
+    declare var subscribeFn: Subscribe<string>;
+
+    const ch = eventChannel(subscribeFn, buffers.none());
+
+    // $FlowExpectedError[incompatible-call]
+    ch.flush();
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_flush.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_flush.js
new file mode 100644
index 0000000000..ee174d12e6
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_flush.js
@@ -0,0 +1,65 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import {
+  channel,
+  eventChannel,
+  multicastChannel,
+  stdChannel,
+} from "redux-saga";
+import { flush } from "redux-saga/effects";
+
+describe("flush effect", () => {
+  describe("structure", () => {
+    const c = flush(channel());
+
+    it('type must be equal "FLUSH"', () => {
+      (c.type: "FLUSH");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("flush(channel)", () => {
+    it("must passes when pass Channel", () => {
+      const myChannel = channel();
+
+      flush(myChannel);
+    });
+
+    it("must passes when pass EventChannel", () => {
+      const myEventChannel = eventChannel(emitter => {
+        emitter("test");
+
+        return () => {};
+      });
+
+      flush(myEventChannel);
+    });
+
+    it("must raises an error when pass MulticastChannel", () => {
+      // $FlowExpectedError[prop-missing]: MulticastChannel haven"t a flush property
+      flush(multicastChannel());
+
+      // $FlowExpectedError[prop-missing]: MulticastChannel haven"t a flush property
+      flush(stdChannel());
+    });
+
+    it("must raises an error when passed invalid arguments", () => {
+      // $FlowExpectedError[incompatible-call]: Too few arguments
+      flush();
+
+      // $FlowExpectedError[prop-missing]: Only accept Channels
+      flush(42);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_fork.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_fork.js
new file mode 100644
index 0000000000..a0bf7a84c8
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_fork.js
@@ -0,0 +1,446 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { fork } from "redux-saga/effects";
+
+describe("fork effect", () => {
+  describe("structure", () => {
+    const c = fork(() => {});
+
+    it('type must be equal "FORK"', () => {
+      (c.type: "FORK");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("fork(fn, ...args)", () => {
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const c0 = fork(nfn0);
+    const c1 = fork(nfn1, "1");
+    const c2 = fork(nfn2, "1", 2);
+    const c3 = fork(nfn3, "1", 2, true);
+    const c4 = fork(nfn4, "1", 2, true, "4");
+    const c5 = fork(nfn5, "1", 2, true, "4", 5);
+    const c6 = fork(nfn6, "1", 2, true, "4", 5, false);
+    const c7 = fork(nfn7, "1", 2, true, "4", 5, false, "7");
+    const c8 = fork(nfn8, "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        fork(nfn6, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        fork(nfn1, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof nfn1);
+        (c2.payload.fn: typeof nfn2);
+        (c3.payload.fn: typeof nfn3);
+        (c4.payload.fn: typeof nfn4);
+        (c5.payload.fn: typeof nfn5);
+        (c6.payload.fn: typeof nfn6);
+        (c7.payload.fn: typeof nfn7);
+        (c8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must haven't context", () => {
+        (c1.payload.context: null);
+        (c2.payload.context: null);
+        (c3.payload.context: null);
+        (c4.payload.context: null);
+        (c5.payload.context: null);
+        (c6.payload.context: null);
+        (c7.payload.context: null);
+        (c8.payload.context: null);
+      });
+
+      it("must raises an error when lead context to Object", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: {...});
+      });
+    });
+  });
+
+  describe("fork([context, fn], ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const f0 = fork([context, nfn0]);
+    const f1 = fork([context, nfn1], "1");
+    const f2 = fork([context, nfn2], "1", 2);
+    const f3 = fork([context, nfn3], "1", 2, true);
+    const f4 = fork([context, nfn4], "1", 2, true, "4");
+    const f5 = fork([context, nfn5], "1", 2, true, "4", 5);
+    const f6 = fork([context, nfn6], "1", 2, true, "4", 5, false);
+    const f7 = fork([context, nfn7], "1", 2, true, "4", 5, false, "7");
+    const f8 = fork([context, nfn8], "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (f0.payload.args: []);
+        (f1.payload.args: [string]);
+        (f2.payload.args: [string, number]);
+        (f3.payload.args: [string, number, boolean]);
+        (f4.payload.args: [string, number, boolean, string]);
+        (f5.payload.args: [string, number, boolean, string, number]);
+        (f6.payload.args: [string, number, boolean, string, number, boolean]);
+        (f7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (f8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (f1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        fork([context, nfn6], "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        fork([context, nfn1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (f1.payload.fn: typeof nfn1);
+        (f2.payload.fn: typeof nfn2);
+        (f3.payload.fn: typeof nfn3);
+        (f4.payload.fn: typeof nfn4);
+        (f5.payload.fn: typeof nfn5);
+        (f6.payload.fn: typeof nfn6);
+        (f7.payload.fn: typeof nfn7);
+        (f8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (f1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (f1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (f1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (f4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (f6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (f1.payload.context: typeof context);
+        (f2.payload.context: typeof context);
+        (f3.payload.context: typeof context);
+        (f4.payload.context: typeof context);
+        (f5.payload.context: typeof context);
+        (f6.payload.context: typeof context);
+        (f7.payload.context: typeof context);
+        (f8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (f1.payload.context: null);
+      });
+    });
+  });
+
+  describe("fork({context, fn}, ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const c0 = fork({ context, fn: nfn0 });
+    const c1 = fork({ context, fn: nfn1 }, "1");
+    const c2 = fork({ context, fn: nfn2 }, "1", 2);
+    const c3 = fork({ context, fn: nfn3 }, "1", 2, true);
+    const c4 = fork({ context, fn: nfn4 }, "1", 2, true, "4");
+    const c5 = fork({ context, fn: nfn5 }, "1", 2, true, "4", 5);
+    const c6 = fork({ context, fn: nfn6 }, "1", 2, true, "4", 5, false);
+    const c7 = fork({ context, fn: nfn7 }, "1", 2, true, "4", 5, false, "7");
+    const c8 = fork({ context, fn: nfn8 }, "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        fork({ context, fn: nfn6 }, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        fork({ context, fn: nfn1 }, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof nfn1);
+        (c2.payload.fn: typeof nfn2);
+        (c3.payload.fn: typeof nfn3);
+        (c4.payload.fn: typeof nfn4);
+        (c5.payload.fn: typeof nfn5);
+        (c6.payload.fn: typeof nfn6);
+        (c7.payload.fn: typeof nfn7);
+        (c8.payload.fn: typeof nfn8);
+      });
+
+      it("must actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (c1.payload.context: typeof context);
+        (c2.payload.context: typeof context);
+        (c3.payload.context: typeof context);
+        (c4.payload.context: typeof context);
+        (c5.payload.context: typeof context);
+        (c6.payload.context: typeof context);
+        (c7.payload.context: typeof context);
+        (c8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: null);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_getContext.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_getContext.js
new file mode 100644
index 0000000000..0504e05e90
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_getContext.js
@@ -0,0 +1,38 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { getContext } from "redux-saga/effects";
+
+describe("getContext(prop)", () => {
+  describe("structure", () => {
+    const prop = "TEST";
+    const c = getContext(prop);
+
+    it("payload must be equal prop argument", () => {
+      (c.payload: typeof prop);
+    });
+
+    it('type must be equal "GET_CONTEXT"', () => {
+      (c.type: "GET_CONTEXT");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  it("must ruses an error when first argument isn't string", () => {
+    // $FlowExpectedError[incompatible-call] argument required
+    getContext();
+
+    // $FlowExpectedError[incompatible-call] object literal is incompatible with string
+    getContext({});
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_high-level-api-takes.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_high-level-api-takes.js
new file mode 100644
index 0000000000..a2a89c0bd5
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_high-level-api-takes.js
@@ -0,0 +1,229 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { channel } from "redux-saga";
+import { takeEvery, takeLatest, takeLeading } from "redux-saga/effects";
+
+const topLevelTakesApi = [takeEvery, takeLatest, takeLeading];
+
+for (const takeEffect of topLevelTakesApi) {
+  describe("top level takes effect", () => {
+    describe("structure", () => {
+      const c = takeEffect("ACTION_NAME", () => {});
+
+      it('type must be equal "FORK"', () => {
+        (c.type: "FORK");
+      });
+
+      it("returned object must be read only", () => {
+        // $FlowExpectedError[cannot-write]: read-only  property
+        c.type = "anyType";
+        // $FlowExpectedError[cannot-write]: read-only  property
+        c.payload = {};
+      });
+
+      it("returned object must be exact", () => {
+        // $FlowExpectedError[prop-missing]: exact type
+        c.abc = 69;
+      });
+    });
+
+    function* s0(): any {
+      return 1;
+    }
+    function* s1(a: string): any {
+      return 1;
+    }
+    function* s2(a: string, b: number): any {
+      return 1;
+    }
+    function* s3(a: string, b: number, c: string): any {
+      return 1;
+    }
+    function* s4(a: string, b: number, c: string, d: number): any {
+      return 1;
+    }
+    function* s5(a: string, b: number, c: string, d: number, e: string): any {
+      return 1;
+    }
+    function* s6(a: string, b: number, c: string, d: number, e: string, f: number): any {
+      return 1;
+    }
+    function* s7(a: string, b: number, c: string, d: number, e: string, f: number, g: string): any {
+      return 1;
+    }
+    function* s8(
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      h: number
+    ): any {
+      return 1;
+    }
+
+    describe("takeXXX(pattern)", () => {
+      const e0 = takeEffect("ACTION_NAME", s0);
+      const e1 = takeEffect("ACTION_NAME", s1, "1");
+      const e2 = takeEffect("ACTION_NAME", s2, "1", 2);
+      const e3 = takeEffect("ACTION_NAME", s3, "1", 2, "3");
+      const e4 = takeEffect("ACTION_NAME", s4, "1", 2, "3", 4);
+      const e5 = takeEffect("ACTION_NAME", s5, "1", 2, "3", 4, "5");
+      const e6 = takeEffect("ACTION_NAME", s6, "1", 2, "3", 4, "5", 6);
+      const e7 = takeEffect("ACTION_NAME", s7, "1", 2, "3", 4, "5", 6, "7");
+      const e8 = takeEffect("ACTION_NAME", s8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+      it("must haven't context", () => {
+        (e0.payload.context: null);
+        (e1.payload.context: null);
+        (e2.payload.context: null);
+        (e3.payload.context: null);
+        (e4.payload.context: null);
+        (e5.payload.context: null);
+        (e6.payload.context: null);
+        (e7.payload.context: null);
+        (e8.payload.context: null);
+      });
+
+      describe("arguments tests", () => {
+        it("must passes when used properly", () => {
+          (e0.payload.args: [string, typeof s0]);
+          (e1.payload.args: [string, typeof s1, string]);
+          (e2.payload.args: [string, typeof s2, string, number]);
+          (e3.payload.args: [string, typeof s3, string, number, string]);
+          (e4.payload.args: [string, typeof s4, string, number, string, number]);
+          (e5.payload.args: [string, typeof s5, string, number, string, number, string]);
+          (e6.payload.args: [string, typeof s6, string, number, string, number, string, number]);
+          (e7.payload.args: [
+            string,
+            typeof s7,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number,
+            string
+          ]);
+          (e8.payload.args: [
+            string,
+            typeof s8,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number
+          ]);
+        });
+
+        it("must raises an error when passed number but need string", () => {
+          // $FlowExpectedError[incompatible-cast]
+          // $FlowExpectedError[invalid-tuple-arity]: First parameter is a string, not a number
+          (e1.payload.args: [number]);
+        });
+
+        it("must raises an error when passed too few arguments", () => {
+          // $FlowExpectedError[cannot-resolve-name]: Too few arguments
+          fork("ACTION_NAME", s6, "1", 2, true, "4");
+        });
+
+        it("must raises an error when passed wrong argument types", () => {
+          // $FlowExpectedError[cannot-resolve-name]: Wrong argument types
+          fork("ACTION_NAME", s1, 1);
+        });
+      });
+    });
+
+    describe("takeXXX(channel)", () => {
+      const myChannel = channel();
+
+      const e0 = takeEffect(myChannel, s0);
+      const e1 = takeEffect(myChannel, s1, "1");
+      const e2 = takeEffect(myChannel, s2, "1", 2);
+      const e3 = takeEffect(myChannel, s3, "1", 2, "3");
+      const e4 = takeEffect(myChannel, s4, "1", 2, "3", 4);
+      const e5 = takeEffect(myChannel, s5, "1", 2, "3", 4, "5");
+      const e6 = takeEffect(myChannel, s6, "1", 2, "3", 4, "5", 6);
+      const e7 = takeEffect(myChannel, s7, "1", 2, "3", 4, "5", 6, "7");
+      const e8 = takeEffect(myChannel, s8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+      it("must haven't context", () => {
+        (e0.payload.context: null);
+        (e1.payload.context: null);
+        (e2.payload.context: null);
+        (e3.payload.context: null);
+        (e4.payload.context: null);
+        (e5.payload.context: null);
+        (e6.payload.context: null);
+        (e7.payload.context: null);
+        (e8.payload.context: null);
+      });
+
+      describe("arguments tests", () => {
+        it("must passes when used properly", () => {
+          (e0.payload.args: [typeof myChannel, typeof s0]);
+          (e1.payload.args: [typeof myChannel, typeof s1, string]);
+          (e2.payload.args: [typeof myChannel, typeof s2, string, number]);
+          (e3.payload.args: [typeof myChannel, typeof s3, string, number, string]);
+          (e4.payload.args: [typeof myChannel, typeof s4, string, number, string, number]);
+          (e5.payload.args: [typeof myChannel, typeof s5, string, number, string, number, string]);
+          (e6.payload.args: [
+            typeof myChannel,
+            typeof s6,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number
+          ]);
+          (e7.payload.args: [
+            typeof myChannel,
+            typeof s7,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number,
+            string
+          ]);
+          (e8.payload.args: [
+            typeof myChannel,
+            typeof s8,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number,
+            string,
+            number
+          ]);
+        });
+
+        it("must raises an error when passed number but need string", () => {
+          // $FlowExpectedError[incompatible-cast]
+          // $FlowExpectedError[invalid-tuple-arity]
+          // $FlowExpectedError[prop-missing]: First parameter is a string, not a number
+          (e1.payload.args: [number]);
+        });
+
+        it("must raises an error when passed too few arguments", () => {
+          // $FlowExpectedError[cannot-resolve-name]: Too few arguments
+          fork(myChannel, s6, "1", 2, true, "4");
+        });
+
+        it("must raises an error when passed wrong argument types", () => {
+          // $FlowExpectedError[cannot-resolve-name]: Wrong argument types
+          fork(myChannel, s1, 1);
+        });
+      });
+    });
+  });
+}
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_isEnd.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_isEnd.js
new file mode 100644
index 0000000000..69b151f96d
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_isEnd.js
@@ -0,0 +1,16 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { isEnd, END } from "redux-saga";
+
+describe("isEnd(any) => boolean", () => {
+  it("must return true when first argument is END object", () => {
+    (isEnd(END): true);
+  });
+
+  it("must return false when first argument isn't END object", () => {
+    (isEnd(): false);
+    (isEnd({}): false);
+    (isEnd(null): false);
+    (isEnd(undefined): false);
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_join.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_join.js
new file mode 100644
index 0000000000..1216866dd0
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_join.js
@@ -0,0 +1,39 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { type Task } from "redux-saga";
+import { join } from "redux-saga/effects";
+
+describe("join effect", () => {
+  describe("structure", () => {
+    declare var t: Task<number>;
+    const c = join(t);
+
+    it('type must be equal "JOIN"', () => {
+      (c.type: "JOIN");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  it("must passes when used properly", () => {
+    declare var task1: Task<string>;
+    declare var task2: Task<number>;
+
+    const arrTasks = [task1, task2];
+    const j1 = join(task1);
+    const j2 = join(arrTasks);
+
+    (j1.payload: typeof task1);
+    (j2.payload: typeof arrTasks);
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_put.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_put.js
new file mode 100644
index 0000000000..06f6ebc7ba
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_put.js
@@ -0,0 +1,74 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { channel, eventChannel, multicastChannel } from "redux-saga";
+import { put } from "redux-saga/effects";
+
+describe("put effect", () => {
+  describe("structure", () => {
+    const c = put({});
+
+    it('type must be equal "PUT"', () => {
+      (c.type: "PUT");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("put(action)", () => {
+    it("must passes when used properly", () => {
+      put({ type: "test" });
+
+      const put1 = put({ type: "TEST", payload: "hi" });
+
+      (put1.payload.action.payload: string);
+    });
+
+    it(`must raises an error when action isn't object`, () => {
+      // $FlowExpectedError[incompatible-call]: Can only be called with objects
+      put("FOO");
+    });
+  });
+
+  describe("put(channel, action)", () => {
+    it("must passes when used properly Channel and Action", () => {
+      const myChannel = channel();
+      const myAction = { type: "test" };
+      const p = put(myChannel, myAction);
+
+      (p.payload.channel: typeof myChannel);
+      (p.payload.action: typeof myAction);
+    });
+
+    it("must raises an error when pass EventChannel", () => {
+      const myEventChannel = eventChannel(emitter => () => {});
+      const myAction = { type: "test" };
+
+      // $FlowExpectedError[incompatible-call]: event channel hasn"t a put() property
+      put(myEventChannel, myAction);
+    });
+
+    it("must passes when used properly MulticastChannel and Action", () => {
+      const myMultiChannel = multicastChannel();
+      const myAction = { type: "test" };
+      const p = put(myMultiChannel, myAction);
+
+      (p.payload.channel: typeof myMultiChannel);
+      (p.payload.action: typeof myAction);
+    });
+
+    it("must rises an error when channel is null", () => {
+      // $FlowExpectedError[incompatible-call]: No null as channel accepted
+      put(null, { type: "TEST" });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_putResolve.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_putResolve.js
new file mode 100644
index 0000000000..f67668c6ba
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_putResolve.js
@@ -0,0 +1,75 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { channel, eventChannel, multicastChannel } from "redux-saga";
+import { putResolve } from "redux-saga/effects";
+
+describe("putResolve effect", () => {
+  describe("structure", () => {
+    const c = putResolve({});
+
+    it('type must be equal "PUT"', () => {
+      (c.type: "PUT");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("putResolve(action)", () => {
+    it("must passes when used properly", () => {
+      putResolve({ type: "test" });
+
+      const put1 = putResolve({ type: "TEST", payload: "hi" });
+
+      (put1.payload.action.payload: string);
+      (put1.payload.resolve: true);
+    });
+
+    it(`must raises an error when action isn't object`, () => {
+      // $FlowExpectedError[incompatible-call]: Can only be called with objects
+      putResolve("FOO");
+    });
+  });
+
+  describe("putResolve(channel, action)", () => {
+    it("must passes when used properly Channel and Action", () => {
+      const myChannel = channel();
+      const myAction = { type: "test" };
+      const p = putResolve(myChannel, myAction);
+
+      (p.payload.channel: typeof myChannel);
+      (p.payload.action: typeof myAction);
+    });
+
+    it("must raises an error when pass EventChannel", () => {
+      const myEventChannel = eventChannel(emitter => () => {});
+      const myAction = { type: "test" };
+
+      // $FlowExpectedError[incompatible-call]: event channel hasn"t a put() property
+      putResolve(myEventChannel, myAction);
+    });
+
+    it("must passes when used properly MulticastChannel and Action", () => {
+      const myMultiChannel = multicastChannel();
+      const myAction = { type: "test" };
+      const p = putResolve(myMultiChannel, myAction);
+
+      (p.payload.channel: typeof myMultiChannel);
+      (p.payload.action: typeof myAction);
+    });
+
+    it("must rises an error when channel is null", () => {
+      // $FlowExpectedError[incompatible-call]: No null as channel accepted
+      putResolve(null, { type: "TEST" });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_race.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_race.js
new file mode 100644
index 0000000000..e8579873d9
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_race.js
@@ -0,0 +1,56 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { race, take, put } from "redux-saga/effects";
+
+describe("race effect", () => {
+  describe("structure", () => {
+    const c = race([]);
+
+    it('type must be equal "RACE"', () => {
+      (c.type: "RACE");
+    });
+
+    it('combinator must be equal true', () => {
+      (c.combinator: true);
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("race(Array<Effect>)", () => {
+    it("should recognize the payload data structure", () => {
+      const e1 = take("LOG_OUT");
+      const e2 = put({ type: "FETCH_USER" });
+
+      const r = race([e1, e2]);
+
+      (r.payload[0]: typeof e1);
+      (r.payload[1]: typeof e2);
+    });
+  });
+
+  describe("race({[key: string]: Effect})", () => {
+    it("should recognize the payload data structure", () => {
+      const e1 = take("LOG_OUT");
+      const e2 = put({ type: "FETCH_USER" });
+
+      const r = race({
+        isLogOut: e1,
+        fetchUser: e2
+      });
+
+      (r.payload.isLogOut: typeof e1);
+      (r.payload.fetchUser: typeof e2);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_retry.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_retry.js
new file mode 100644
index 0000000000..32eb222632
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_retry.js
@@ -0,0 +1,169 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { retry } from "redux-saga/effects";
+
+describe("retry effect", () => {
+  describe("structure", () => {
+    const c = retry(0, 0, () => {});
+
+    it('type must be equal "CALL"', () => {
+      (c.type: "CALL");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("retry(maxTries, delay, fn, ...args)", () => {
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const [maxTries, delayMs] = [0, 0];
+
+    const c0 = retry(maxTries, delayMs, nfn0);
+    const c1 = retry(maxTries, delayMs, nfn1, "1");
+    const c2 = retry(maxTries, delayMs, nfn2, "1", 2);
+    const c3 = retry(maxTries, delayMs, nfn3, "1", 2, true);
+    const c4 = retry(maxTries, delayMs, nfn4, "1", 2, true, "4");
+    const c5 = retry(maxTries, delayMs, nfn5, "1", 2, true, "4", 5);
+    const c6 = retry(maxTries, delayMs, nfn6, "1", 2, true, "4", 5, false);
+    const c7 = retry(maxTries, delayMs, nfn6, "1", 2, true, "4", 5, false, "7");
+    const c8 = retry(maxTries, delayMs, nfn6, "1", 2, true, "4", 5, false, "8", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: [number, number, typeof nfn0]);
+        (c1.payload.args: [number, number, typeof nfn1, string]);
+        (c2.payload.args: [number, number, typeof nfn2, string, number]);
+        (c3.payload.args: [number, number, typeof nfn3, string, number, boolean]);
+        (c4.payload.args: [number, number, typeof nfn4, string, number, boolean, string]);
+        (c5.payload.args: [number, number, typeof nfn5, string, number, boolean, string, number]);
+        (c6.payload.args: [
+          number,
+          number,
+          typeof nfn6,
+          string,
+          number,
+          boolean,
+          string,
+          number,
+          boolean
+        ]);
+        (c7.payload.args: [
+          number,
+          number,
+          typeof nfn7,
+          string,
+          number,
+          boolean,
+          string,
+          number,
+          boolean,
+          string
+        ]);
+        (c8.payload.args: [
+          number,
+          number,
+          typeof nfn8,
+          string,
+          number,
+          boolean,
+          string,
+          number,
+          boolean,
+          string,
+          number
+        ]);
+      });
+
+      it("must raises an error when passed number but need number", () => {
+        // $FlowExpectedError[incompatible-cast]
+        // $FlowExpectedError[invalid-tuple-arity]: First parameter is a number, not a string
+        (c1.payload.args: [string]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        retry(maxTries, delayMs, nfn6, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        retry(maxTries, delayMs, nfn1, 1);
+      });
+    });
+
+    it("must passes when used properly", () => {
+      (c1.payload.fn: Function);
+      (c2.payload.fn: Function);
+      (c3.payload.fn: Function);
+      (c4.payload.fn: Function);
+      (c5.payload.fn: Function);
+      (c6.payload.fn: Function);
+      (c7.payload.fn: Function);
+      (c8.payload.fn: Function);
+    });
+
+    it("must haven't context", () => {
+      (c1.payload.context: null);
+      (c2.payload.context: null);
+      (c3.payload.context: null);
+      (c4.payload.context: null);
+      (c5.payload.context: null);
+      (c6.payload.context: null);
+      (c7.payload.context: null);
+      (c8.payload.context: null);
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_runSaga.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_runSaga.js
new file mode 100644
index 0000000000..8f9ad9a1a7
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_runSaga.js
@@ -0,0 +1,109 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import {
+  runSaga,
+  stdChannel,
+  type Saga,
+  type Task,
+  type SagaMonitor,
+  type MulticastChannel
+} from "redux-saga";
+
+describe("runSaga", () => {
+  function* s0(): Saga<number> {
+    return 1;
+  }
+  function* s1(a: string): Saga<number> {
+    return 1;
+  }
+  function* s2(a: string, b: number): Saga<number> {
+    return 1;
+  }
+  function* s3(a: string, b: number, c: string): Saga<number> {
+    return 1;
+  }
+  function* s4(a: string, b: number, c: string, d: number): Saga<number> {
+    return 1;
+  }
+  function* s5(a: string, b: number, c: string, d: number, e: string): Saga<number> {
+    return 1;
+  }
+  function* s6(a: string, b: number, c: string, d: number, e: string, f: number): Saga<number> {
+    return 1;
+  }
+  function* s7(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string
+  ): Saga<number> {
+    return 1;
+  }
+  function* s8(
+    a: string,
+    b: number,
+    c: string,
+    d: number,
+    e: string,
+    f: number,
+    g: string,
+    h: number
+  ): Saga<number> {
+    return 1;
+  }
+
+  describe("test arguments", () => {
+    it("must passes when used properly", () => {
+      (runSaga({}, s0): Task<number>);
+      (runSaga({}, s1, "1"): Task<number>);
+      (runSaga({}, s2, "1", 2): Task<number>);
+      (runSaga({}, s3, "1", 2, "3"): Task<number>);
+      (runSaga({}, s4, "1", 2, "3", 4): Task<number>);
+      (runSaga({}, s5, "1", 2, "3", 4, "5"): Task<number>);
+      (runSaga({}, s6, "1", 2, "3", 4, "5", 6): Task<number>);
+      (runSaga({}, s7, "1", 2, "3", 4, "5", 6, "7"): Task<number>);
+      (runSaga({}, s8, "1", 2, "3", 4, "5", 6, "7", 8): Task<number>);
+    });
+
+    it("must raises an error when passed invalid arguments", () => {
+      // $FlowExpectedError[incompatible-call]: too few args
+      (runSaga({}, s6, "1", 2): Task<number>);
+
+      // $FlowExpectedError[incompatible-call]: wrong argument type
+      (runSaga({}, s1, 1): Task<number>);
+    });
+
+    it("must raises an error", () => {
+      // $FlowExpectedError[incompatible-call]: wrong return type
+      (runSaga({}, s1, 1): Task<string>);
+    });
+  });
+
+  describe("runSaga(RunSagaOptions)", () => {
+    const channel: MulticastChannel<number> = stdChannel();
+    const sagaMonitor: SagaMonitor = {
+      effectTriggered: _ => {},
+      effectResolved: (_, _2) => {},
+      effectRejected: (_, _2) => {},
+      effectCancelled: _ => {},
+      actionDispatched: _ => {}
+    };
+
+    const dispatch = output => {};
+    const getState = () => ({});
+    const logger = level => {};
+
+    runSaga({ dispatch }, s0);
+    runSaga({ getState }, s0);
+    runSaga({ sagaMonitor }, s0);
+    runSaga({ logger }, s0);
+
+    // $FlowExpectedError[incompatible-call]: error level is a string enum
+    runSaga({ logger: (level: number) => {} }, s0);
+
+    runSaga({ channel }, s1, "");
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_select.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_select.js
new file mode 100644
index 0000000000..516ee2da15
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_select.js
@@ -0,0 +1,115 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { select } from "redux-saga/effects";
+
+describe("select effect", () => {
+  describe("structure", () => {
+    const c = select(() => {});
+
+    it('type must be equal "SELECT"', () => {
+      (c.type: "SELECT");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("select(selector, ...args)", () => {
+    const s0 = (state: Object): Object => ({});
+    const s1 = (state: Object, a: string) => ({});
+    const s2 = (state: Object, a: string, b: number) => ({});
+    const s3 = (state: Object, a: string, b: number, c: string) => ({});
+    const s4 = (state: Object, a: string, b: number, c: string, d: number) => ({});
+    const s5 = (state: Object, a: string, b: number, c: string, d: number, e: string) => ({});
+    const s6 = (
+      state: Object,
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number
+    ) => ({});
+    const s7 = (
+      state: Object,
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string
+    ) => ({});
+    const s8 = (
+      state: Object,
+      a: string,
+      b: number,
+      c: string,
+      d: number,
+      e: string,
+      f: number,
+      g: string,
+      h: number
+    ) => ({});
+
+    const eVoid = select();
+    const e0 = select(s0);
+    const e1 = select(s1, "1");
+    const e2 = select(s2, "1", 2);
+    const e3 = select(s3, "1", 2, "3");
+    const e4 = select(s4, "1", 2, "3", 4);
+    const e5 = select(s5, "1", 2, "3", 4, "5");
+    const e6 = select(s6, "1", 2, "3", 4, "5", 6);
+    const e7 = select(s7, "1", 2, "3", 4, "5", 6, "7");
+    const e8 = select(s8, "1", 2, "3", 4, "5", 6, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (eVoid.payload.args: []);
+        (e0.payload.args: []);
+        (e1.payload.args: [string]);
+        (e2.payload.args: [string, number]);
+        (e3.payload.args: [string, number, string]);
+        (e4.payload.args: [string, number, string, number]);
+        (e5.payload.args: [string, number, string, number, string]);
+        (e6.payload.args: [string, number, string, number, string, number]);
+        (e7.payload.args: [string, number, string, number, string, number, string]);
+        (e8.payload.args: [string, number, string, number, string, number, string, number]);
+      });
+
+      it("must raises an error when passed boolean but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: second args is not a boolean
+        (e3.payload.args: [string, boolean, string]);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (eVoid.payload.selector: void);
+        (e0.payload.selector: typeof s0);
+        (e1.payload.selector: typeof s1);
+        (e2.payload.selector: typeof s2);
+        (e3.payload.selector: typeof s3);
+        (e4.payload.selector: typeof s4);
+        (e5.payload.selector: typeof s5);
+        (e6.payload.selector: typeof s6);
+        (e7.payload.selector: typeof s7);
+        (e8.payload.selector: typeof s8);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: args.a should actually be a string
+        (e1.payload.selector: (state: Object, a: number) => Object);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_setContext.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_setContext.js
new file mode 100644
index 0000000000..b7e5fce714
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_setContext.js
@@ -0,0 +1,38 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { setContext } from "redux-saga/effects";
+
+describe("setContext(prop)", () => {
+  describe("structure", () => {
+    const props = {};
+    const c = setContext(props);
+
+    it("payload must be equal props argument", () => {
+      (c.payload: typeof props);
+    });
+
+    it('type must be equal "SET_CONTEXT"', () => {
+      (c.type: "SET_CONTEXT");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  it("must ruses an error when first argument isn't object", () => {
+    // $FlowExpectedError[incompatible-call] argument required
+    setContext();
+
+    // $FlowExpectedError[incompatible-call] object literal is incompatible with object
+    setContext("TEST");
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_spawn.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_spawn.js
new file mode 100644
index 0000000000..50f5a5def5
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_spawn.js
@@ -0,0 +1,305 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { spawn } from "redux-saga/effects";
+
+describe("spawn effect", () => {
+  describe("structure", () => {
+    const c = spawn(() => {});
+
+    it('type must be equal "FORK"', () => {
+      (c.type: "FORK");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("spawn(fn, ...args)", () => {
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const c0 = spawn(nfn0);
+    const c1 = spawn(nfn1, "1");
+    const c2 = spawn(nfn2, "1", 2);
+    const c3 = spawn(nfn3, "1", 2, true);
+    const c4 = spawn(nfn4, "1", 2, true, "4");
+    const c5 = spawn(nfn5, "1", 2, true, "4", 5);
+    const c6 = spawn(nfn6, "1", 2, true, "4", 5, false);
+    const c7 = spawn(nfn7, "1", 2, true, "4", 5, false, "7");
+    const c8 = spawn(nfn8, "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: []);
+        (c1.payload.args: [string]);
+        (c2.payload.args: [string, number]);
+        (c3.payload.args: [string, number, boolean]);
+        (c4.payload.args: [string, number, boolean, string]);
+        (c5.payload.args: [string, number, boolean, string, number]);
+        (c6.payload.args: [string, number, boolean, string, number, boolean]);
+        (c7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (c8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (c1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        spawn(nfn6, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        spawn(nfn1, 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (c1.payload.fn: typeof nfn1);
+        (c2.payload.fn: typeof nfn2);
+        (c3.payload.fn: typeof nfn3);
+        (c4.payload.fn: typeof nfn4);
+        (c5.payload.fn: typeof nfn5);
+        (c6.payload.fn: typeof nfn6);
+        (c7.payload.fn: typeof nfn7);
+        (c8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (c1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (c1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (c4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (c6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must haven't context", () => {
+        (c1.payload.context: null);
+        (c2.payload.context: null);
+        (c3.payload.context: null);
+        (c4.payload.context: null);
+        (c5.payload.context: null);
+        (c6.payload.context: null);
+        (c7.payload.context: null);
+        (c8.payload.context: null);
+      });
+
+      it("must raises an error when lead context to Object", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (c1.payload.context: {...});
+      });
+    });
+  });
+
+  describe("spawn([context, fn], ...args)", () => {
+    const context = { some: "contextObject" };
+
+    function nfn0(): number {
+      return 1;
+    }
+    function nfn1(a: string): number {
+      return 1;
+    }
+    function nfn2(a: string, b: number): number {
+      return 1;
+    }
+    function nfn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function nfn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function nfn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function nfn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+    function nfn7(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string
+    ): number {
+      return 1;
+    }
+    function nfn8(
+      a: string,
+      b: number,
+      c: boolean,
+      d: string,
+      e: number,
+      f: boolean,
+      g: string,
+      h: number
+    ): number {
+      return 1;
+    }
+
+    const f0 = spawn([context, nfn0]);
+    const f1 = spawn([context, nfn1], "1");
+    const f2 = spawn([context, nfn2], "1", 2);
+    const f3 = spawn([context, nfn3], "1", 2, true);
+    const f4 = spawn([context, nfn4], "1", 2, true, "4");
+    const f5 = spawn([context, nfn5], "1", 2, true, "4", 5);
+    const f6 = spawn([context, nfn6], "1", 2, true, "4", 5, false);
+    const f7 = spawn([context, nfn7], "1", 2, true, "4", 5, false, "7");
+    const f8 = spawn([context, nfn8], "1", 2, true, "4", 5, false, "7", 8);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (f0.payload.args: []);
+        (f1.payload.args: [string]);
+        (f2.payload.args: [string, number]);
+        (f3.payload.args: [string, number, boolean]);
+        (f4.payload.args: [string, number, boolean, string]);
+        (f5.payload.args: [string, number, boolean, string, number]);
+        (f6.payload.args: [string, number, boolean, string, number, boolean]);
+        (f7.payload.args: [string, number, boolean, string, number, boolean, string]);
+        (f8.payload.args: [string, number, boolean, string, number, boolean, string, number]);
+      });
+
+      it("must raises an error when passed number but need string", () => {
+        // $FlowExpectedError[incompatible-cast]: First parameter is a string, not a number
+        (f1.payload.args: [number]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        spawn([context, nfn6], "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        spawn([context, nfn1], 1);
+      });
+    });
+
+    describe("function test", () => {
+      it("must passes when used properly", () => {
+        (f1.payload.fn: typeof nfn1);
+        (f2.payload.fn: typeof nfn2);
+        (f3.payload.fn: typeof nfn3);
+        (f4.payload.fn: typeof nfn4);
+        (f5.payload.fn: typeof nfn5);
+        (f6.payload.fn: typeof nfn6);
+        (f7.payload.fn: typeof nfn7);
+        (f8.payload.fn: typeof nfn8);
+      });
+
+      it("should actually fail, but apparently more parameter are fine", () => {
+        (f1.payload.fn: typeof nfn6);
+      });
+
+      it("must raises an error when Function return not string", () => {
+        // $FlowExpectedError[incompatible-cast]: fn returns a number not string
+        (f1.payload.fn: (a: boolean) => string);
+      });
+
+      it(`must raises an error when "a" argument isn't string`, () => {
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (f1.payload.fn: (a: boolean) => number);
+
+        // $FlowExpectedError[incompatible-cast]: 'a' is actually of type string
+        (f4.payload.fn: (a: number, b: number) => number);
+      });
+
+      it("must raises an error when less parameter are noticed", () => {
+        // $FlowExpectedError[incompatible-cast]: Less parameter are noticed
+        (f6.payload.fn: typeof nfn1);
+      });
+    });
+
+    describe("context tests", () => {
+      it("must have context", () => {
+        (f1.payload.context: typeof context);
+        (f2.payload.context: typeof context);
+        (f3.payload.context: typeof context);
+        (f4.payload.context: typeof context);
+        (f5.payload.context: typeof context);
+        (f6.payload.context: typeof context);
+        (f7.payload.context: typeof context);
+        (f8.payload.context: typeof context);
+      });
+
+      it("must raises an error when lead context to null", () => {
+        // $FlowExpectedError[incompatible-cast]
+        (f1.payload.context: null);
+      });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_take.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_take.js
new file mode 100644
index 0000000000..b447e7ed6a
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_take.js
@@ -0,0 +1,88 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import {
+  channel,
+  eventChannel,
+  multicastChannel,
+  stdChannel,
+} from "redux-saga";
+import { take } from "redux-saga/effects";
+
+describe("take effect", () => {
+  describe("structure", () => {
+    const c = take("ACTION_NAME");
+
+    it('type must be equal "TAKE"', () => {
+      (c.type: "TAKE");
+    });
+
+    it(`payload property must haven't "maybe" property`, () => {
+      // $FlowExpectedError[prop-missing]: property `maybe` is missing in type
+      (c.payload.maybe: true);
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("take()", () => {
+    it("must passes when call effect without any arguments", () => {
+      const t = take();
+
+      (t.payload.pattern: '*');
+    });
+  });
+
+  describe("take(pattern)", () => {
+    it("must passes when used properly", () => {
+      take(action => action.type === "foo");
+      take(action => action.type);
+      take([action => action.type === "foo", action => action.type === "foo"]);
+
+      take("ACTION_1");
+      take(["ACTION_1", "ACTION_2"]);
+    });
+
+    it("must raises an error when passed invalid pattern", () => {
+      // $FlowExpectedError[incompatible-call]: Only string patterns for arrays
+      take(["FOO", "BAR", 1]);
+    });
+  });
+
+  describe("take(channel)", () => {
+    it("must passes when pass Channel", () => {
+      const myChannel = channel();
+
+      take(myChannel);
+    });
+
+    it("must passes when pass EventChannel", () => {
+      const myEventChannel = eventChannel(emitter => {
+        emitter("test");
+
+        return () => {};
+      });
+
+      take(myEventChannel);
+    });
+
+    it("must passes when pass MulticastChannel", () => {
+      take(multicastChannel());
+      take(stdChannel());
+    });
+
+    it("must raises an error when passed invalid channel", () => {
+      // $FlowExpectedError[incompatible-call]: Channels must have take prop
+      take({ close: () => {}, put: msg => {} });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_takeMaybe.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_takeMaybe.js
new file mode 100644
index 0000000000..56985db5d2
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_takeMaybe.js
@@ -0,0 +1,90 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import {
+  channel,
+  eventChannel,
+  multicastChannel,
+  stdChannel,
+} from "redux-saga";
+import { takeMaybe } from "redux-saga/effects";
+
+describe("takeMaybe effect", () => {
+  describe("structure", () => {
+    const c = takeMaybe("ACTION_NAME");
+
+    it('type must be equal "TAKE"', () => {
+      (c.type: "TAKE");
+    });
+
+    it('payload property must have "maybe" property', () => {
+      (c.payload.maybe: true);
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("takeMaybe()", () => {
+    it("must passes when call effect without any arguments", () => {
+      const t = takeMaybe();
+
+      (t.payload.pattern: '*');
+    });
+  });
+
+  describe("takeMaybe(pattern)", () => {
+    it("must passes when used properly", () => {
+      takeMaybe(action => action.type === "foo");
+      takeMaybe(action => action.type);
+      takeMaybe([
+        action => action.type === "foo",
+        action => action.type === "foo",
+      ]);
+
+      takeMaybe("ACTION_1");
+      takeMaybe(["ACTION_1", "ACTION_2"]);
+    });
+
+    it("must raises an error when passed invalid pattern", () => {
+      // $FlowExpectedError[incompatible-call]: Only string patterns for arrays
+      takeMaybe(["FOO", "BAR", 1]);
+    });
+  });
+
+  describe("takeMaybe(channel)", () => {
+    it("must passes when pass Channel", () => {
+      const myChannel = channel();
+
+      takeMaybe(myChannel);
+    });
+
+    it("must passes when pass EventChannel", () => {
+      const myEventChannel = eventChannel(emitter => {
+        emitter("test");
+
+        return () => {};
+      });
+
+      takeMaybe(myEventChannel);
+    });
+
+    it("must passes when pass MulticastChannel", () => {
+      takeMaybe(multicastChannel());
+      takeMaybe(stdChannel());
+    });
+
+    it("must raises an error when passed invalid channel", () => {
+      // $FlowExpectedError[incompatible-call]: Channels must have take prop
+      takeMaybe({ close: () => {}, put: msg => {} });
+    });
+  });
+});
diff --git a/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_throttle.js b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_throttle.js
new file mode 100644
index 0000000000..8070a8eda7
--- /dev/null
+++ b/definitions/npm/redux-saga_v1.x.x/flow_v0.201.x-/test_redux-saga_1.x.x_throttle.js
@@ -0,0 +1,126 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import type { Pattern } from "redux-saga";
+import { throttle } from "redux-saga/effects";
+
+describe("throttle effect", () => {
+  describe("structure", () => {
+    const c = throttle(0, "pattern", () => {});
+
+    it('type must be equal "FORK"', () => {
+      (c.type: "FORK");
+    });
+
+    it("returned object must be read only", () => {
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.type = "anyType";
+      // $FlowExpectedError[cannot-write]: read-only  property
+      c.payload = {};
+    });
+
+    it("returned object must be exact", () => {
+      // $FlowExpectedError[prop-missing]: exact type
+      c.abc = 69;
+    });
+  });
+
+  describe("throttle(ms, pattern, saga, ...args)", () => {
+    function fn0(): number {
+      return 1;
+    }
+    function fn1(a: string): number {
+      return 1;
+    }
+    function fn2(a: string, b: number): number {
+      return 1;
+    }
+    function fn3(a: string, b: number, c: boolean): number {
+      return 1;
+    }
+    function fn4(a: string, b: number, c: boolean, d: string): number {
+      return 1;
+    }
+    function fn5(a: string, b: number, c: boolean, d: string, e: number): number {
+      return 1;
+    }
+    function fn6(a: string, b: number, c: boolean, d: string, e: number, f: boolean): number {
+      return 1;
+    }
+
+    const timeMs: number = 0;
+    const pattern: Pattern = "ACTION_NAME";
+
+    const c0 = throttle(timeMs, pattern, fn0);
+    const c1 = throttle(timeMs, pattern, fn1, "1");
+    const c2 = throttle(timeMs, pattern, fn2, "1", 2);
+    const c3 = throttle(timeMs, pattern, fn3, "1", 2, true);
+    const c4 = throttle(timeMs, pattern, fn4, "1", 2, true, "4");
+    const c5 = throttle(timeMs, pattern, fn5, "1", 2, true, "4", 5);
+    const c6 = throttle(timeMs, pattern, fn6, "1", 2, true, "4", 5, false);
+
+    describe("arguments tests", () => {
+      it("must passes when used properly", () => {
+        (c0.payload.args: [number, typeof pattern, typeof fn0]);
+        (c1.payload.args: [number, typeof pattern, typeof fn1, string]);
+        (c2.payload.args: [number, typeof pattern, typeof fn2, string, number]);
+        (c3.payload.args: [number, typeof pattern, typeof fn3, string, number, boolean]);
+        (c4.payload.args: [number, typeof pattern, typeof fn4, string, number, boolean, string]);
+        (c5.payload.args: [
+          number,
+          typeof pattern,
+          typeof fn5,
+          string,
+          number,
+          boolean,
+          string,
+          number
+        ]);
+        (c6.payload.args: [
+          number,
+          typeof pattern,
+          typeof fn6,
+          string,
+          number,
+          boolean,
+          string,
+          number,
+          boolean
+        ]);
+      });
+
+      it("must raises an error when passed number but need number", () => {
+        // $FlowExpectedError[incompatible-cast]
+        // $FlowExpectedError[invalid-tuple-arity]: First parameter is a number, not a string
+        (c1.payload.args: [string]);
+      });
+
+      it("must raises an error when passed too few arguments", () => {
+        // $FlowExpectedError[incompatible-call]: Too few arguments
+        throttle(timeMs, pattern, fn6, "1", 2, true, "4");
+      });
+
+      it("must raises an error when passed wrong argument types", () => {
+        // $FlowExpectedError[incompatible-call]: Wrong argument types
+        throttle(timeMs, pattern, fn1, 1);
+      });
+    });
+
+    it("must passes when used properly", () => {
+      (c1.payload.fn: Function);
+      (c2.payload.fn: Function);
+      (c3.payload.fn: Function);
+      (c4.payload.fn: Function);
+      (c5.payload.fn: Function);
+      (c6.payload.fn: Function);
+    });
+
+    it("must haven't context", () => {
+      (c1.payload.context: null);
+      (c2.payload.context: null);
+      (c3.payload.context: null);
+      (c4.payload.context: null);
+      (c5.payload.context: null);
+      (c6.payload.context: null);
+    });
+  });
+});
diff --git a/definitions/npm/redux-thunk_v2.x.x/flow_v0.201.x-/redux-thunk_v2.x.x.js b/definitions/npm/redux-thunk_v2.x.x/flow_v0.201.x-/redux-thunk_v2.x.x.js
new file mode 100644
index 0000000000..b41a921b51
--- /dev/null
+++ b/definitions/npm/redux-thunk_v2.x.x/flow_v0.201.x-/redux-thunk_v2.x.x.js
@@ -0,0 +1,30 @@
+// Copied types from redux so that
+// redux-thunk can be used with redux and redux-mock-store.
+//
+// This should be replaced with imports in the not too distant future once we
+// figure out cross dependency imports in flow-typed
+declare module '@@redux' {
+  declare export type DispatchAPI<A> = (action: A) => A;
+
+  declare export type Dispatch<A: { type: any, ... }> = DispatchAPI<A>;
+
+  declare export type MiddlewareAPI<S, A, D = Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    ...
+  };
+
+  declare export type Middleware<S, A, D = Dispatch<A>> = (
+    api: MiddlewareAPI<S, A, D>
+  ) => (next: D) => D;
+}
+
+declare module 'redux-thunk' {
+  import type { Middleware } from '@@redux';
+
+  declare export type Thunk = Middleware<any, any> & {|
+    withExtraArgument(arg: $NonMaybeType<mixed>): Middleware<any, any>,
+  |};
+
+  declare module.exports: Thunk;
+}
diff --git a/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-/test_redux-thunk_v2.x.x.js b/definitions/npm/redux-thunk_v2.x.x/flow_v0.201.x-/test_redux-thunk_v2.x.x.js
similarity index 100%
rename from definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-/test_redux-thunk_v2.x.x.js
rename to definitions/npm/redux-thunk_v2.x.x/flow_v0.201.x-/test_redux-thunk_v2.x.x.js
diff --git a/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-/redux-thunk_v2.x.x.js b/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-v.200.x/redux-thunk_v2.x.x.js
similarity index 100%
rename from definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-/redux-thunk_v2.x.x.js
rename to definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-v.200.x/redux-thunk_v2.x.x.js
diff --git a/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-v.200.x/test_redux-thunk_v2.x.x.js b/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-v.200.x/test_redux-thunk_v2.x.x.js
new file mode 100644
index 0000000000..3979584211
--- /dev/null
+++ b/definitions/npm/redux-thunk_v2.x.x/flow_v0.83.x-v.200.x/test_redux-thunk_v2.x.x.js
@@ -0,0 +1,28 @@
+// @flow
+import thunk from 'redux-thunk';
+import { describe, it } from 'flow-typed-test';
+
+type MiddlewareStub = (
+  api: any
+) => (next: any) => any;
+
+describe('redux-thunk', () => {
+  it('is a middleware', () => {
+    (thunk: MiddlewareStub);
+  });
+
+  it('is a middleware with extra args', () => {
+    (thunk.withExtraArgument(''): MiddlewareStub);
+    // Ideally the following should be [props-missing] code but intersection type causes [incompatible-call] code instead
+    // $FlowExpectedError[incompatible-call] Only accepts 1 arg
+    thunk.withExtraArgument();
+    // Ideally the following should be [extra-arg] code but intersection type causes [incompatible-call] code instead
+    // $FlowExpectedError[incompatible-call] Only accepts 1 arg
+    thunk.withExtraArgument('', '');
+  });
+
+  it('thunk does not have extra random properties', () => {
+    // $FlowExpectedError[incompatible-call]
+    thunk.withSomeMoreArguments();
+  });
+});
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.134.x-/redux_v3.x.x.js b/definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/redux_v3.x.x.js
similarity index 100%
rename from definitions/npm/redux_v3.x.x/flow_v0.134.x-/redux_v3.x.x.js
rename to definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/redux_v3.x.x.js
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_applyMiddleware.js b/definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_applyMiddleware.js
similarity index 100%
rename from definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_applyMiddleware.js
rename to definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_applyMiddleware.js
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_combineReducers.js b/definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_combineReducers.js
similarity index 100%
rename from definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_combineReducers.js
rename to definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_combineReducers.js
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_createStore.js b/definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_createStore.js
similarity index 100%
rename from definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_createStore.js
rename to definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_createStore.js
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_custom_dispatch.js b/definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_custom_dispatch.js
similarity index 100%
rename from definitions/npm/redux_v3.x.x/flow_v0.134.x-/test_custom_dispatch.js
rename to definitions/npm/redux_v3.x.x/flow_v0.134.x-v.200.x/test_custom_dispatch.js
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.201.x-/redux_v3.x.x.js b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/redux_v3.x.x.js
new file mode 100644
index 0000000000..840b7661b3
--- /dev/null
+++ b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/redux_v3.x.x.js
@@ -0,0 +1,96 @@
+declare module 'redux' {
+  /*
+
+    S = State
+    A = Action
+    D = Dispatch
+
+  */
+
+  declare export type Action = { type: any, ... };
+
+  declare export type DispatchAPI<A> = (action: A) => A;
+
+  declare export type Dispatch<A: Action> = DispatchAPI<A>;
+
+  declare export type MiddlewareAPI<S, A, D = Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    ...
+  };
+
+  declare export type Store<S, A, D = Dispatch<A>> = {
+    // rewrite MiddlewareAPI members in order to get nicer error messages (intersections produce long messages)
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Reducer<S, A>): void,
+    ...
+  };
+
+  declare export type Reducer<S, A> = (state: S | void, action: A) => S;
+
+  declare export type CombinedReducer<S, A> = (
+    state: ($Shape<S> & {...}) | void,
+    action: A
+  ) => S;
+
+  declare export type Middleware<S, A, D = Dispatch<A>> = (
+    api: MiddlewareAPI<S, A, D>
+  ) => (next: D) => D;
+
+  declare export type StoreCreator<S, A, D = Dispatch<A>> = {
+    (reducer: Reducer<S, A>, enhancer?: StoreEnhancer<S, A, D>): Store<S, A, D>,
+    (
+      reducer: Reducer<S, A>,
+      preloadedState: S,
+      enhancer?: StoreEnhancer<S, A, D>
+    ): Store<S, A, D>,
+    ...
+  };
+
+  declare export type StoreEnhancer<S, A, D = Dispatch<A>> = (
+    next: StoreCreator<S, A, D>
+  ) => StoreCreator<S, A, D>;
+
+  declare export function createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+  declare export function createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    preloadedState?: S,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+
+  declare export function applyMiddleware<S, A, D>(
+    ...middlewares: Array<Middleware<S, A, D>>
+  ): StoreEnhancer<S, A, D>;
+
+  declare export type ActionCreator<A, B> = (...args: Array<B>) => A;
+  declare export type ActionCreators<K, A> = { [key: K]: ActionCreator<A, any>, ... };
+
+  declare export function bindActionCreators<
+    A,
+    C: ActionCreator<A, any>,
+    D: DispatchAPI<A>
+  >(
+    actionCreator: C,
+    dispatch: D
+  ): C;
+  declare export function bindActionCreators<
+    A,
+    K,
+    C: ActionCreators<K, A>,
+    D: DispatchAPI<A>
+  >(
+    actionCreators: C,
+    dispatch: D
+  ): C;
+
+  declare export function combineReducers<O: {...}, A>(
+    reducers: O
+  ): CombinedReducer<$ObjMap<O, <S>(r: Reducer<S, any>) => S>, A>;
+
+  declare export var compose: $Compose;
+}
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_applyMiddleware.js b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_applyMiddleware.js
new file mode 100644
index 0000000000..d7c16554fc
--- /dev/null
+++ b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_applyMiddleware.js
@@ -0,0 +1,38 @@
+// @flow
+import type { Store as ReduxStore, MiddlewareAPI } from 'redux';
+import { applyMiddleware, createStore } from 'redux';
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Store = ReduxStore<State, Action>;
+const reducer = (state: State = [], action: Action): State => state;
+
+//
+// applyMiddleware API
+//
+
+applyMiddleware();
+applyMiddleware(api => next => next);
+// $FlowExpectedError[incompatible-call]
+applyMiddleware('wrong');
+
+//
+// interaction with createStore
+//
+
+createStore(reducer, [1], applyMiddleware(api => next => next));
+createStore(
+  reducer,
+  [1],
+  applyMiddleware((api: MiddlewareAPI<State, Action>) => {
+    // $FlowExpectedError[incompatible-type]
+    const s: number = api.getState(); // wrong return type
+    // $FlowExpectedError[incompatible-call]
+    api.dispatch({ type: 'wrong' }); // wrong action
+    // $FlowExpectedError[prop-missing]
+    api.replaceReducer(() => ({})); // wrong reducer
+    // $FlowExpectedError[prop-missing]
+    api.subscribe(() => 'wrong'); // wrong subscriber
+    return next => next;
+  })
+);
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_combineReducers.js b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_combineReducers.js
new file mode 100644
index 0000000000..18bef6af3c
--- /dev/null
+++ b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_combineReducers.js
@@ -0,0 +1,50 @@
+// @flow
+import type { Reducer } from 'redux';
+import { combineReducers } from 'redux';
+
+type Action = { type: 'A', ... } | { type: 'B', ... };
+type AState = { foo: number, ... };
+const initialAState: AState = { foo: 1 };
+const reducerA: Reducer<AState, Action> = (state = initialAState, action) => {
+  return state;
+};
+type State = {
+  a: AState,
+  name: string,
+  age: number,
+  ...
+};
+
+//
+// combineReducers API
+//
+
+const initialName = 'initialName';
+function reducerName(name: string = initialName, action: Action): string {
+  return name;
+}
+
+const initialAge = 0;
+function reducerAge(age: number = initialAge, action: Action): number {
+  return age;
+}
+
+// ok
+const reducer0: Reducer<State, Action> = combineReducers({
+  a: reducerA,
+  name: reducerName,
+  age: reducerAge,
+});
+
+// $FlowExpectedError[incompatible-call]
+combineReducers(); // wrong reducers argument
+// $FlowExpectedError[incompatible-call]
+combineReducers([]); // wrong reducers argument
+
+// $FlowExpectedError[prop-missing]
+// $FlowExpectedError[incompatible-type]
+const reducer1: Reducer<State, Action> = combineReducers({
+  a: reducerA,
+  name: reducerName,
+  // missing age reducer
+});
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_createStore.js b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_createStore.js
new file mode 100644
index 0000000000..da2ced8df3
--- /dev/null
+++ b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_createStore.js
@@ -0,0 +1,50 @@
+// @flow
+import type { Store as ReduxStore, StoreEnhancer } from 'redux';
+import { createStore } from 'redux';
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Store = ReduxStore<State, Action>;
+const reducer = (state: State = [], action: Action): State => state;
+
+//
+// createStore API
+//
+
+// $FlowExpectedError[incompatible-type-arg]
+// $FlowExpectedError[incompatible-call]
+const store1: Store = createStore(() => ({})); // wrong reducer
+const store2: Store = createStore(reducer);
+// $FlowExpectedError[incompatible-call]
+const store3: Store = createStore(reducer, {}); // wrong initialState shape
+const store4: Store = createStore(reducer, []);
+// $FlowExpectedError[incompatible-type]
+// $FlowExpectedError[incompatible-call]
+const store5: Store = createStore(reducer, ['wrong']); // wrong initialState content
+const store6: Store = createStore(reducer, [1]);
+// $FlowExpectedError[incompatible-call]
+const store7: Store = createStore(reducer, [1], 'wrong'); // wrong enhancer
+declare var myEnhancer: StoreEnhancer<State, Action>;
+const store8: Store = createStore(reducer, [1], myEnhancer);
+const store9: Store = createStore(reducer, undefined, myEnhancer);
+
+//
+// store members
+//
+
+const s: State = store2.getState();
+// $FlowExpectedError[name-already-bound]
+// $FlowExpectedError[incompatible-type]
+const s: number = store2.getState(); // wrong return type
+
+store2.dispatch({ type: 'A' });
+// $FlowExpectedError[incompatible-call]
+store2.dispatch({ type: 'wrong' }); // wrong action
+
+store2.replaceReducer(reducer);
+// $FlowExpectedError[incompatible-call]
+store2.replaceReducer(() => ({})); // wrong reducer
+
+store2.subscribe(() => {});
+// $FlowExpectedError[incompatible-call]
+store2.subscribe(() => 'wrong'); // wrong subscriber
diff --git a/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_custom_dispatch.js b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_custom_dispatch.js
new file mode 100644
index 0000000000..7bccdc6deb
--- /dev/null
+++ b/definitions/npm/redux_v3.x.x/flow_v0.201.x-/test_custom_dispatch.js
@@ -0,0 +1,69 @@
+// @flow
+import type {
+  Store as ReduxStore,
+  DispatchAPI,
+  MiddlewareAPI,
+  StoreEnhancer,
+} from 'redux';
+import { applyMiddleware, bindActionCreators, createStore } from 'redux';
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Thunk = (dispatch: Dispatch, getState: () => State) => void;
+type Dispatch = DispatchAPI<Action | Thunk>;
+type Store = ReduxStore<State, Action, Dispatch>;
+const reducer = (state: State = [], action: Action): State => state;
+
+//
+// applyMiddleware interaction with createStore
+//
+
+createStore(
+  reducer,
+  [1],
+  applyMiddleware((api: MiddlewareAPI<State, Action, Dispatch>) => {
+    api.dispatch({ type: 'A' });
+    // $FlowExpectedError[incompatible-call]
+    api.dispatch({ type: 'wrong' }); // wrong action
+
+    api.dispatch((dispatch, getState) => {});
+    // $FlowExpectedError[incompatible-call]
+    api.dispatch(() => false);
+
+    return next => next;
+  })
+);
+
+//
+// bindActionCreators API
+//
+
+declare var dispatch: Dispatch;
+
+const ac1 = bindActionCreators((n: number) => ({ type: 'A' }), dispatch);
+ac1(1);
+// $FlowExpectedError[incompatible-call]
+bindActionCreators((n: number) => ({ type: 'wrong' }), dispatch); // wrong action
+
+const ac2 = bindActionCreators(
+  (n: number) => (dispatch, getState) => {},
+  dispatch
+);
+ac2(1);
+// $FlowExpectedError[incompatible-call]
+bindActionCreators((n: number) => (dispatch, getState) => 'wrong', dispatch); // wrong thunk
+
+//
+// createStore API
+//
+
+declare var myEnhancer: StoreEnhancer<State, Action, Dispatch>;
+const store: Store = createStore(reducer, [1], myEnhancer);
+
+store.dispatch({ type: 'A' });
+// $FlowExpectedError[incompatible-call]
+store.dispatch({ type: 'wrong' }); // wrong action
+
+store.dispatch((dispatch, getState) => {});
+// $FlowExpectedError[incompatible-call]
+store.dispatch((dispatch, getState) => false); // wrong action
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/redux_v4.x.x.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/redux_v4.x.x.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/redux_v4.x.x.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/redux_v4.x.x.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_action.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_action.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_action.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_action.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_applyMiddleware.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_applyMiddleware.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_applyMiddleware.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_applyMiddleware.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_combineReducers.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_combineReducers.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_combineReducers.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_combineReducers.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_createStore.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_createStore.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_createStore.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_createStore.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_custom_dispatch.js b/definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_custom_dispatch.js
similarity index 100%
rename from definitions/npm/redux_v4.x.x/flow_v0.134.x-/test_custom_dispatch.js
rename to definitions/npm/redux_v4.x.x/flow_v0.134.x-v.200.x/test_custom_dispatch.js
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/redux_v4.x.x.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/redux_v4.x.x.js
new file mode 100644
index 0000000000..2631ff1a59
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/redux_v4.x.x.js
@@ -0,0 +1,106 @@
+declare module 'redux' {
+  /*
+
+    S = State
+    A = Action
+    D = Dispatch
+
+  */
+
+  declare export type Action<T> = { type: T, ... }
+
+  declare export type DispatchAPI<A> = (action: A) => A;
+
+  declare export type Dispatch<A: { type: any, ... }> = DispatchAPI<A>;
+
+  declare export type MiddlewareAPI<S, A, D = Dispatch<A>> = {
+    dispatch: D,
+    getState(): S,
+    ...
+  };
+
+  declare export type Store<S, A, D = Dispatch<A>> = {
+    // rewrite MiddlewareAPI members in order to get nicer error messages (intersections produce long messages)
+    dispatch: D,
+    getState(): S,
+    subscribe(listener: () => void): () => void,
+    replaceReducer(nextReducer: Reducer<S, A>): void,
+    ...
+  };
+
+  declare export type Reducer<S, A> = (state: S, action: A) => S;
+
+  declare export type CombinedReducer<S, A> = (
+    state: ($Shape<S> & {...}) | void,
+    action: A
+  ) => S;
+
+  declare export type Middleware<S, A, D = Dispatch<A>> = (
+    api: MiddlewareAPI<S, A, D>
+  ) => (next: D) => D;
+
+  declare export type StoreCreator<S, A, D = Dispatch<A>> = {
+    (reducer: Reducer<S, A>, enhancer?: StoreEnhancer<S, A, D>): Store<S, A, D>,
+    (
+      reducer: Reducer<S, A>,
+      preloadedState: S,
+      enhancer?: StoreEnhancer<S, A, D>
+    ): Store<S, A, D>,
+    ...
+  };
+
+  declare export type StoreEnhancer<S, A, D = Dispatch<A>> = (
+    next: StoreCreator<S, A, D>
+  ) => StoreCreator<S, A, D>;
+
+  declare export function createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+  declare export function createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    preloadedState?: S,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+
+  declare export function legacy_createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+  declare export function legacy_createStore<S, A, D>(
+    reducer: Reducer<S, A>,
+    preloadedState?: S,
+    enhancer?: StoreEnhancer<S, A, D>
+  ): Store<S, A, D>;
+
+  declare export function applyMiddleware<S, A, D>(
+    ...middlewares: Array<Middleware<S, A, D>>
+  ): StoreEnhancer<S, A, D>;
+
+  declare export type ActionCreator<A, B> = (...args: Array<B>) => A;
+  declare export type ActionCreators<K, A> = { [key: K]: ActionCreator<A, any>, ... };
+
+  declare export function bindActionCreators<
+    A,
+    C: ActionCreator<A, any>,
+    D: DispatchAPI<A>
+  >(
+    actionCreator: C,
+    dispatch: D
+  ): C;
+  declare export function bindActionCreators<
+    A,
+    K,
+    C: ActionCreators<K, A>,
+    D: DispatchAPI<A>
+  >(
+    actionCreators: C,
+    dispatch: D
+  ): C;
+
+  declare export function combineReducers<O: {...}, A>(
+    reducers: O
+  ): CombinedReducer<$ObjMap<O, <S>(r: Reducer<S, any>) => S>, A>;
+
+  declare export var compose: $Compose;
+}
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_action.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_action.js
new file mode 100644
index 0000000000..55031b026e
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_action.js
@@ -0,0 +1,25 @@
+// @flow
+import type {Action} from 'redux'
+import { describe, it } from 'flow-typed-test';
+
+describe('Action<T>', () => {
+
+  it('passes when used properly', () => {
+    const action: Action<"increment"> = { type: "increment" };
+  });
+
+  it('raises an error when passed an invalid type parameter', () => {
+    // $FlowExpectedError[incompatible-type]
+    const action: Action<"increment"> = { type: "decrement" };
+  });
+
+  it('raises an error when missed the type property', () => {
+    // $FlowExpectedError[prop-missing]
+    const action: Action<string> = { payload: 1 };
+  });
+
+});
+
+
+
+
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_applyMiddleware.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_applyMiddleware.js
new file mode 100644
index 0000000000..7e98416b9a
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_applyMiddleware.js
@@ -0,0 +1,34 @@
+// @flow
+import type { Store as ReduxStore, MiddlewareAPI } from 'redux'
+import { applyMiddleware, createStore } from 'redux'
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Store = ReduxStore<State, Action>;
+const reducer = (state: State = [], action: Action): State => state
+
+//
+// applyMiddleware API
+//
+
+applyMiddleware();
+applyMiddleware(api => next => next);
+// $FlowExpectedError[incompatible-call]
+applyMiddleware('wrong');
+
+//
+// interaction with createStore
+//
+
+createStore(reducer, [1], applyMiddleware(api => next => next))
+createStore(reducer, [1], applyMiddleware((api: MiddlewareAPI<State, Action>) => {
+  // $FlowExpectedError[incompatible-type]
+  const s: number = api.getState() // wrong return type
+  // $FlowExpectedError[incompatible-call]
+  api.dispatch({ type: 'wrong' }) // wrong action
+  // $FlowExpectedError[prop-missing]
+  api.replaceReducer(() => ({})) // wrong reducer
+  // $FlowExpectedError[prop-missing]
+  api.subscribe(() => 'wrong') // wrong subscriber
+  return next => next
+}))
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_combineReducers.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_combineReducers.js
new file mode 100644
index 0000000000..79d295895c
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_combineReducers.js
@@ -0,0 +1,50 @@
+// @flow
+import type { Reducer } from 'redux'
+import { combineReducers } from 'redux'
+
+type Action = { type: 'A', ... } | { type: 'B', ... };
+type AState = { foo: number, ... };
+const initialAState: AState = { foo: 1 }
+const reducerA: Reducer<AState, Action> = (state = initialAState, action) => {
+  return state
+}
+type State = {
+  a: AState,
+  name: string,
+  age: number,
+  ...
+};
+
+//
+// combineReducers API
+//
+
+const initialName = 'initialName'
+function reducerName(name: string = initialName, action: Action): string {
+  return name
+}
+
+const initialAge = 0
+function reducerAge(age: number = initialAge, action: Action): number {
+  return age
+}
+
+// ok
+const reducer0: Reducer<State, Action> = combineReducers({
+  a: reducerA,
+  name: reducerName,
+  age: reducerAge
+})
+
+// $FlowExpectedError[incompatible-call]
+combineReducers() // wrong reducers argument
+// $FlowExpectedError[incompatible-call]
+combineReducers([]) // wrong reducers argument
+
+// $FlowExpectedError[prop-missing]
+// $FlowExpectedError[incompatible-type]
+const reducer1: Reducer<State, Action> = combineReducers({
+  a: reducerA,
+  name: reducerName
+  // missing age reducer
+})
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_createStore.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_createStore.js
new file mode 100644
index 0000000000..0edc320fdd
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_createStore.js
@@ -0,0 +1,67 @@
+// @flow
+import type { Store as ReduxStore, StoreEnhancer } from 'redux'
+import { createStore, legacy_createStore } from 'redux'
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Store = ReduxStore<State, Action>;
+const reducer = (state: State = [], action: Action): State => state
+
+//
+// createStore API
+//
+
+// $FlowExpectedError[incompatible-type-arg]
+// $FlowExpectedError[incompatible-call]
+const store1: Store = createStore(() => ({})); // wrong reducer
+const store2: Store = createStore(reducer);
+// $FlowExpectedError[incompatible-call]
+const store3: Store = createStore(reducer, {}); // wrong initialState shape
+const store4: Store = createStore(reducer, []);
+// $FlowExpectedError[incompatible-type]
+// $FlowExpectedError[incompatible-call]
+const store5: Store = createStore(reducer, ['wrong']); // wrong initialState content
+const store6: Store = createStore(reducer, [1]);
+// $FlowExpectedError[incompatible-call]
+const store7: Store = createStore(reducer, [1], 'wrong'); // wrong enhancer
+declare var myEnhancer: StoreEnhancer<State, Action>;
+const store8: Store = createStore(reducer, [1], myEnhancer);
+const store9: Store = createStore(reducer, undefined, myEnhancer);
+
+// $FlowExpectedError[incompatible-type-arg]
+// $FlowExpectedError[incompatible-call]
+const legacyStore1: Store = legacy_createStore(() => ({})); // wrong reducer
+const legacyStore2: Store = legacy_createStore(reducer);
+// $FlowExpectedError[incompatible-call]
+const legacyStore3: Store = legacy_createStore(reducer, {}); // wrong initialState shape
+const legacyStore4: Store = legacy_createStore(reducer, []);
+// $FlowExpectedError[incompatible-type]
+// $FlowExpectedError[incompatible-call]
+const legacyStore5: Store = legacy_createStore(reducer, ['wrong']); // wrong initialState content
+const legacyStore6: Store = legacy_createStore(reducer, [1]);
+// $FlowExpectedError[incompatible-call]
+const legacyStore7: Store = legacy_createStore(reducer, [1], 'wrong'); // wrong enhancer
+declare var legacyMyEnhancer: StoreEnhancer<State, Action>;
+const legacyStore8: Store = legacy_createStore(reducer, [1], myEnhancer);
+const legacyStore9: Store = legacy_createStore(reducer, undefined, myEnhancer);
+
+//
+// store members
+//
+
+const s: State = store2.getState()
+// $FlowExpectedError[incompatible-type]
+// $FlowExpectedError[name-already-bound]
+const s: number = store2.getState() // wrong return type
+
+store2.dispatch({ type: 'A' })
+// $FlowExpectedError[incompatible-call]
+store2.dispatch({ type: 'wrong' }) // wrong action
+
+store2.replaceReducer(reducer)
+// $FlowExpectedError[incompatible-call]
+store2.replaceReducer(() => ({})) // wrong reducer
+
+store2.subscribe(() => {})
+// $FlowExpectedError[incompatible-call]
+store2.subscribe(() => 'wrong') // wrong subscriber
diff --git a/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_custom_dispatch.js b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_custom_dispatch.js
new file mode 100644
index 0000000000..557e934466
--- /dev/null
+++ b/definitions/npm/redux_v4.x.x/flow_v0.201.x-/test_custom_dispatch.js
@@ -0,0 +1,57 @@
+// @flow
+import type { Store as ReduxStore, DispatchAPI, MiddlewareAPI, StoreEnhancer } from 'redux'
+import { applyMiddleware, bindActionCreators, createStore } from 'redux'
+
+type State = Array<number>;
+type Action = { type: 'A', ... };
+type Thunk = (dispatch: Dispatch, getState: () => State) => void;
+type Dispatch = DispatchAPI<Action | Thunk>;
+type Store = ReduxStore<State, Action, Dispatch>;
+const reducer = (state: State = [], action: Action): State => state
+
+//
+// applyMiddleware interaction with createStore
+//
+
+createStore(reducer, [1], applyMiddleware((api: MiddlewareAPI<State, Action, Dispatch>) => {
+  api.dispatch({ type: 'A' });
+  // $FlowExpectedError[incompatible-call]
+  api.dispatch({ type: 'wrong' }) // wrong action
+
+  api.dispatch((dispatch, getState) => {});
+  // $FlowExpectedError[incompatible-call]
+  api.dispatch(() => false);
+
+  return next => next
+}));
+
+//
+// bindActionCreators API
+//
+
+declare var dispatch: Dispatch;
+
+const ac1 = bindActionCreators((n: number) => ({ type: 'A' }), dispatch);
+ac1(1);
+// $FlowExpectedError[incompatible-call]
+bindActionCreators((n: number) => ({ type: 'wrong' }), dispatch); // wrong action
+
+const ac2 = bindActionCreators((n: number) => (dispatch, getState) => {}, dispatch);
+ac2(1);
+// $FlowExpectedError[incompatible-call]
+bindActionCreators((n: number) => (dispatch, getState) => 'wrong', dispatch); // wrong thunk
+
+//
+// createStore API
+//
+
+declare var myEnhancer: StoreEnhancer<State, Action, Dispatch>;
+const store: Store = createStore(reducer, [1], myEnhancer);
+
+store.dispatch({ type: 'A' });
+// $FlowExpectedError[incompatible-call]
+store.dispatch({ type: 'wrong' }); // wrong action
+
+store.dispatch((dispatch, getState) => {});
+// $FlowExpectedError[incompatible-call]
+store.dispatch((dispatch, getState) => false); // wrong action
diff --git a/definitions/npm/rivets_v0.9.x/flow_v0.104.x-/rivets_v0.9.x.js b/definitions/npm/rivets_v0.9.x/flow_v0.104.x-v.200.x/rivets_v0.9.x.js
similarity index 100%
rename from definitions/npm/rivets_v0.9.x/flow_v0.104.x-/rivets_v0.9.x.js
rename to definitions/npm/rivets_v0.9.x/flow_v0.104.x-v.200.x/rivets_v0.9.x.js
diff --git a/definitions/npm/rivets_v0.9.x/flow_v0.201.x-/rivets_v0.9.x.js b/definitions/npm/rivets_v0.9.x/flow_v0.201.x-/rivets_v0.9.x.js
new file mode 100644
index 0000000000..6876d5814c
--- /dev/null
+++ b/definitions/npm/rivets_v0.9.x/flow_v0.201.x-/rivets_v0.9.x.js
@@ -0,0 +1,64 @@
+declare module 'rivets' {
+  declare class View {
+    unbind(): void;
+  }
+
+  declare type ConfigurationOptions = {|
+    prefix?: string,
+    preloadData?: boolean,
+    rootInterface?: string,
+    templateDelimiters?: [string, string],
+    iterationAlias?: (modelName: string) => string,
+    handler?: (target: HTMLElement, event: Event, binding: Object) => void,
+    executeFunctions?: boolean
+  |}
+
+  declare type TwoWayBinder = {|
+    bind: (el: HTMLElement) => void,
+    unbind: (el: HTMLElement) => void,
+    routine: (el: HTMLElement, value: any) => any,
+    getValue?: (el: HTMLElement) => any,
+    publishes?: boolean,
+    priority?: number,
+    block?: boolean
+  |}
+
+  declare type TwoWayFormatter = {|
+    read: (value: any) => any,
+    publish: (value: any) => any
+  |}
+
+  declare type Component<C> = {|
+    static?: Array<string>,
+    template: () => string,
+    initialize: (el: HTMLElement, data: Object) => C
+  |}
+
+  declare type Adapter = {|
+    observe: (obj: Object, keypath: string, callback: () => void) => void,
+    unobserve: (obj: Object, keypath: string, callback: () => void) => void,
+    get: (obj: Object, keypath: string) => any,
+    set: (obj: Object, keypath: string, value: any) => void,
+
+    // NOTE: these are non-standard methods used to observe arrays
+    observeMutations?: (obj: Object, ref: string, keypath: string) => void,
+    unobserveMutations?: (obj: Object, ref: string, keypath: string) => void
+  |};
+
+  declare class Rivets {
+
+    bind(element: HTMLElement, model: Object): View;
+    configure(options: ConfigurationOptions): void;
+    init(componentName: string, element: HTMLElement, data: Object): View;
+
+    binders: { [key: string]: TwoWayBinder | (el: HTMLElement, value: any) => void, ... };
+
+    formatters: { [key: string]: TwoWayFormatter | (...value: any) => any, ... };
+
+    components: { [key: string]: Component<any>, ... };
+
+    adapters: { [key: string]: Adapter, ... };
+  }
+
+  declare export default Rivets;
+}
diff --git a/definitions/npm/rsuite_v3.x.x/flow_v0.104.x-/rsuite_v3.x.x.js b/definitions/npm/rsuite_v3.x.x/flow_v0.104.x-v.200.x/rsuite_v3.x.x.js
similarity index 100%
rename from definitions/npm/rsuite_v3.x.x/flow_v0.104.x-/rsuite_v3.x.x.js
rename to definitions/npm/rsuite_v3.x.x/flow_v0.104.x-v.200.x/rsuite_v3.x.x.js
diff --git a/definitions/npm/rsuite_v3.x.x/flow_v0.104.x-/test_rsuite_v3.x.x.js b/definitions/npm/rsuite_v3.x.x/flow_v0.104.x-v.200.x/test_rsuite_v3.x.x.js
similarity index 100%
rename from definitions/npm/rsuite_v3.x.x/flow_v0.104.x-/test_rsuite_v3.x.x.js
rename to definitions/npm/rsuite_v3.x.x/flow_v0.104.x-v.200.x/test_rsuite_v3.x.x.js
diff --git a/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/rsuite_v3.x.x.js b/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/rsuite_v3.x.x.js
new file mode 100644
index 0000000000..ba48a40302
--- /dev/null
+++ b/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/rsuite_v3.x.x.js
@@ -0,0 +1,1856 @@
+declare module "rsuite" {
+  import type { ElementType, Element, Node, ElementRef } from 'react';
+  declare type moment$Moment = Object;
+  declare type Size = "lg" | "md" | "sm" | "xs";
+  declare type Types = "success" | "warning" | "error" | "info";
+  declare type PickerAppearanceType = "default" | "subtle";
+  declare type SVGIcon = {
+    viewBox: string,
+    id: string,
+    ...
+  };
+  declare type Color =
+    | "red"
+    | "orange"
+    | "yellow"
+    | "green"
+    | "cyan"
+    | "blue"
+    | "violet";
+
+  declare type TriggerType = "click" | "hover";
+  declare type WhisperTriggerType = "click" | "hover" | "focus" | "active";
+  declare type DropdownTriggerType = "click" | "hover" | "contextMenu";
+  declare type PlacementFourSides = "top" | "right" | "bottom" | "left";
+  declare type PlacementEightPoints =
+    | "bottomLeft"
+    | "bottomRight"
+    | "topLeft"
+    | "topRight"
+    | "leftTop"
+    | "rightTop"
+    | "leftBottom"
+    | "rightBottom";
+
+  declare type PlacementAuto =
+    | "auto"
+    | "autoVertical"
+    | "autoVerticalLeft"
+    | "autoVerticalRight"
+    | "autoHorizontal"
+    | "autoHorizontalTop"
+    | "autoHorizontalBottom";
+
+  declare type Placement = PlacementEightPoints | PlacementAuto;
+  declare type ItemDataType = {
+    label: mixed,
+    value: mixed,
+    ...
+  };
+
+  declare type AnimationCallbackProps = {
+    onEnter?: () => void,
+    onEntering?: () => void,
+    onEntered?: () => void,
+    onExit?: () => void,
+    onExiting?: () => void,
+    onExited?: () => void,
+    ...
+  };
+
+  declare type SelectProps = {
+    menuStyle?: Object,
+    menuClassName?: string,
+    valueKey?: string,
+    labelKey?: string,
+    ...
+  };
+
+  declare type PickerProps = {
+    className?: string,
+    classPrefix?: string,
+    toggleComponentClass?: ElementType,
+    style?: Object,
+    container?: HTMLElement | (() => HTMLElement),
+    containerPadding?: number,
+    cleanable?: boolean,
+    open?: boolean,
+    defaultOpen?: boolean,
+    placement?: Placement,
+    block?: boolean,
+    disabled?: boolean,
+    placeholder?: string,
+    renderMenu?: (itemLabel: Node, item: Object) => Node,
+    onOpen?: () => void,
+    onClose?: () => void,
+    ...
+  } & AnimationCallbackProps;
+
+  declare export class Cascader extends React$Component<
+    PickerProps &
+      SelectProps & {
+      appearance?: PickerAppearanceType,
+      childrenKey?: string,
+      data: Array<any>,
+      renderExtraFooter?: () => Node,
+      value?: any,
+      defaultValue?: any,
+      onChange?: (value: any, event: SyntheticEvent<any>) => void,
+      onSelect?: (
+        value: any,
+        activePaths: Array<any>,
+        event: SyntheticEvent<any>
+      ) => void,
+      renderValue?: (activePaths?: Array<any>) => Node,
+      renderMenuItem?: (itemLabel: Node, item: Object) => Node,
+      menuWidth?: number,
+      menuHeight?: number,
+      disabledItemValues?: Array<any>,
+      ...
+    }
+  > {}
+
+  declare export class CheckTreePicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      appearance?: PickerAppearanceType,
+      data: Array<any>,
+      value?: Array<any>,
+      height?: number,
+      inline?: boolean,
+      cascade?: boolean,
+      expandAll?: boolean,
+      searchable?: boolean,
+      childrenKey?: string,
+      defaultValue?: Array<any>,
+      searchKeyword?: string,
+      defaultExpandAll?: boolean,
+      disabledItemValues?: Array<any>,
+      disabledCheckboxValues?: Array<any>,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      onChange?: (values: any) => void,
+      onExpand?: (activeNode: any, labyer: number) => void,
+      onSelect?: (activeNode: any, layer: number, values: any) => void,
+      onScroll?: (event: SyntheticEvent<any>) => void,
+      renderValue?: (
+        values: Array<any>,
+        checkItems: Array<any>,
+        placeholder: string | Node
+      ) => Node,
+      renderTreeNode?: (nodeData: Object) => Node,
+      renderTreeIcon?: (nodeData: Object) => Node,
+      renderExtraFooter?: () => Node,
+      ...
+    }
+  > {}
+
+  declare export class TreePicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      appearance?: PickerAppearanceType,
+      data: Array<any>,
+      open?: boolean,
+      value?: any,
+      height?: number,
+      inline?: boolean,
+      expandAll?: boolean,
+      searchable?: boolean,
+      childrenKey?: string,
+      defaultValue?: any,
+      searchKeyword?: string,
+      defaultExpandAll?: boolean,
+      disabledItemValues?: Array<any>,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      onChange?: (value: any) => void,
+      onExpand?: (activeNode: any, labyer: number) => void,
+      onSelect?: (
+        activeNode: any,
+        layer: number,
+        event: SyntheticEvent<any>
+      ) => void,
+      renderValue?: (
+        activeNode: Object,
+        placeholder: string | Node
+      ) => Node,
+      renderTreeNode?: (nodeData: Object) => Node,
+      renderTreeIcon?: (nodeData: Object) => Node,
+      renderExtraFooter?: () => Node,
+      ...
+    }
+  > {}
+
+  declare export class Tree extends React$Component<{
+    data: Array<any>,
+    value?: any,
+    height?: number,
+    expandAll?: boolean,
+    valueKey?: string,
+    labelKey?: string,
+    childrenKey?: string,
+    defaultValue?: any,
+    defaultExpandAll?: boolean,
+    disabledItemValues?: Array<any>,
+    onChange?: (value: any) => void,
+    onExpand?: (activeNode: any, labyer: number) => void,
+    onSelect?: (
+      activeNode: any,
+      layer: number,
+      event: SyntheticEvent<any>
+    ) => void,
+    renderTreeNode?: (nodeData: Object) => Node,
+    renderTreeIcon?: (nodeData: Object) => Node,
+    ...
+  }> {}
+
+  declare export class CheckTree extends React$Component<{
+    data: Array<any>,
+    value?: any,
+    height?: number,
+    expandAll?: boolean,
+    valueKey?: string,
+    labelKey?: string,
+    childrenKey?: string,
+    defaultValue?: any,
+    defaultExpandAll?: boolean,
+    disabledItemValues?: Array<any>,
+    onChange?: (value: Array<any>) => void,
+    onExpand?: (activeNode: any, labyer: number) => void,
+    onSelect?: (
+      activeNode: any,
+      layer: number,
+      event: SyntheticEvent<any>
+    ) => void,
+    renderTreeNode?: (nodeData: Object) => Node,
+    renderTreeIcon?: (nodeData: Object) => Node,
+    ...
+  }> {}
+
+  declare export class CheckPicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      appearance?: PickerAppearanceType,
+      data: Array<any>,
+      disabledItemValues?: Array<any>,
+      maxHeight?: number,
+      value?: Array<any>,
+      defaultValue?: Array<any>,
+      renderMenuItem?: (itemLabel: Node, item: Object) => Node,
+      renderMenuGroup?: (title: Node, item: Object) => Node,
+      renderValue?: (value: Array<any>, items: Array<any>) => Node,
+      renderExtraFooter?: () => Node,
+      onChange?: (value: Array<any>, event: SyntheticEvent<any>) => void,
+      onSelect?: (value: any, item: Object, event: SyntheticEvent<any>) => void,
+      onGroupTitleClick?: (event: SyntheticEvent<any>) => void,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      groupBy?: any,
+      searchable?: boolean,
+      ...
+    }
+  > {}
+
+  declare export class DatePicker extends React$Component<
+    PickerProps & {
+      appearance?: PickerAppearanceType,
+      disabledDate?: (date?: moment$Moment) => boolean,
+      disabledHours?: (hour: number, date: moment$Moment) => boolean,
+      disabledMinutes?: (minute: number, date: moment$Moment) => boolean,
+      disabledSeconds?: (second: number, date: moment$Moment) => boolean,
+      hideHours?: (hour: number, date: moment$Moment) => boolean,
+      hideMinutes?: (minute: number, date: moment$Moment) => boolean,
+      hideSeconds?: (second: number, date: moment$Moment) => boolean,
+      ranges?: Array<Range>,
+      defaultValue?: moment$Moment,
+      value?: moment$Moment,
+      calendarDefaultDate?: moment$Moment,
+      format?: string,
+      inline?: boolean,
+      onChange?: (value: moment$Moment | null) => void,
+      onChangeCalendarDate?: (
+        date: moment$Moment,
+        event?: SyntheticEvent<any>
+      ) => void,
+      onToggleMonthDropdown?: (toggle: boolean) => void,
+      onToggleTimeDropdown?: (toggle: boolean) => void,
+      onSelect?: (date: moment$Moment, event?: SyntheticEvent<any>) => void,
+      onPrevMonth?: (date: moment$Moment) => void,
+      onNextMonth?: (date: moment$Moment) => void,
+      onOk?: (date: moment$Moment, event: SyntheticEvent<any>) => void,
+      isoWeek?: boolean,
+      limitStartYear?: number,
+      limitEndYear?: number,
+      menuClassName?: string,
+      ...
+    }
+  > {}
+
+  declare export class DateRangePicker extends React$Component<
+    PickerProps & {
+      appearance?: PickerAppearanceType,
+      disabledDate?: (
+        date: moment$Moment,
+        selectValue: Array<moment$Moment | null>,
+        doneSelected: boolean,
+        type: string
+      ) => boolean,
+      ranges?: Array<Range>,
+      value?: Array<moment$Moment>,
+      defaultValue?: Array<moment$Moment>,
+      format?: string,
+      onChange?: (value: Array<moment$Moment>) => void,
+      onOk?: (value?: Array<moment$Moment>, event: SyntheticEvent<any>) => void,
+      hoverRange?: "week" | "month" | (() => void),
+      isoWeek?: boolean,
+      oneTap?: boolean,
+      limitStartYear?: number,
+      limitEndYear?: number,
+      menuClassName?: string,
+      onSelect?: (date: moment$Moment) => void,
+      ...
+    }
+  > {}
+
+  declare export class InputPicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      data: Array<any>,
+      cacheData?: Array<any>,
+      disabledItemValues?: Array<any>,
+      maxHeight?: number,
+      value?: any,
+      defaultValue?: any,
+      renderMenuItem?: (itemLabel: Node, item: Object) => Node,
+      renderMenuGroup?: (title: Node, item: Object) => Node,
+      renderValue?: (value: any, item: Object) => Node,
+      renderExtraFooter?: () => Node,
+      onChange?: (value: any, event: SyntheticEvent<any>) => void,
+      onSelect?: (value: any, item: Object, event: SyntheticEvent<any>) => void,
+      onGroupTitleClick?: (event: SyntheticEvent<any>) => void,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      groupBy?: any,
+      searchable?: boolean,
+      creatable?: boolean,
+      ...
+    }
+  > {}
+
+  declare export class TagPicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      data: Array<any>,
+      cacheData?: Array<any>,
+      disabledItemValues?: Array<any>,
+      maxHeight?: number,
+      value?: Array<any>,
+      defaultValue?: Array<any>,
+      renderMenuItem?: (itemLabel: Node, item: Object) => Node,
+      renderMenuGroup?: (title: Node, item: Object) => Node,
+      renderValue?: (value: Array<any>, item: Object) => Node,
+      renderExtraFooter?: () => Node,
+      onChange?: (value: Array<any>, event: SyntheticEvent<any>) => void,
+      onSelect?: (
+        value: Array<any>,
+        item: Object,
+        event: SyntheticEvent<any>
+      ) => void,
+      onGroupTitleClick?: (event: SyntheticEvent<any>) => void,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      groupBy?: any,
+      searchable?: boolean,
+      creatable?: boolean,
+      ...
+    }
+  > {}
+
+  declare export class SelectPicker extends React$Component<
+    PickerProps &
+      SelectProps & {
+      appearance?: PickerAppearanceType,
+      data: Array<any>,
+      disabledItemValues?: Array<any>,
+      maxHeight?: number,
+      value?: any,
+      defaultValue?: any,
+      renderMenuItem?: (itemLabel: Node, item: Object) => Node,
+      renderMenuGroup?: (title: Node, item: Object) => Node,
+      renderValue?: (value: any, item: Object) => Node,
+      renderExtraFooter?: () => Node,
+      onChange?: (value: any, event: SyntheticEvent<any>) => void,
+      onSelect?: (value: any, item: Object, event: SyntheticEvent<any>) => void,
+      onGroupTitleClick?: (event: SyntheticEvent<any>) => void,
+      onSearch?: (searchKeyword: string, event: SyntheticEvent<any>) => void,
+      groupBy?: any,
+      searchable?: boolean,
+      ...
+    }
+  > {}
+
+  declare export class AutoComplete extends React$Component<{
+    data: Array<string | ItemDataType>,
+    disabled?: boolean,
+    onSelect?: (item: ItemDataType, event: SyntheticEvent<any>) => void,
+    onChange?: (value: string, event: SyntheticEvent<any>) => void,
+    classPrefix?: string,
+    value?: string,
+    defaultValue?: string,
+    className?: string,
+    menuClassName?: string,
+    placement?: Placement,
+    onFocus?: (event: SyntheticEvent<any>) => void,
+    onMenuFocus?: (focusItemValue: any, event: SyntheticEvent<any>) => void,
+    onBlur?: (event: SyntheticEvent<any>) => void,
+    onKeyDown?: (event: SyntheticEvent<any>) => void,
+    onOpen?: () => void,
+    onClose?: () => void,
+    renderItem?: (itemValue: string) => Node,
+    style?: Object,
+    open?: boolean,
+    selectOnEnter?: boolean,
+    ...
+  }> {}
+
+  declare export class BreadcrumbItem extends React$Component<{
+    active?: boolean,
+    className?: string,
+    style?: Object,
+    href?: string,
+    title?: ElementType,
+    target?: string,
+    classPrefix?: string,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Breadcrumb extends React$Component<{
+    separator?: Node,
+    componentClass?: ElementType,
+    children?: Node,
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {
+    static Item: Class<BreadcrumbItem>;
+  }
+
+  declare export class Button extends React$Component<{
+    appearance?: "default" | "primary" | "link" | "subtle" | "ghost",
+    classPrefix?: string,
+    componentClass?: ElementType,
+    className?: string,
+    active?: boolean,
+    block?: boolean,
+    href?: string,
+    loading?: boolean,
+    disabled?: boolean,
+    children?: Node,
+    ...
+  }> {}
+
+  declare export class ButtonGroup extends React$Component<{
+    className?: string,
+    vertical?: boolean,
+    justified?: boolean,
+    block?: boolean,
+    classPrefix?: string,
+    children?: Element<typeof Button>,
+    ...
+  }> {}
+
+  declare export class ButtonToolbar extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Checkbox extends React$Component<{
+    title?: string,
+    className?: string,
+    inline?: boolean,
+    disabled?: boolean,
+    checked?: boolean,
+    defaultChecked?: boolean,
+    indeterminate?: boolean,
+    onChange?: (
+      value: any,
+      checked: boolean,
+      event: SyntheticInputEvent<HTMLInputElement>
+    ) => void,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    inputRef?: ElementRef<any>,
+    value?: any,
+    children?: Node,
+    classPrefix?: string,
+    tabIndex?: number,
+    ...
+  }> {}
+
+  declare export class CheckboxGroup extends React$Component<{
+    name?: string,
+    className?: string,
+    inline?: boolean,
+    value?: Array<any>,
+    defaultValue?: Array<any>,
+    onChange?: (
+      value: Array<any>,
+      event: SyntheticInputEvent<HTMLInputElement>
+    ) => void,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Col extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    xs?: number,
+    sm?: number,
+    md?: number,
+    lg?: number,
+    xsOffset?: number,
+    smOffset?: number,
+    mdOffset?: number,
+    lgOffset?: number,
+    xsPush?: number,
+    smPush?: number,
+    mdPush?: number,
+    lgPush?: number,
+    xsPull?: number,
+    smPull?: number,
+    mdPull?: number,
+    lgPull?: number,
+    xsHidden?: boolean,
+    smHidden?: boolean,
+    mdHidden?: boolean,
+    lgHidden?: boolean,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Container extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Content extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class ControlLabel extends React$Component<{
+    className?: string,
+    htmlFor?: string,
+    classPrefix?: string,
+    srOnly?: boolean,
+    ...
+  }> {}
+
+  declare export class Divider extends React$Component<{
+    className?: string,
+    vertical?: boolean,
+    classPrefix?: string,
+    children?: Node,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Drawer extends React$Component<{
+    classPrefix?: string,
+    placement?: "top" | "right" | "bottom" | "left",
+    show?: boolean,
+    full?: boolean,
+    children?: Node,
+    className?: string,
+    ...
+  }> {
+    static Body: Class<ModalBody>;
+    static Header: Class<ModalHeader>;
+    static Title: Class<ModalTitle>;
+    static Footer: Class<ModalFooter>;
+    static Dialog: Class<ModalDialog>;
+  }
+
+  declare export class Dropdown extends React$Component<{
+    activeKey?: any,
+    classPrefix?: string,
+    trigger?: DropdownTriggerType | Array<DropdownTriggerType>,
+    placement?: PlacementEightPoints,
+    title?: Node,
+    disabled?: boolean,
+    icon?: Element<typeof Icon>,
+    onClose?: () => void,
+    onOpen?: () => void,
+    onToggle?: (open?: boolean) => void,
+    onSelect?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    onMouseEnter?: (event: SyntheticEvent<any>) => void,
+    onMouseLeave?: (event: SyntheticEvent<any>) => void,
+    onContextMenu?: (event: SyntheticEvent<any>) => void,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    menuStyle?: Object,
+    className?: string,
+    toggleClassName?: string,
+    renderTitle?: (children?: Node) => Node,
+    tabIndex?: number,
+    open?: boolean,
+    eventKey?: any,
+    componentClass?: ElementType,
+    toggleComponentClass?: ElementType,
+    noCaret?: boolean,
+    ...
+  }> {
+    static Item: Class<DropdownMenuItem>;
+    static Menu: Class<DropdownMenu>;
+  }
+
+  declare export class DropdownMenu extends React$Component<{
+    activeKey?: any,
+    className?: string,
+    icon?: Element<typeof Icon>,
+    classPrefix?: string,
+    pullLeft?: boolean,
+    onSelect?: Function,
+    title?: Node,
+    open?: boolean,
+    trigger?: TriggerType | Array<TriggerType>,
+    eventKey?: any,
+    onToggle?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    openKeys?: Array<any>,
+    expanded?: boolean,
+    collapsible?: boolean,
+    ...
+  }> {}
+
+  declare export class DropdownMenuItem extends React$Component<{
+    activeKey?: any,
+    className?: string,
+    children?: Node,
+    icon?: Element<typeof Icon>,
+    classPrefix?: string,
+    pullLeft?: boolean,
+    onSelect?: Function,
+    title?: Node,
+    open?: boolean,
+    trigger?: TriggerType | Array<TriggerType>,
+    eventKey?: any,
+    onToggle?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    openKeys?: Array<any>,
+    expanded?: boolean,
+    collapsible?: boolean,
+    ...
+  }> {}
+
+  declare export class DorpdownToggle extends React$Component<{
+    className?: string,
+    children?: Node,
+    icon?: Element<typeof Icon>,
+    renderTitle?: (children?: Node) => Node,
+    classPrefix?: string,
+    noCaret?: boolean,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class ErrorMessage extends React$Component<{
+    htmlFor?: string,
+    show?: boolean,
+    classPrefix?: string,
+    children?: Node,
+    className?: string,
+    placement?: PlacementEightPoints,
+    ...
+  }> {}
+
+  declare export class FlexboxGrid extends React$Component<{
+    className?: string,
+    align?: "top" | "middle" | "bottom",
+    justify?: "start" | "end" | "center" | "space-around" | "space-between",
+    classPrefix?: string,
+    ...
+  }> {
+    static Item: Class<FlexboxGridItem>;
+  }
+
+  declare export class FlexboxGridItem extends React$Component<{
+    className?: string,
+    colspan?: number,
+    order?: number,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Footer extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Form extends React$Component<{
+    className?: string,
+    layout?: "horizontal" | "vertical" | "inline",
+    fluid?: boolean,
+    formValue?: Object,
+    formDefaultValue?: Object,
+    formError?: Object,
+    checkDelay?: number,
+    checkTrigger?: "change" | "blur" | "none",
+    onChange?: (formValue: Object, event: SyntheticEvent<any>) => void,
+    onError?: (formError: Object) => void,
+    onCheck?: (formError: Object) => void,
+    model?: typeof Schema,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Icon extends React$Component<{
+    icon: string | SVGIcon,
+    className?: string,
+    classPrefix?: string,
+    componentClass?: ElementType,
+    size?: "lg" | "2x" | "3x" | "4x" | "5x",
+    flip?: "horizontal" | "vertical",
+    stack?: "1x" | "2x",
+    rotate?: number,
+    fixedWidth?: boolean,
+    svgStyle?: Object,
+    spin?: boolean,
+    pulse?: boolean,
+    ...
+  }> {}
+
+  declare export class IntlProvider extends React$Component<{
+    locale?: Object,
+    children?: Node,
+    ...
+  }> {}
+
+  declare export class FormControl extends React$Component<{
+    name: string,
+    checkTrigger?: "change" | "blur" | "none",
+    accepter?: ElementType,
+    onChange?: (value: any, event: SyntheticEvent<any>) => void,
+    onBlur?: (event: SyntheticEvent<any>) => void,
+    classPrefix?: string,
+    errorMessage?: Node,
+    errorPlacement?: PlacementEightPoints,
+    ...
+  }> {}
+
+  declare export class FormGroup extends React$Component<{
+    controlId?: string,
+    isValid?: boolean,
+    className?: string,
+    classPrefix?: string,
+    validationState?: "success" | "warning" | "error",
+    ...
+  }> {}
+
+  declare export class Grid extends React$Component<{
+    className?: string,
+    fluid?: boolean,
+    classPrefix?: string,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Header extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class HelpBlock extends React$Component<{
+    className?: string,
+    htmlFor?: string,
+    tooltip?: boolean,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class IconButton extends React$Component<{
+    className?: string,
+    icon?: Element<typeof Icon>,
+    classPrefix?: string,
+    circle?: boolean,
+    children?: Node,
+    placement?: "left" | "right",
+    ...
+  }> {}
+
+  declare export class Input extends React$Component<{
+    type?: string,
+    componentClass?: ElementType,
+    id?: string,
+    classPrefix?: string,
+    className?: string,
+    disabled?: boolean,
+    value?: string | number,
+    defaultValue?: string | number,
+    inputRef?: ElementRef<any>,
+    onChange?: (
+      value: any,
+      event: SyntheticInputEvent<HTMLInputElement>
+    ) => void,
+    onFocus?: (event: SyntheticEvent<any>) => void,
+    onBlur?: (event: SyntheticEvent<any>) => void,
+    onKeyDown?: (event: SyntheticEvent<any>) => void,
+    onPressEnter?: (event: SyntheticEvent<any>) => void,
+    ...
+  }> {}
+
+  declare export class InputGroup extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    inside?: boolean,
+    disabled?: boolean,
+    ...
+  }> {
+    static Addon: Class<InputGroupAddon>;
+    static Button: Class<InputGroupButton>;
+  }
+
+  declare export class InputGroupAddon extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    disabled?: boolean,
+    ...
+  }> {}
+
+  declare export class InputGroupButton extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class InputNumber extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    min?: number,
+    max?: number,
+    step?: number,
+    value?: number | string,
+    defaultValue?: number | string,
+    prefix?: Node,
+    postfix?: Node,
+    disabled?: boolean,
+    size?: "lg" | "md" | "sm" | "xs",
+    onWheel?: (event?: SyntheticEvent<any>) => void,
+    onChange?: (value: any, event?: SyntheticEvent<any>) => void,
+    buttonAppearance?: "default" | "primary" | "link" | "subtle" | "ghost",
+    ...
+  }> {}
+
+  declare export class Loader extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    center?: boolean,
+    backdrop?: boolean,
+    inverse?: boolean,
+    vertical?: boolean,
+    content?: Node,
+    speed?: "normal" | "fast" | "slow",
+    ...
+  }> {}
+
+  declare export class Message extends React$Component<{
+    type?: Types,
+    className?: string,
+    onClose?: () => void,
+    closable?: boolean,
+    closeLabel?: string,
+    title?: Node,
+    description?: Node,
+    showIcon?: boolean,
+    full?: boolean,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Modal extends React$Component<{
+    classPrefix?: string,
+    size?: Size,
+    container?: ElementType | Function,
+    onRendered?: Function,
+    className?: string,
+    dialogClassName?: string,
+    backdropClassName?: string,
+    style?: Object,
+    dialogStyle?: Object,
+    backdropStyle?: Object,
+    show?: boolean,
+    full?: boolean,
+    backdrop?: boolean | "static",
+    keyboard?: boolean,
+    transition?: ElementType,
+    dialogTransitionTimeout?: number,
+    backdropTransitionTimeout?: number,
+    autoFocus?: boolean,
+    enforceFocus?: boolean,
+    overflow?: boolean,
+    drawer?: boolean,
+    animation?: boolean,
+    dialogComponentClass?: ElementType,
+    onEscapeKeyUp?: Function,
+    onBackdropClick?: Function,
+    onShow?: Function,
+    onHide?: Function,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    ...
+  }> {
+    static Body: Class<ModalBody>;
+    static Header: Class<ModalHeader>;
+    static Title: Class<ModalTitle>;
+    static Footer: Class<ModalFooter>;
+    static Dialog: Class<ModalDialog>;
+  }
+
+  declare export class ModalBody extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class ModalDialog extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    dialogClassName?: string,
+    style?: Object,
+    dialogStyle?: Object,
+    ...
+  }> {}
+
+  declare export class ModalFooter extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class ModalHeader extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    closeButton?: boolean,
+    onHide?: Function,
+    ...
+  }> {}
+
+  declare export class ModalTitle extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Nav extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    appearance?: "default" | "subtle" | "tabs",
+    reversed?: boolean,
+    justified?: boolean,
+    vertical?: boolean,
+    pullRight?: boolean,
+    activeKey?: any,
+    onSelect?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    ...
+  }> {
+    static Item: Class<NavItem>;
+  }
+
+  declare export class NavItem extends React$Component<{
+    active?: boolean,
+    disabled?: boolean,
+    className?: string,
+    classPrefix?: string,
+    divider?: boolean,
+    panel?: boolean,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    style?: Object,
+    icon?: Element<typeof Icon>,
+    onSelect?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    eventKey?: any,
+    tabIndex?: number,
+    hasTooltip?: boolean,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Navbar extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    appearance?: "default" | "inverse" | "subtle",
+    componentClass?: ElementType,
+    hasChildContext?: boolean,
+    ...
+  }> {
+    static Body: Class<NavbarBody>;
+    static Header: Class<NavbarHeader>;
+  }
+
+  declare export class NavbarBody extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    children?: Node,
+    ...
+  }> {}
+
+  declare export class NavbarHeader extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class Pagination extends React$Component<{
+    activePage?: number,
+    pages?: number,
+    maxButtons?: number,
+    boundaryLinks?: boolean,
+    ellipsis?: boolean | Node,
+    first?: boolean | Node,
+    last?: boolean | Node,
+    prev?: boolean | Node,
+    next?: boolean | Node,
+    onSelect?: (event: SyntheticEvent<any>) => void,
+    buttonComponentClass?: ElementType | string,
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Panel extends React$Component<{
+    collapsible?: boolean,
+    bordered?: boolean,
+    bodyFill?: boolean,
+    header?: any,
+    id?: string | number,
+    defaultExpanded?: boolean,
+    expanded?: boolean,
+    eventKey?: any,
+    headerRole?: string,
+    panelRole?: string,
+    classPrefix?: string,
+    children?: Node,
+    onSelect?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class PanelGroup extends React$Component<{
+    accordion?: boolean,
+    activeKey?: any,
+    bordered?: boolean,
+    defaultActiveKey?: any,
+    className?: string,
+    children?: Node,
+    classPrefix?: string,
+    onSelect?: (eventKey: any, event: SyntheticEvent<any>) => void,
+    ...
+  }> {}
+
+  declare export class Popover extends React$Component<{
+    placement?: PlacementFourSides | Placement,
+    classPrefix?: string,
+    children?: Node,
+    title?: Node,
+    visible?: boolean,
+    className?: string,
+    full?: boolean,
+    onMouseLeave?: (event: SyntheticEvent<any>) => void,
+    onMouseEnter?: (event: SyntheticEvent<any>) => void,
+    ...
+  }> {}
+
+  declare export class ProgressCircle extends React$Component<{
+    className?: string,
+    strokeColor?: string,
+    strokeLinecap?: "butt" | "round" | "square",
+    trailColor?: string,
+    percent?: number,
+    strokeWidth?: number,
+    trailWidth?: number,
+    gapDegree?: number,
+    gapPosition?: "top" | "bottom" | "left" | "right",
+    showInfo?: boolean,
+    status?: "success" | "fail" | "active",
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class ProgressLine extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    percent?: number,
+    strokeColor?: string,
+    strokeWidth?: number,
+    trailColor?: string,
+    trailWidth?: number,
+    showInfo?: boolean,
+    status?: "success" | "fail" | "active",
+    ...
+  }> {}
+
+  declare export class Radio extends React$Component<{
+    id?: string,
+    name?: string,
+    inline?: boolean,
+    title?: string,
+    disabled?: boolean,
+    checked?: boolean,
+    defaultChecked?: boolean,
+    inputRef?: ElementRef<any>,
+    children?: Node,
+    className?: string,
+    classPrefix?: string,
+    value?: any,
+    onChange?: (
+      value: any,
+      checked: boolean,
+      event: SyntheticInputEvent<HTMLInputElement>
+    ) => void,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    tabIndex?: number,
+    ...
+  }> {}
+
+  declare export class RadioGroup extends React$Component<{
+    name?: string,
+    inline?: boolean,
+    value?: any,
+    defaultValue?: any,
+    className?: string,
+    classPrefix?: string,
+    children?: Node,
+    onChange?: (
+      value: any,
+      event: SyntheticInputEvent<HTMLInputElement>
+    ) => void,
+    ...
+  }> {}
+
+  declare export class Row extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    gutter?: number,
+    style?: Object,
+    componentClass?: ElementType,
+    children?: Node,
+    ...
+  }> {}
+
+  declare export class SafeAnchor extends React$Component<{
+    href?: string,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    disabled?: boolean,
+    role?: string,
+    style?: Object,
+    tabIndex?: number | string,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Sidebar extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    width?: number | string,
+    collapsible?: boolean,
+    ...
+  }> {}
+
+  declare export class Sidenav extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    expanded?: boolean,
+    appearance?: "default" | "inverse" | "subtle",
+    defaultOpenKeys?: Array<any>,
+    openKeys?: Array<any>,
+    onOpenChange?: (openKeys: Array<any>, event: SyntheticEvent<any>) => void,
+    activeKey?: any,
+    onSelect?: (eventKey: Array<any>, event: SyntheticEvent<any>) => void,
+    componentClass?: ElementType,
+    ...
+  }> {
+    static Header: Class<SidenavHeader>;
+    static Body: Class<SidenavBody>;
+    static Toggle: Class<SidenavToggle>;
+  }
+
+  declare export class SidenavBody extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class SidenavHeader extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class SidenavToggle extends React$Component<{
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class Slider extends React$Component<{
+    min?: number,
+    max?: number,
+    step?: number,
+    value?: number,
+    defaultValue?: number,
+    className?: string,
+    classPrefix?: string,
+    handleClassName?: string,
+    handleTitle?: Node,
+    barClassName?: string,
+    hanldeStyle?: Object,
+    disabled?: boolean,
+    graduated?: boolean,
+    tooltip?: boolean,
+    progress?: boolean,
+    vertical?: boolean,
+    onChange?: (value: number) => void,
+    renderMark?: (mark: number) => Node,
+    ...
+  }> {}
+
+  declare export class StepItem extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    itemWidth?: number | string,
+    status?: "finish" | "wait" | "process" | "error",
+    icon?: Element<typeof Icon>,
+    stepNumber?: number,
+    description?: Node,
+    title?: Node,
+    ...
+  }> {}
+
+  declare export class Steps extends React$Component<{
+    classPrefix?: string,
+    vertical?: boolean,
+    small?: boolean,
+    className?: string,
+    current?: number,
+    currentStatus?: "finish" | "wait" | "process" | "error",
+    ...
+  }> {
+    static Item: Class<StepItem>;
+  }
+
+  declare export class TableColumn extends React$Component<{
+    align?: "left" | "center" | "right",
+    width?: number,
+    fixed?: boolean,
+    resizable?: boolean,
+    sortable?: boolean,
+    flexGrow?: number,
+    minWidth?: number,
+    colSpan?: number,
+    ...
+  }> {}
+
+  declare export class TableCell extends React$Component<{
+    align?: "left" | "center" | "right",
+    className?: string,
+    classPrefix?: string,
+    dataKey?: string,
+    isHeaderCell?: boolean,
+    width?: number,
+    height?: number,
+    left?: number,
+    headerHeight?: number,
+    style?: Object,
+    firstColumn?: boolean,
+    lastColumn?: boolean,
+    hasChildren?: boolean,
+    children?: Node,
+    rowKey?: string | number,
+    rowIndex?: number,
+    rowData?: Object,
+    layer?: number,
+    onTreeToggle?: (
+      rowKey?: string | number,
+      rowIndex?: number,
+      rowData?: Object,
+      event?: SyntheticEvent<any>
+    ) => void,
+    renderTreeToggle?: (
+      expandButton: Node,
+      rowData?: Object
+    ) => Node,
+    renderCell?: (contentChildren: Node) => Node,
+    wordWrap?: boolean,
+    removed?: boolean,
+    ...
+  }> {}
+
+  declare export class TableHeaderCell extends React$Component<{
+    width?: number,
+    dataKey?: string,
+    left?: number,
+    className?: string,
+    classPrefix?: string,
+    headerHeight?: number,
+    children?: Node,
+    index?: number,
+    sortColumn?: string,
+    sortType?: "desc" | "asc",
+    sortable?: boolean,
+    resizable?: boolean,
+    onColumnResizeStart?: (
+      columnWidth?: number,
+      left?: number,
+      fixed?: boolean
+    ) => void,
+    onColumnResizeEnd?: (
+      columnWidth?: number,
+      cursorDelta?: number,
+      dataKey?: any,
+      index?: number
+    ) => void,
+    onColumnResizeMove?: (
+      columnWidth?: number,
+      columnLeft?: number,
+      columnFixed?: boolean
+    ) => void,
+    onSortColumn?: Function,
+    flexGrow?: number,
+    fixed?: boolean,
+    ...
+  }> {}
+
+  declare export class TablePagination extends React$Component<{
+    lengthMenu?: Array<{
+      value: number,
+      label: Node,
+      ...
+    }>,
+    showLengthMenu?: boolean,
+    showInfo?: boolean,
+    total: number,
+    displayLength?: number,
+    renderLengthMenu?: (picker: Node) => Node,
+    renderTotal?: Function,
+    onChangePage?: Function,
+    onChangeLength?: Function,
+    prev?: boolean,
+    next?: boolean,
+    first?: boolean,
+    last?: boolean,
+    maxButtons?: number,
+    activePage?: number,
+    className?: string,
+    classPrefix?: string,
+    ...
+  }> {}
+
+  declare export class Table extends React$Component<{
+    data: Array<Object>,
+    width?: number,
+    height?: number,
+    autoHeight?: boolean,
+    minHeight?: number,
+    rowHeight?: number,
+    headerHeight?: number,
+    setRowHeight?: (rowData: Object) => number,
+    rowKey?: string | number,
+    isTree?: boolean,
+    defaultExpandAllRows?: boolean,
+    defaultExpandedRowKeys?: Array<string | number>,
+    expandedRowKeys?: Array<string | number>,
+    renderTreeToggle?: (
+      expandButton: Node,
+      rowData: Object
+    ) => Node,
+    renderRowExpanded?: (rowDate?: Object) => Node,
+    rowExpandedHeight?: number,
+    style?: Object,
+    sortColumn?: string,
+    sortType?: "desc" | "asc",
+    disabledScroll?: boolean,
+    hover?: boolean,
+    loading?: boolean,
+    className?: string,
+    classPrefix?: string,
+    children?: mixed,
+    bordered?: boolean,
+    cellBordered?: boolean,
+    wordWrap?: boolean,
+    onRowClick?: (rowData: Object) => void,
+    onScroll?: (scrollX: number, scrollY: number) => void,
+    onSortColumn?: (dataKey: string, sortType: "desc" | "asc") => void,
+    onExpandChange?: (expanded: boolean, rowData: Object) => void,
+    // for tests
+    onTouchStart?: (event: SyntheticTouchEvent<any>) => void,
+    // for tests
+    onTouchMove?: (event: SyntheticTouchEvent<any>) => void,
+    bodyRef?: ElementRef<any>,
+    loadAnimation?: boolean,
+    showHeader?: boolean,
+    ...
+  }> {
+    static Column: Class<TableColumn>;
+    static Cell: Class<TableCell>;
+    static HeaderCell: Class<TableHeaderCell>;
+    static Pagination: Class<TablePagination>;
+  }
+
+  declare export class Tag extends React$Component<{
+    closable?: boolean,
+    classPrefix?: string,
+    onClose?: (event: SyntheticEvent<any>) => void,
+    children?: Node,
+    className?: string,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Timeline extends React$Component<{
+    className?: string,
+    classPrefix?: string,
+    children?: Node,
+    componentClass?: ElementType,
+    ...
+  }> {
+    static Item: Class<TimelineItem>;
+  }
+
+  declare export class TimelineItem extends React$Component<{
+    last?: boolean,
+    dot?: Node,
+    className?: string,
+    children?: Node,
+    classPrefix?: string,
+    componentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Toggle extends React$Component<{
+    disabled?: boolean,
+    checked?: boolean,
+    defaultChecked?: boolean,
+    onChange?: (checked: boolean, event: SyntheticEvent<any>) => void,
+    checkedChildren?: Node,
+    unCheckedChildren?: Node,
+    classPrefix?: string,
+    className?: string,
+    ...
+  }> {}
+
+  declare export class Tooltip extends React$Component<{
+    placement?: PlacementFourSides | Placement,
+    positionLeft?: number,
+    positionTop?: number,
+    visible?: boolean,
+    classPrefix?: string,
+    className?: string,
+    children?: Node,
+    onMouseLeave?: (event: SyntheticEvent<any>) => void,
+    onMouseEnter?: (event: SyntheticEvent<any>) => void,
+    ...
+  }> {}
+
+  declare export type FileType = {
+    name: string,
+    fileKey: number | string,
+    // https://developer.mozilla.org/zh-CN/docs/Web/API/File
+    blobFile?: File,
+    status?: "inited" | "uploading" | "error" | "finished",
+    progress?: number,
+    ...
+  };
+
+  declare export class Uploader extends React$Component<{
+    action: string,
+    accept?: string,
+    autoUpload?: boolean,
+    children?: Element<any>,
+    className?: string,
+    classPrefix?: string,
+    defaultFileList?: Array<FileType>,
+    fileList?: Array<FileType>,
+    data?: Object,
+    multiple?: boolean,
+    disabled?: boolean,
+    disabledFileItem?: boolean,
+    name?: string,
+    timeout?: number,
+    withCredentials?: boolean,
+    headers?: Object,
+    listType?: "text" | "picture-text" | "picture",
+    shouldQueueUpdate?: (
+      fileList: Array<FileType>,
+      newFile: Array<FileType> | FileType
+    ) => boolean,
+    shouldUpload?: (file: FileType) => boolean,
+    onChange?: (fileList: Array<FileType>) => void,
+    onUpload?: (file: FileType) => void,
+    onReupload?: (file: FileType) => void,
+    onPreview?: (file: FileType, event: SyntheticEvent<any>) => void,
+    onError?: (
+      status: Object,
+      file: FileType,
+      event: SyntheticEvent<any>
+    ) => void,
+    onSuccess?: (
+      response: Object,
+      file: FileType,
+      event: SyntheticEvent<any>
+    ) => void,
+    onProgress?: (
+      percent: number,
+      file: FileType,
+      event: SyntheticEvent<any>
+    ) => void,
+    onRemove?: (file: FileType) => void,
+    maxPreviewFileSize?: number,
+    toggleComponentClass?: ElementType,
+    ...
+  }> {}
+
+  declare export class Whisper extends React$Component<{
+    target?: Function,
+    container?: HTMLElement | (() => HTMLElement),
+    containerPadding?: number,
+    placement?: Placement,
+    show?: boolean,
+    rootClose?: boolean,
+    onHide?: Function,
+    transition?: ElementType,
+    onEnter?: Function,
+    onEntering?: Function,
+    onEntered?: Function,
+    onExit?: Function,
+    onExiting?: Function,
+    onExited?: Function,
+    animation?: ElementType | boolean,
+    trigger?: WhisperTriggerType | Array<WhisperTriggerType>,
+    delay?: number,
+    delayShow?: number,
+    delayHide?: number,
+    defaultOpen?: boolean,
+    open?: boolean,
+    speaker: Element<any>,
+    children: Node,
+    onMouseOver?: (event: SyntheticEvent<any>) => void,
+    onMouseOut?: (event: SyntheticEvent<any>) => void,
+    onClick?: (event: SyntheticEvent<any>) => void,
+    onBlur?: (event: SyntheticEvent<any>) => void,
+    onFocus?: (event: SyntheticEvent<any>) => void,
+    disabled?: boolean,
+    ...
+  }> {}
+
+  declare export var Progress: {
+    Line: Class<ProgressLine>,
+    Circle: Class<ProgressCircle>,
+    ...
+  };
+
+  declare type NotificationConfig = {
+    title: Node,
+    description: ElementType,
+    duration?: number,
+    placement?: string,
+    top?: number,
+    bottom?: number,
+    onClose?: () => void,
+    style?: Object,
+    key?: string,
+    ...
+  };
+
+  declare export var Notification: {
+    open: (config: NotificationConfig) => void,
+    info: (config: NotificationConfig) => void,
+    success: (config: NotificationConfig) => void,
+    warning: (config: NotificationConfig) => void,
+    error: (config: NotificationConfig) => void,
+    remove: (key: string) => void,
+    ...
+  };
+
+  declare export var Alert: {
+    info: (content: string, duration?: number, onClose?: () => void) => void,
+    success: (content: string, duration?: number, onClose?: () => void) => void,
+    warning: (content: string, duration?: number, onClose?: () => void) => void,
+    error: (content: string, duration?: number, onClose?: () => void) => void,
+    config: (options: {
+      top?: number,
+      duration?: number,
+      getContainer?: () => HTMLElement,
+      ...
+    }) => void,
+    ...
+  };
+
+  declare export class Transition extends React$Component<{
+    children?: Node,
+    className?: string,
+    in?: boolean,
+    unmountOnExit?: boolean,
+    transitionAppear?: boolean,
+    timeout?: number,
+    exitedClassName?: string,
+    exitingClassName?: string,
+    enteredClassName?: string,
+    enteringClassName?: string,
+    onEnter?: (node: null | HTMLElement | Text) => void,
+    onEntering?: (node: null | HTMLElement | Text) => void,
+    onEntered?: (node: null | HTMLElement | Text) => void,
+    onExit?: (node: null | HTMLElement | Text) => void,
+    onExiting?: (node: null | HTMLElement | Text) => void,
+    onExited?: (node: null | HTMLElement | Text) => void,
+    ...
+  }> {}
+
+  declare export class Fade extends React$Component<{
+    timeout?: number,
+    className?: string,
+    in?: boolean,
+    ...
+  }> {}
+
+  declare export class Collapse extends React$Component<{
+    in?: boolean,
+    timeout?: number,
+    className?: string,
+    onEnter?: (node: null | HTMLElement | Text) => void,
+    onEntering?: (node: null | HTMLElement | Text) => void,
+    onEntered?: (node: null | HTMLElement | Text) => void,
+    onExit?: (node: null | HTMLElement | Text) => void,
+    onExiting?: (node: null | HTMLElement | Text) => void,
+    onExited?: (node: null | HTMLElement | Text) => void,
+    dimension?: "height" | "width" | (() => "height" | "width"),
+    getDimensionValue?: (
+      dimension: "height" | "width",
+      elem: HTMLElement
+    ) => number,
+    role?: string,
+    exitedClassName?: string,
+    exitingClassName?: string,
+    enteredClassName?: string,
+    enteringClassName?: string,
+    ...
+  }> {}
+
+  declare export class Portal extends React$Component<{
+    container?: HTMLElement | (() => HTMLElement),
+    onRendered?: Function,
+    children?: Node,
+    ...
+  }> {}
+
+  declare export var Animation: {
+    Transition: Class<Transition>,
+    Fade: Class<Fade>,
+    Collapse: Class<Collapse>,
+    ...
+  };
+
+  declare class SchemaStringType {
+    constructor(errorMessage: string): SchemaStringType;
+    isRequired(errorMessage: string): SchemaStringType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaStringType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+    containsLetter(errorMessage: string): SchemaStringType;
+    containsUppercaseLetter(errorMessage: string): SchemaStringType;
+    containsLowercaseLetter(errorMessage: string): SchemaStringType;
+    containsLetterOnly(errorMessage: string): SchemaStringType;
+    containsNumber(errorMessage: string): SchemaStringType;
+    isOneOf(strArr: Array<string>, errorMessage: string): SchemaStringType;
+    isEmail(errorMessage: string): SchemaStringType;
+    isURL(errorMessage: string): SchemaStringType;
+    isHex(errorMessage: string): SchemaStringType;
+    pattern(regexp: RegExp, errorMessage: string): SchemaStringType;
+    rangeLength(
+      minLength: number,
+      maxLength: number,
+      errorMessage: string
+    ): SchemaStringType;
+
+    minLength(minLength: number, errorMessage: string): SchemaStringType;
+    maxLength(maxLength: number, errorMessage: string): SchemaStringType;
+  }
+
+  declare class SchemaNumberType {
+    constructor(errorMessage: string): SchemaNumberType;
+    isRequired(errorMessage: string): SchemaNumberType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaNumberType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+    pattern(regexp: RegExp, errorMessage: string): SchemaNumberType;
+    isInteger(errorMessage: string): SchemaNumberType;
+    isOneOf(items: Array<number>, errorMessage: string): SchemaNumberType;
+    range(
+      minLength: number,
+      maxLength: number,
+      errorMessage: string
+    ): SchemaNumberType;
+    min(min: number, errorMessage: string): SchemaNumberType;
+    max(min: number, errorMessage: string): SchemaNumberType;
+  }
+
+  declare class SchemaArrayType {
+    constructor(errorMessage: string): SchemaArrayType;
+    isRequired(errorMessage: string): SchemaArrayType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaArrayType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+    rangeLength(
+      minLength: number,
+      maxLength: number,
+      errorMessage: string
+    ): SchemaArrayType;
+    minLength(minLength: number, errorMessage: string): SchemaArrayType;
+    maxLength(maxLength: number, errorMessage: string): SchemaArrayType;
+    unrepeatable(errorMessage: string): SchemaArrayType;
+    of(type: any, errorMessage: string): SchemaArrayType;
+  }
+
+  declare class SchemaDateType {
+    constructor(errorMessage: string): SchemaDateType;
+    isRequired(errorMessage: string): SchemaDateType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaDateType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+    range(min: Date, max: Date, errorMessage: string): SchemaDateType;
+    min(min: Date, errorMessage: string): SchemaDateType;
+    max(max: Date, errorMessage: string): SchemaDateType;
+  }
+
+  declare class SchemaObjectType {
+    constructor(errorMessage: string): SchemaObjectType;
+    isRequired(errorMessage: string): SchemaObjectType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaObjectType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+    shape(types: Object, errorMessage: string): SchemaObjectType;
+  }
+
+  declare class SchemaBooleanType {
+    constructor(errorMessage: string): SchemaBooleanType;
+    isRequired(errorMessage: string): SchemaBooleanType;
+    addRule((value: any) => boolean, errorMessage: string): SchemaBooleanType;
+    check(
+      value: any
+    ): {
+      hasError: boolean,
+      errorMessage: string,
+      ...
+    };
+  }
+
+  declare export var Schema: {
+    Model: Object,
+    Types: {
+      StringType: (errorMessage: string) => SchemaStringType,
+      NumberType: (errorMessage: string) => SchemaNumberType,
+      ArrayType: (errorMessage: string) => SchemaArrayType,
+      DateType: (errorMessage: string) => SchemaDateType,
+      ObjectType: (errorMessage: string) => SchemaObjectType,
+      BooleanType: (errorMessage: string) => SchemaBooleanType,
+      ...
+    },
+    ...
+  };
+
+  declare export var DOMHelper: {
+    hasClass: (node: HTMLElement, className: string) => boolean,
+    addClass: (node: HTMLElement, className: string) => HTMLElement,
+    removeClass: (node: HTMLElement, className: string) => HTMLElement,
+    toggleClass: (node: HTMLElement, className: string) => HTMLElement,
+    getStyle: Function,
+    removeStyle: Function,
+    addStyle: Function,
+    translateDOMPositionXY: (style: Object, x: number, y: number) => Object,
+    on: (
+      target: HTMLElement,
+      eventName: string,
+      listener: Function,
+      capture?: boolean
+    ) => { off: Function, ... },
+    off: (
+      target: HTMLElement,
+      eventName: string,
+      listener: Function,
+      capture?: boolean
+    ) => void,
+    activeElement: () => HTMLElement,
+    getHeight: (node: HTMLElement, client?: HTMLElement) => number,
+    getWidth: (node: HTMLElement, client?: HTMLElement) => number,
+    getOffset: (node: HTMLElement) => Object,
+    getOffsetParent: (node: HTMLElement) => Object,
+    getPosition: (node: HTMLElement, offsetParent?: Object) => Object,
+    getWindow: (node: HTMLElement) => String,
+    nodeName: (node: HTMLElement) => String,
+    ownerDocument: (node: HTMLElement) => Object,
+    ownerWindow: (node: HTMLElement) => Object,
+    contains: (context: HTMLElement, node: HTMLElement) => boolean,
+    scrollLeft: (node: HTMLElement, val?: number) => number | void,
+    scrollTop: (node: HTMLElement, val?: number) => number | void,
+    DOMMouseMoveTracker: Function,
+    ...
+  };
+}
+
+declare module "rsuite/lib/IntlProvider/locales/en_GB" {
+  declare module.exports: any;
+}
+declare module "rsuite/lib/IntlProvider/locales/en_GB.js" {
+  declare module.exports: $Exports<"rsuite/lib/IntlProvider/locales/en_GB">;
+}
+
+declare module "rsuite/lib/IntlProvider/locales/en_US" {
+  declare module.exports: any;
+}
+declare module "rsuite/lib/IntlProvider/locales/en_US.js" {
+  declare module.exports: $Exports<"rsuite/lib/IntlProvider/locales/en_US">;
+}
+
+declare module "rsuite/lib/IntlProvider/locales/zh_CN" {
+  declare module.exports: any;
+}
+declare module "rsuite/lib/IntlProvider/locales/zh_CN.js" {
+  declare module.exports: $Exports<"rsuite/lib/IntlProvider/locales/zh_CN">;
+}
+
+declare module "rsuite/lib/IntlProvider/locales/zh_TW" {
+  declare module.exports: any;
+}
+declare module "rsuite/lib/IntlProvider/locales/zh_TW.js" {
+  declare module.exports: $Exports<"rsuite/lib/IntlProvider/locales/zh_TW">;
+}
diff --git a/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/test_rsuite_v3.x.x.js b/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/test_rsuite_v3.x.x.js
new file mode 100644
index 0000000000..c111d21b69
--- /dev/null
+++ b/definitions/npm/rsuite_v3.x.x/flow_v0.201.x-/test_rsuite_v3.x.x.js
@@ -0,0 +1,477 @@
+import { describe, it } from "flow-typed-test";
+import * as React from "react";
+import {
+  Button,
+  IconButton,
+  ButtonToolbar,
+  ButtonGroup,
+  Whisper,
+  Tooltip,
+  Popover,
+  Modal,
+  Alert,
+  Notification,
+  Message,
+  Drawer,
+  Loader,
+  Icon,
+  SafeAnchor,
+  Divider,
+  Dropdown,
+  Nav,
+  Navbar,
+  Sidenav,
+  Breadcrumb,
+  Pagination,
+  Steps,
+  Toggle,
+  Form,
+  FormGroup,
+  ErrorMessage,
+  ControlLabel,
+  HelpBlock,
+  FormControl,
+  Input,
+  InputNumber,
+  InputGroup,
+  Checkbox,
+  CheckboxGroup,
+  Radio,
+  RadioGroup,
+  SelectPicker,
+  CheckPicker,
+  InputPicker,
+  TagPicker,
+  TreePicker,
+  CheckTreePicker,
+  Cascader,
+  DatePicker,
+  DateRangePicker,
+  AutoComplete,
+  Uploader,
+  Slider,
+  Tree,
+  CheckTree,
+  Panel,
+  PanelGroup,
+  Table,
+  TablePagination,
+  Progress,
+  Timeline,
+  Tag,
+  Grid,
+  Row,
+  Col,
+  FlexboxGrid,
+  Container,
+  Content,
+  Header,
+  Sidebar,
+  Footer,
+  Schema,
+  Animation,
+  Portal,
+  DOMHelper,
+  IntlProvider
+} from "rsuite";
+
+const {
+  addClass,
+  hasClass,
+  removeClass,
+  toggleClass,
+  addStyle,
+  removeStyle,
+  getStyle,
+  translateDOMPositionXY,
+  on,
+  off,
+  scrollLeft,
+  scrollTop,
+  getHeight,
+  getWidth,
+  getOffset,
+  getOffsetParent,
+  getPosition,
+  contains,
+  DOMMouseMoveTracker
+} = DOMHelper;
+
+<Button appearance="default">test</Button>;
+//$FlowExpectedError
+<Button appearance="test">test</Button>;
+
+<Cascader data={[]} />;
+//$FlowExpectedError
+<Cascader />;
+
+<CheckTreePicker data={[]} />;
+//$FlowExpectedError
+<CheckTreePicker />;
+
+<TreePicker data={[]} />;
+//$FlowExpectedError
+<TreePicker />;
+
+<Tree data={[]} />;
+//$FlowExpectedError
+<Tree />;
+
+<CheckTree data={[]} />;
+//$FlowExpectedError
+<CheckTree />;
+
+<DatePicker />;
+
+//$FlowExpectedError
+<DatePicker value={"10/10/2018"} />;
+
+<DateRangePicker />;
+
+//$FlowExpectedError
+<DateRangePicker value={["10/10/2018", "10/10/2018"]} />;
+
+<InputPicker data={[]} />;
+//$FlowExpectedError
+<InputPicker />;
+
+<TagPicker data={[]} />;
+//$FlowExpectedError
+<TagPicker />;
+
+<SelectPicker data={[]} />;
+//$FlowExpectedError
+<SelectPicker />;
+
+<AutoComplete data={[]} />;
+//$FlowExpectedError
+<AutoComplete />;
+
+<Breadcrumb.Item />;
+//$FlowExpectedError
+<Breadcrumb.Item active="a" />;
+
+<Breadcrumb>
+  <Breadcrumb.Item>test</Breadcrumb.Item>
+</Breadcrumb>;
+
+<Breadcrumb>
+  <Breadcrumb.Item>item1</Breadcrumb.Item>
+  <Breadcrumb.Item>item2</Breadcrumb.Item>
+</Breadcrumb>;
+
+
+<Button />;
+//$FlowExpectedError
+<Button active="a" />;
+
+<ButtonGroup />;
+<ButtonToolbar />;
+
+<Checkbox
+  inputRef={ref => {
+    (ref: ?HTMLInputElement);
+  }}
+/>;
+
+<CheckboxGroup
+  value={["a"]}
+  onChange={value => {
+    (value: Array<any>);
+  }}
+>
+  <Checkbox value="a">A</Checkbox>
+  <Checkbox value="b">B</Checkbox>
+</CheckboxGroup>;
+
+<Col />;
+
+//$FlowExpectedError
+<Col xs="1" />;
+
+<Container />;
+<Content />;
+<ControlLabel />;
+<Divider />;
+<Drawer />;
+
+<Drawer>
+  <Drawer.Header>1</Drawer.Header>
+  <Drawer.Body>2</Drawer.Body>
+  <Drawer.Title>3</Drawer.Title>
+  <Drawer.Footer>4</Drawer.Footer>
+  <Drawer.Dialog>5</Drawer.Dialog>
+</Drawer>;
+
+<Dropdown>
+  <Dropdown.Item>1</Dropdown.Item>
+  <Dropdown.Item>2</Dropdown.Item>
+  <Dropdown.Menu>
+    <Dropdown.Item>3</Dropdown.Item>
+    <Dropdown.Item>4</Dropdown.Item>
+  </Dropdown.Menu>
+</Dropdown>;
+
+<ErrorMessage>error</ErrorMessage>;
+
+<FlexboxGrid />;
+//$FlowExpectedError
+<FlexboxGrid align="abc" />;
+
+<FlexboxGrid>
+  <FlexboxGrid.Item>a</FlexboxGrid.Item>
+</FlexboxGrid>;
+
+<Footer />;
+
+<Form />;
+//$FlowExpectedError
+<Form layout="abc" />;
+
+<Form>
+  <FormControl name="username" />
+</Form>;
+
+<Icon icon="user" />;
+
+//$FlowExpectedError
+<Icon />;
+
+//$FlowExpectedError
+<Icon icon="user" size="100" />;
+
+<IntlProvider />;
+
+<FormControl name="username" />;
+
+//$FlowExpectedError
+<FormControl />;
+
+<FormGroup />;
+<Grid />;
+<Header />;
+<HelpBlock />;
+<IconButton />;
+<Input
+  onChange={(value: string) => {
+    (value: string);
+  }}
+/>;
+<InputGroup />;
+<InputGroup>
+  <InputGroup.Addon />
+  <Input />
+  <InputGroup.Button />
+</InputGroup>;
+
+<InputNumber />;
+
+//$FlowExpectedError
+<InputNumber value={[]} />;
+
+<Loader />;
+
+//$FlowExpectedError
+<Loader speed="default" />;
+
+<Message>error</Message>;
+
+<Modal>
+  <Modal.Header>1</Modal.Header>
+  <Modal.Body>2</Modal.Body>
+  <Modal.Title>3</Modal.Title>
+  <Modal.Footer>4</Modal.Footer>
+  <Modal.Dialog>5</Modal.Dialog>
+</Modal>;
+
+<Nav />;
+
+<Nav>
+  <Nav.Item>a</Nav.Item>
+</Nav>;
+
+<Navbar />;
+
+<Navbar>
+  <Navbar.Header>1</Navbar.Header>
+  <Navbar.Body>2</Navbar.Body>
+</Navbar>;
+
+<Pagination />;
+<Panel />;
+<PanelGroup />;
+
+<PanelGroup>
+  <Panel>a</Panel>
+</PanelGroup>;
+
+<Popover />;
+
+<Progress.Circle />;
+
+//$FlowExpectedError
+<Progress.Circle status />;
+
+<Progress.Line />;
+
+//$FlowExpectedError
+<Progress.Line status />;
+
+<Radio />;
+<RadioGroup>
+  <Radio />
+</RadioGroup>;
+
+<Row />;
+
+<Row>
+  <Col>1</Col>
+</Row>;
+
+<Row>
+  <Col>2</Col>
+  <Col>3</Col>
+</Row>;
+
+<SafeAnchor href="http://" />;
+<Sidebar />;
+<Sidenav />;
+
+<Sidenav>
+  <Sidenav.Header />
+  <Sidenav.Body />
+  <Sidenav.Toggle />
+</Sidenav>;
+
+<Slider value={100} />;
+<Steps.Item />;
+<Steps>
+  <Steps.Item>1</Steps.Item>
+</Steps>;
+
+<Table data={[]}>
+  <Table.Column>
+    <Table.HeaderCell />
+    <Table.Cell />
+  </Table.Column>
+</Table>;
+
+<Table.Pagination total={100} activePage={1} />;
+
+//$FlowExpectedError
+<Table />;
+
+//$FlowExpectedError
+<Table.Pagination />;
+
+<Tag />;
+
+<Timeline />;
+
+<Timeline>
+  <Timeline.Item />
+</Timeline>;
+
+<Toggle
+  onChange={(checked: boolean) => {
+    (checked: boolean);
+  }}
+/>;
+
+<Tooltip />;
+
+<Uploader action="http://" />;
+
+//$FlowExpectedError
+<Uploader />;
+
+//$FlowExpectedError
+<Whisper />;
+
+//$FlowExpectedError
+<Whisper>
+  <a>a</a>
+</Whisper>;
+
+<Whisper speaker={<div>a</div>}>
+  <a>a</a>
+</Whisper>;
+
+//$FlowExpectedError
+Alert.info();
+
+Alert.info("message");
+Alert.success("message");
+Alert.warning("message");
+Alert.error("message");
+Alert.config({
+  top: 10,
+  duration: 100,
+  getContainer: () => {
+    return document.createElement("div");
+  }
+});
+
+//$FlowExpectedError
+Notification.info();
+
+Notification.open({ title: "title", description: "desc" });
+Notification.info({ title: "title", description: "desc" });
+Notification.success({ title: "title", description: "desc" });
+Notification.warning({ title: "title", description: "desc" });
+Notification.error({ title: "title", description: "desc" });
+Notification.remove("key");
+
+<Animation.Transition />;
+<Animation.Fade />;
+<Animation.Collapse />;
+
+<Portal />;
+
+const { Model, Types } = Schema;
+const {
+  StringType,
+  NumberType,
+  ArrayType,
+  DateType,
+  ObjectType,
+  BooleanType
+} = Types;
+
+StringType("error")
+  .isRequired("isRequired")
+  .containsLetter("")
+  .containsUppercaseLetter("")
+  .containsLowercaseLetter("")
+  .containsLetterOnly("")
+  .containsNumber("")
+  .isOneOf(["dd", "aa"], "")
+  .isEmail("")
+  .isURL("")
+  .isHex("")
+  .pattern(/\s/, "")
+  .rangeLength(1, 4, "")
+  .minLength(1, "")
+  .maxLength(4, "")
+  .addRule(() => true, "");
+
+//$FlowExpectedError
+StringType("error").maxLength();
+
+NumberType("error")
+  .isRequired("isRequired")
+  .isInteger("");
+
+ArrayType("error")
+  .isRequired("isRequired")
+  .rangeLength(1, 100, "");
+
+DateType("error")
+  .isRequired("isRequired")
+  .range(new Date(), new Date(), "");
+
+ObjectType("error")
+  .isRequired("isRequired")
+  .shape({}, "");
+
+BooleanType("error").isRequired("isRequired");
diff --git a/definitions/npm/rxjs_v5.0.x/flow_v0.153.x-/rxjs_v5.0.x.js b/definitions/npm/rxjs_v5.0.x/flow_v0.153.x-v.200.x/rxjs_v5.0.x.js
similarity index 100%
rename from definitions/npm/rxjs_v5.0.x/flow_v0.153.x-/rxjs_v5.0.x.js
rename to definitions/npm/rxjs_v5.0.x/flow_v0.153.x-v.200.x/rxjs_v5.0.x.js
diff --git a/definitions/npm/rxjs_v5.0.x/flow_v0.153.x-/test_rxjs.js b/definitions/npm/rxjs_v5.0.x/flow_v0.153.x-v.200.x/test_rxjs.js
similarity index 100%
rename from definitions/npm/rxjs_v5.0.x/flow_v0.153.x-/test_rxjs.js
rename to definitions/npm/rxjs_v5.0.x/flow_v0.153.x-v.200.x/test_rxjs.js
diff --git a/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/rxjs_v5.0.x.js b/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/rxjs_v5.0.x.js
new file mode 100644
index 0000000000..5feda4eea0
--- /dev/null
+++ b/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/rxjs_v5.0.x.js
@@ -0,0 +1,1649 @@
+type rxjs$PartialObserver<-T> =
+  | {
+  +next: (value: T) => mixed,
+  +error?: (error: any) => mixed,
+  +complete?: () => mixed,
+  ...
+}
+  | {
+  +next?: (value: T) => mixed,
+  +error: (error: any) => mixed,
+  +complete?: () => mixed,
+  ...
+}
+  | {
+  +next?: (value: T) => mixed,
+  +error?: (error: any) => mixed,
+  +complete: () => mixed,
+  ...
+};
+
+declare interface rxjs$ISubscription {
+  unsubscribe(): void;
+}
+
+type rxjs$TeardownLogic = rxjs$ISubscription | (() => void);
+
+type rxjs$EventListenerOptions =
+  | {
+  capture?: boolean,
+  passive?: boolean,
+  once?: boolean,
+  ...
+}
+  | boolean;
+
+type rxjs$ObservableInput<T> = rxjs$Observable<T> | Promise<T> | Iterable<T>;
+
+type rxjs$OperatorFunction<T, R> = (rxjs$Observable<T>) => rxjs$Observable<R>;
+type rxjs$OperatorFunctionLast<T, R: rxjs$Observable<any>> = (
+  rxjs$Observable<T>
+) => R;
+
+declare class rxjs$Observable<+T> {
+  static bindCallback(
+    callbackFunc: (callback: (_: void) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): () => rxjs$Observable<void>;
+  static bindCallback<U>(
+    callbackFunc: (callback: (result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): () => rxjs$Observable<U>;
+  static bindCallback<T, U>(
+    callbackFunc: (v1: T, callback: (result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T) => rxjs$Observable<U>;
+  static bindCallback<T, T2, U>(
+    callbackFunc: (v1: T, v2: T2, callback: (result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, U>(
+    callbackFunc: (v1: T, v2: T2, v3: T3, callback: (result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      callback: (result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, T5, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      callback: (result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, T5, T6, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      v6: T6,
+      callback: (result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable<U>;
+  static bindCallback<U>(
+    callbackFunc: (callback: (...args: Array<any>) => any) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): () => rxjs$Observable<U>;
+  static bindCallback<T, U>(
+    callbackFunc: (v1: T, callback: (...args: Array<any>) => any) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T) => rxjs$Observable<U>;
+  static bindCallback<T, T2, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      callback: (...args: Array<any>) => any
+    ) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      callback: (...args: Array<any>) => any
+    ) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      callback: (...args: Array<any>) => any
+    ) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, T5, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      callback: (...args: Array<any>) => any
+    ) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable<U>;
+  static bindCallback<T, T2, T3, T4, T5, T6, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      v6: T6,
+      callback: (...args: Array<any>) => any
+    ) => any,
+    selector: (...args: Array<any>) => U,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable<U>;
+  static bindCallback<T>(
+    callbackFunc: Function,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (...args: Array<any>) => rxjs$Observable<T>;
+  static bindCallback<T>(
+    callbackFunc: Function,
+    selector?: (...args: Array<any>) => T,
+    scheduler?: rxjs$SchedulerClass
+  ): (...args: Array<any>) => rxjs$Observable<T>;
+
+  static bindNodeCallback<U>(
+    callbackFunc: (callback: (err: any, result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): () => rxjs$Observable<U>;
+  static bindNodeCallback<T, U>(
+    callbackFunc: (v1: T, callback: (err: any, result: U) => any) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T) => rxjs$Observable<U>;
+  static bindNodeCallback<T, T2, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      callback: (err: any, result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2) => rxjs$Observable<U>;
+  static bindNodeCallback<T, T2, T3, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      callback: (err: any, result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3) => rxjs$Observable<U>;
+  static bindNodeCallback<T, T2, T3, T4, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      callback: (err: any, result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable<U>;
+  static bindNodeCallback<T, T2, T3, T4, T5, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      callback: (err: any, result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable<U>;
+  static bindNodeCallback<T, T2, T3, T4, T5, T6, U>(
+    callbackFunc: (
+      v1: T,
+      v2: T2,
+      v3: T3,
+      v4: T4,
+      v5: T5,
+      v6: T6,
+      callback: (err: any, result: U) => any
+    ) => any,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable<U>;
+  static bindNodeCallback<T>(
+    callbackFunc: Function,
+    selector?: void,
+    scheduler?: rxjs$SchedulerClass
+  ): (...args: Array<any>) => rxjs$Observable<T>;
+  static bindNodeCallback<T>(
+    callbackFunc: Function,
+    selector?: (...args: Array<any>) => T,
+    scheduler?: rxjs$SchedulerClass
+  ): (...args: Array<any>) => rxjs$Observable<T>;
+
+  static concat(...sources: rxjs$Observable<T>[]): rxjs$Observable<T>;
+
+  static create(
+    subscribe: (
+      observer: rxjs$Observer<T>
+    ) => rxjs$ISubscription | Function | void
+  ): rxjs$Observable<T>;
+
+  static defer(
+    observableFactory: () => rxjs$Observable<T> | Promise<T>
+  ): rxjs$Observable<T>;
+
+  static from(
+    input: rxjs$ObservableInput<T>,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T>;
+
+  static fromEvent(
+    element: any,
+    eventName: string,
+    ...none: Array<void>
+  ): rxjs$Observable<T>;
+  static fromEvent(
+    element: any,
+    eventName: string,
+    options: rxjs$EventListenerOptions,
+    ...none: Array<void>
+  ): rxjs$Observable<T>;
+  static fromEvent(
+    element: any,
+    eventName: string,
+    selector: () => T,
+    ...none: Array<void>
+  ): rxjs$Observable<T>;
+  static fromEvent(
+    element: any,
+    eventName: string,
+    options: rxjs$EventListenerOptions,
+    selector: () => T
+  ): rxjs$Observable<T>;
+
+  static fromEventPattern(
+    addHandler: (handler: (item: T) => void) => void,
+    removeHandler: (handler: (item: T) => void) => void,
+    selector?: () => T
+  ): rxjs$Observable<T>;
+
+  static fromPromise(promise: Promise<T>): rxjs$Observable<T>;
+
+  static empty<U>(): rxjs$Observable<U>;
+
+  static interval(period: number): rxjs$Observable<number>;
+
+  static timer(
+    initialDelay: number | Date,
+    period?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<number>;
+
+  static merge<T, U>(
+    source0: rxjs$Observable<T>,
+    source1: rxjs$Observable<U>
+  ): rxjs$Observable<T | U>;
+  static merge<T, U, V>(
+    source0: rxjs$Observable<T>,
+    source1: rxjs$Observable<U>,
+    source2: rxjs$Observable<V>
+  ): rxjs$Observable<T | U | V>;
+  static merge(...sources: rxjs$Observable<T>[]): rxjs$Observable<T>;
+
+  static never<U>(): rxjs$Observable<U>;
+
+  static of(...values: T[]): rxjs$Observable<T>;
+
+  static race(...sources: rxjs$Observable<T>[]): rxjs$Observable<T>;
+
+  static range(
+    start?: number,
+    count?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<number>;
+
+  static throw(error: any): rxjs$Observable<any>;
+
+  audit(
+    durationSelector: (value: T) => rxjs$Observable<any> | Promise<any>
+  ): rxjs$Observable<T>;
+
+  auditTime(
+    duration: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T>;
+
+  race(other: rxjs$Observable<T>): rxjs$Observable<T>;
+
+  repeat(count?: number): rxjs$Observable<T>;
+
+  buffer(bufferBoundaries: rxjs$Observable<any>): rxjs$Observable<Array<T>>;
+
+  bufferCount(
+    bufferSize: number,
+    startBufferEvery?: number
+  ): rxjs$Observable<Array<T>>;
+
+  bufferTime(
+    bufferTimeSpan: number,
+    bufferCreationInterval?: number,
+    maxBufferSize?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<Array<T>>;
+
+  bufferToggle<U>(
+    openings: rxjs$Observable<U> | Promise<U>,
+    closingSelector: (value: U) => rxjs$Observable<any> | Promise<any>
+  ): rxjs$Observable<Array<T>>;
+
+  bufferWhen(
+    closingSelector: () => rxjs$Observable<any>
+  ): rxjs$Observable<Array<T>>;
+
+  catch<U>(
+    selector: (err: any, caught: rxjs$Observable<T>) => rxjs$Observable<U>
+  ): rxjs$Observable<T | U>;
+
+  concat<U>(...sources: rxjs$Observable<U>[]): rxjs$Observable<T | U>;
+
+  concatAll<U>(): rxjs$Observable<U>;
+
+  concatMap<U>(
+    f: (value: T, index: number) => rxjs$ObservableInput<U>,
+    _: void
+  ): rxjs$Observable<U>;
+  concatMap<U, V>(
+    f: (value: T, index: number) => rxjs$ObservableInput<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V
+  ): rxjs$Observable<V>;
+
+  debounceTime(
+    dueTime: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T>;
+
+  defaultIfEmpty<U>(defaultValue: U): rxjs$Observable<T | U>;
+
+  delay(dueTime: number, scheduler?: rxjs$SchedulerClass): rxjs$Observable<T>;
+
+  delayWhen(
+    delayDurationSelector: (value: T) => rxjs$Observable<any>,
+    subscriptionDelay?: rxjs$Observable<any>
+  ): rxjs$Observable<T>;
+
+  distinctUntilChanged(compare?: (x: T, y: T) => boolean): rxjs$Observable<T>;
+
+  distinct<U>(
+    keySelector?: (value: T) => U,
+    flushes?: rxjs$Observable<mixed>
+  ): rxjs$Observable<T>;
+
+  distinctUntilKeyChanged(
+    key: string,
+    compare?: (x: mixed, y: mixed) => boolean
+  ): rxjs$Observable<T>;
+
+  elementAt(index: number, defaultValue?: T): rxjs$Observable<T>;
+
+  exhaustMap<U>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    _: void
+  ): rxjs$Observable<U>;
+  exhaustMap<U, V>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V
+  ): rxjs$Observable<V>;
+
+  expand(
+    project: (value: T, index: number) => rxjs$Observable<T>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T>;
+
+  filter(predicate: typeof Boolean): rxjs$Observable<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$Observable<T>;
+
+  finally(f: () => mixed): rxjs$Observable<T>;
+
+  first(
+    predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
+  ): rxjs$Observable<T>;
+  first<U>(
+    predicate: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    resultSelector: (value: T, index: number) => U
+  ): rxjs$Observable<U>;
+  first<U>(
+    predicate: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    resultSelector: ?(value: T, index: number) => U,
+    defaultValue: U
+  ): rxjs$Observable<U>;
+
+  groupBy<K>(
+    keySelector: (value: T) => K,
+    _: void
+  ): rxjs$Observable<rxjs$GroupedObservable<K, T>>;
+  groupBy<K, V>(
+    keySelector: (value: T) => K,
+    elementSelector: (value: T) => V,
+    durationSelector?: (
+      grouped: rxjs$GroupedObservable<K, V>
+    ) => rxjs$Observable<any>
+  ): rxjs$Observable<rxjs$GroupedObservable<K, V>>;
+
+  ignoreElements<U>(): rxjs$Observable<U>;
+
+  last(
+    predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
+  ): rxjs$Observable<T>;
+  last<U>(
+    predicate: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    resultSelector: (value: T, index: number) => U
+  ): rxjs$Observable<U>;
+  last<U>(
+    predicate: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    resultSelector: ?(value: T, index: number) => U,
+    defaultValue: U
+  ): rxjs$Observable<U>;
+
+  let<U>(
+    project: (self: rxjs$Observable<T>) => rxjs$Observable<U>
+  ): rxjs$Observable<U>;
+
+  // Alias for `let`
+  letBind<U>(
+    project: (self: rxjs$Observable<T>) => rxjs$Observable<U>
+  ): rxjs$Observable<U>;
+
+  switch(): T; // assumption: T is Observable
+
+  // Alias for `mergeMap`
+  flatMap<U>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    concurrency?: number
+  ): rxjs$Observable<U>;
+  flatMap<U, V>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V,
+    concurrency?: number
+  ): rxjs$Observable<V>;
+
+  flatMapTo<U>(innerObservable: rxjs$Observable<U>): rxjs$Observable<U>;
+
+  flatMapTo<U, V>(
+    innerObservable: rxjs$Observable<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V,
+    concurrent?: number
+  ): rxjs$Observable<V>;
+
+  switchMap<U>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    _: void
+  ): rxjs$Observable<U>;
+  switchMap<U, V>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V
+  ): rxjs$Observable<V>;
+
+  switchMapTo<U>(innerObservable: rxjs$Observable<U>): rxjs$Observable<U>;
+
+  map<U>(f: (value: T, index: number) => U, thisArg?: any): rxjs$Observable<U>;
+
+  mapTo<U>(value: U): rxjs$Observable<U>;
+
+  merge(other: rxjs$Observable<T>): rxjs$Observable<T>;
+
+  mergeAll<U>(): rxjs$Observable<U>;
+
+  mergeMap<U>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    concurrency?: number
+  ): rxjs$Observable<U>;
+  mergeMap<U, V>(
+    project: (value: T, index: number) => rxjs$ObservableInput<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V,
+    concurrency?: number
+  ): rxjs$Observable<V>;
+
+  mergeMapTo<U>(innerObservable: rxjs$Observable<U>): rxjs$Observable<U>;
+
+  mergeMapTo<U, V>(
+    innerObservable: rxjs$Observable<U>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: U,
+      outerIndex: number,
+      innerIndex: number
+    ) => V,
+    concurrent?: number
+  ): rxjs$Observable<V>;
+
+  multicast(
+    subjectOrSubjectFactory: rxjs$Subject<T> | (() => rxjs$Subject<T>)
+  ): rxjs$ConnectableObservable<T>;
+
+  observeOn(scheduler: rxjs$SchedulerClass): rxjs$Observable<T>;
+
+  pairwise(): rxjs$Observable<[T, T]>;
+
+  partition(
+    predicate: (value: T, index: number) => boolean,
+    thisArg: any
+  ): [rxjs$Observable<T>, rxjs$Observable<T>];
+
+  pipe(): rxjs$Observable<T>;
+
+  pipe<A>(op1: rxjs$OperatorFunctionLast<T, A>): A;
+
+  pipe<A, B>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunctionLast<A, B>
+  ): B;
+
+  pipe<A, B, C>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunctionLast<B, C>
+  ): C;
+
+  pipe<A, B, C, D>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunctionLast<C, D>
+  ): D;
+
+  pipe<A, B, C, D, E>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunctionLast<D, E>
+  ): E;
+
+  publish(): rxjs$ConnectableObservable<T>;
+
+  publishLast(): rxjs$ConnectableObservable<T>;
+
+  reduce<U>(
+    accumulator: (
+      acc: U,
+      currentValue: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => U,
+    seed: U
+  ): rxjs$Observable<U>;
+
+  sample(notifier: rxjs$Observable<any>): rxjs$Observable<T>;
+
+  sampleTime(
+    delay: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T>;
+
+  publishReplay(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$ConnectableObservable<T>;
+
+  retry(retryCount: ?number): rxjs$Observable<T>;
+
+  retryWhen(
+    notifier: (errors: rxjs$Observable<Error>) => rxjs$Observable<any>
+  ): rxjs$Observable<T>;
+
+  scan<U>(f: (acc: U, value: T) => U, initialValue: U): rxjs$Observable<U>;
+
+  share(): rxjs$Observable<T>;
+
+  skip(count: number): rxjs$Observable<T>;
+
+  skipUntil(other: rxjs$Observable<any> | Promise<any>): rxjs$Observable<T>;
+
+  skipWhile(
+    predicate: (value: T, index: number) => boolean
+  ): rxjs$Observable<T>;
+
+  startWith(...values: Array<T>): rxjs$Observable<T>;
+
+  subscribeOn(scheduler: rxjs$SchedulerClass): rxjs$Observable<T>;
+
+  take(count: number): rxjs$Observable<T>;
+
+  takeUntil(other: rxjs$Observable<any>): rxjs$Observable<T>;
+
+  takeWhile(
+    predicate: (value: T, index: number) => boolean
+  ): rxjs$Observable<T>;
+
+  do(
+    onNext?: (value: T) => mixed,
+    onError?: (error: any) => mixed,
+    onCompleted?: () => mixed
+  ): rxjs$Observable<T>;
+  do(observer: {
+    next?: (value: T) => mixed,
+    error?: (error: any) => mixed,
+    complete?: () => mixed,
+    ...
+  }): rxjs$Observable<T>;
+
+  throttleTime(duration: number): rxjs$Observable<T>;
+
+  timeout(due: number | Date, _: void): rxjs$Observable<T>;
+
+  timeoutWith<U>(
+    due: number | Date,
+    withObservable: rxjs$Observable<U>,
+    scheduler?: rxjs$SchedulerClass
+  ): rxjs$Observable<T | U>;
+
+  toArray(): rxjs$Observable<T[]>;
+
+  toPromise(): Promise<T>;
+
+  subscribe(observer: rxjs$PartialObserver<T>): rxjs$Subscription;
+  subscribe(
+    onNext: ?(value: T) => mixed,
+    onError: ?(error: any) => mixed,
+    onCompleted: ?() => mixed
+  ): rxjs$Subscription;
+
+  combineAll<U>(): rxjs$Observable<U>;
+  combineAll<U>(project: (...values: any[]) => U): rxjs$Observable<U>;
+
+  static combineLatest<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (a: A) => B
+  ): rxjs$Observable<B>;
+
+  static combineLatest<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  static combineLatest<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  static combineLatest<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  static combineLatest<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  static combineLatest<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  static combineLatest<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  static combineLatest<A>(a: rxjs$Observable<A>, _: void): rxjs$Observable<[A]>;
+
+  static combineLatest<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[A, B]>;
+
+  static combineLatest<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[A, B, C]>;
+
+  static combineLatest<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D]>;
+
+  static combineLatest<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E]>;
+
+  static combineLatest<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F]>;
+
+  static combineLatest<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G]>;
+
+  static combineLatest<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    h: rxjs$Observable<H>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G, H]>;
+
+  combineLatest<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  combineLatest<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  combineLatest<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  combineLatest<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  combineLatest<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (t: T, a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  combineLatest<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (t: T, a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  combineLatest<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (t: T, a: A) => B
+  ): rxjs$Observable<B>;
+
+  combineLatest<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>;
+
+  combineLatest<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, F]>;
+
+  combineLatest<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E]>;
+
+  combineLatest<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D]>;
+
+  combineLatest<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C]>;
+
+  combineLatest<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[T, A, B]>;
+
+  combineLatest<A>(a: rxjs$Observable<A>, _: void): rxjs$Observable<[T, A]>;
+
+  static zip<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (a: A) => B
+  ): rxjs$Observable<B>;
+
+  static zip<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  static zip<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  static zip<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  static zip<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  static zip<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  static zip<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  static zip<A>(a: rxjs$Observable<A>, _: void): rxjs$Observable<[A]>;
+
+  static zip<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[A, B]>;
+
+  static zip<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[A, B, C]>;
+
+  static zip<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D]>;
+
+  static zip<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E]>;
+
+  static zip<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F]>;
+
+  static zip<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G]>;
+
+  static zip<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    h: rxjs$Observable<H>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G, H]>;
+
+  zip<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  zip<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  zip<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  zip<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  zip<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (t: T, a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  zip<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (t: T, a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  zip<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (t: T, a: A) => B
+  ): rxjs$Observable<B>;
+
+  zip<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>;
+
+  zip<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, F]>;
+
+  zip<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E]>;
+
+  zip<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D]>;
+
+  zip<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C]>;
+
+  zip<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[T, A, B]>;
+
+  zip<A>(a: rxjs$Observable<A>, _: void): rxjs$Observable<[T, A]>;
+
+  static forkJoin<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (a: A) => B
+  ): rxjs$Observable<B>;
+
+  static forkJoin<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  static forkJoin<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  static forkJoin<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  static forkJoin<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  static forkJoin<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  static forkJoin<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  static forkJoin<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[A, B]>;
+
+  static forkJoin<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[A, B, C]>;
+
+  static forkJoin<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D]>;
+
+  static forkJoin<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E]>;
+
+  static forkJoin<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F]>;
+
+  static forkJoin<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G]>;
+
+  static forkJoin<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    h: rxjs$Observable<H>,
+    _: void
+  ): rxjs$Observable<[A, B, C, D, E, F, G, H]>;
+
+  static forkJoin<A>(
+    a: Array<rxjs$Observable<A>>,
+    _: void
+  ): rxjs$Observable<Array<A>>;
+
+  static forkJoin<A>(
+    a: Array<rxjs$Observable<any>>,
+    _: void
+  ): rxjs$Observable<A>;
+
+  static forkJoin<A, B>(
+    a: Array<rxjs$Observable<A>>,
+    resultSelector: (...values: Array<A>) => B
+  ): rxjs$Observable<B>;
+
+  static forkJoin<A>(
+    a: Array<rxjs$Observable<any>>,
+    resultSelector: (...values: Array<any>) => A
+  ): rxjs$Observable<A>;
+
+  window(
+    windowBoundaries: rxjs$Observable<any>
+  ): rxjs$Observable<rxjs$Observable<T>>;
+  windowCount(
+    windowSize: number,
+    startWindowEvery?: number
+  ): rxjs$Observable<rxjs$Observable<T>>;
+  windowToggle<A>(
+    openings: rxjs$Observable<A>,
+    closingSelector: (value: A) => rxjs$Observable<any>
+  ): rxjs$Observable<rxjs$Observable<T>>;
+  windowWhen(
+    closingSelector: () => rxjs$Observable<any>
+  ): rxjs$Observable<rxjs$Observable<T>>;
+
+  withLatestFrom<A, B, C, D, E, F, G, H>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H
+  ): rxjs$Observable<H>;
+
+  withLatestFrom<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G
+  ): rxjs$Observable<G>;
+
+  withLatestFrom<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F
+  ): rxjs$Observable<F>;
+
+  withLatestFrom<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    resultSelector: (t: T, a: A, b: B, c: C, d: D) => E
+  ): rxjs$Observable<E>;
+
+  withLatestFrom<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    resultSelector: (t: T, a: A, b: B, c: C) => D
+  ): rxjs$Observable<D>;
+
+  withLatestFrom<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    resultSelector: (t: T, a: A, b: B) => C
+  ): rxjs$Observable<C>;
+
+  withLatestFrom<A, B>(
+    a: rxjs$Observable<A>,
+    resultSelector: (t: T, a: A) => B
+  ): rxjs$Observable<B>;
+
+  withLatestFrom<A, B, C, D, E, F, G>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    g: rxjs$Observable<G>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>;
+
+  withLatestFrom<A, B, C, D, E, F>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    f: rxjs$Observable<F>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E, F]>;
+
+  withLatestFrom<A, B, C, D, E>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    e: rxjs$Observable<E>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D, E]>;
+
+  withLatestFrom<A, B, C, D>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    d: rxjs$Observable<D>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C, D]>;
+
+  withLatestFrom<A, B, C>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    c: rxjs$Observable<C>,
+    _: void
+  ): rxjs$Observable<[T, A, B, C]>;
+
+  withLatestFrom<A, B>(
+    a: rxjs$Observable<A>,
+    b: rxjs$Observable<B>,
+    _: void
+  ): rxjs$Observable<[T, A, B]>;
+
+  withLatestFrom<A>(a: rxjs$Observable<A>, _: void): rxjs$Observable<[T, A]>;
+
+  static using<R: rxjs$ISubscription>(
+    resourceFactory: () => ?R,
+    observableFactory: (resource: R) => rxjs$Observable<T> | Promise<T> | void
+  ): rxjs$Observable<T>;
+
+  _subscribe(observer: rxjs$Subscriber<T>): rxjs$Subscription;
+
+  _isScalar: boolean;
+  source: ?rxjs$Observable<any>;
+  operator: ?rxjs$Operator<any, any>;
+}
+
+declare class rxjs$ConnectableObservable<T> extends rxjs$Observable<T> {
+  connect(): rxjs$Subscription;
+  refCount(): rxjs$Observable<T>;
+}
+
+declare class rxjs$GroupedObservable<K, V> extends rxjs$Observable<V> {
+  key: K;
+}
+
+declare class rxjs$Observer<-T> {
+  next(value: T): mixed;
+  error(error: any): mixed;
+  complete(): mixed;
+}
+
+declare interface rxjs$Operator<T, R> {
+  call(subscriber: rxjs$Subscriber<R>, source: any): rxjs$TeardownLogic;
+}
+
+declare class rxjs$Subject<T> mixins rxjs$Observable<T>, rxjs$Observer<T> {
+  static create<T>(
+    destination: rxjs$Observer<T>,
+    source: rxjs$Observable<T>
+  ): rxjs$AnonymousSubject<T>;
+
+  asObservable(): rxjs$Observable<T>;
+  observers: Array<rxjs$Observer<T>>;
+  unsubscribe(): void;
+
+  // For use in subclasses only:
+  _next(value: T): void;
+}
+
+declare class rxjs$AnonymousSubject<T> extends rxjs$Subject<T> {
+  source: ?rxjs$Observable<T>;
+  destination: ?rxjs$Observer<T>;
+
+  constructor(
+    destination?: rxjs$Observer<T>,
+    source?: rxjs$Observable<T>
+  ): void;
+}
+
+declare class rxjs$BehaviorSubject<T> extends rxjs$Subject<T> {
+  constructor(initialValue: T): void;
+
+  getValue(): T;
+}
+
+declare class rxjs$ReplaySubject<T> extends rxjs$Subject<T> {
+  constructor(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerClass
+  ): void;
+}
+
+declare class rxjs$Subscription {
+  unsubscribe(): void;
+  add(teardown: rxjs$TeardownLogic): rxjs$Subscription;
+}
+
+declare class rxjs$Subscriber<T> extends rxjs$Subscription {
+  static create<T>(
+    next?: (x?: T) => void,
+    error?: (e?: any) => void,
+    complete?: () => void
+  ): rxjs$Subscriber<T>;
+
+  constructor(
+    destinationOrNext?: rxjs$PartialObserver<any> | ((value: T) => void),
+    error?: (e?: any) => void,
+    complete?: () => void
+  ): void;
+  next(value?: T): void;
+  error(err?: any): void;
+  complete(): void;
+  unsubscribe(): void;
+}
+
+declare class rxjs$SchedulerClass {
+  schedule<T>(
+    work: (state?: T) => void,
+    delay?: number,
+    state?: T
+  ): rxjs$Subscription;
+}
+
+declare class rxjs$ArgumentOutOfRangeError extends Error {}
+declare class rxjs$EmptyError extends Error {}
+declare class rxjs$ObjectUnsubscribedError extends Error {}
+declare class rxjs$TimeoutError extends Error {}
+declare class rxjs$UnsubscriptionError extends Error {}
+
+declare module "rxjs" {
+  declare module.exports: {
+    Observable: typeof rxjs$Observable,
+    Observer: typeof rxjs$Observer,
+    ConnectableObservable: typeof rxjs$ConnectableObservable,
+    Subject: typeof rxjs$Subject,
+    Subscriber: typeof rxjs$Subscriber,
+    AnonymousSubject: typeof rxjs$AnonymousSubject,
+    BehaviorSubject: typeof rxjs$BehaviorSubject,
+    ReplaySubject: typeof rxjs$ReplaySubject,
+    Scheduler: {
+      asap: rxjs$SchedulerClass,
+      queue: rxjs$SchedulerClass,
+      animationFrame: rxjs$SchedulerClass,
+      async: rxjs$SchedulerClass,
+      ...
+    },
+    Subscription: typeof rxjs$Subscription,
+    ArgumentOutOfRangeError: typeof rxjs$ArgumentOutOfRangeError,
+    EmptyError: typeof rxjs$EmptyError,
+    ObjectUnsubscribedError: typeof rxjs$ObjectUnsubscribedError,
+    TimeoutError: typeof rxjs$TimeoutError,
+    UnsubscriptionError: typeof rxjs$UnsubscriptionError,
+    ...
+  };
+}
+
+declare module "rxjs/Observable" {
+  declare module.exports: { Observable: typeof rxjs$Observable, ... };
+}
+
+declare module "rxjs/Observer" {
+  declare module.exports: { Observer: typeof rxjs$Observer, ... };
+}
+
+declare module "rxjs/BehaviorSubject" {
+  declare module.exports: { BehaviorSubject: typeof rxjs$BehaviorSubject, ... };
+}
+
+declare module "rxjs/ReplaySubject" {
+  declare module.exports: { ReplaySubject: typeof rxjs$ReplaySubject, ... };
+}
+
+declare module "rxjs/Subject" {
+  declare module.exports: {
+    Subject: typeof rxjs$Subject,
+    AnonymousSubject: typeof rxjs$AnonymousSubject,
+    ...
+  };
+}
+
+declare module "rxjs/Subscriber" {
+  declare module.exports: { Subscriber: typeof rxjs$Subscriber, ... };
+}
+
+declare module "rxjs/Subscription" {
+  declare module.exports: { Subscription: typeof rxjs$Subscription, ... };
+}
+
+declare module "rxjs/testing/TestScheduler" {
+  declare module.exports: { TestScheduler: typeof rxjs$SchedulerClass, ... };
+}
+
+declare module "rxjs/util/ArgumentOutOfRangeError" {
+  declare module.exports: { ArgumentOutOfRangeError: typeof rxjs$ArgumentOutOfRangeError, ... };
+}
+
+declare module "rxjs/util/EmptyError" {
+  declare module.exports: { EmptyError: typeof rxjs$EmptyError, ... };
+}
+
+declare module "rxjs/util/ObjectUnsubscribedError" {
+  declare module.exports: { ObjectUnsubscribedError: typeof rxjs$ObjectUnsubscribedError, ... };
+}
+
+declare module "rxjs/util/TimeoutError" {
+  declare module.exports: { TimeoutError: typeof rxjs$TimeoutError, ... };
+}
+
+declare module "rxjs/util/UnsubscriptionError" {
+  declare module.exports: { UnsubscriptionError: typeof rxjs$UnsubscriptionError, ... };
+}
diff --git a/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/test_rxjs.js b/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/test_rxjs.js
new file mode 100644
index 0000000000..187a1f8343
--- /dev/null
+++ b/definitions/npm/rxjs_v5.0.x/flow_v0.201.x-/test_rxjs.js
@@ -0,0 +1,136 @@
+/* @flow */
+
+import {
+  AnonymousSubject,
+  Observable,
+  Observer,
+  Scheduler,
+  Subject,
+  Subscriber
+} from "rxjs";
+
+const numbers = Observable.of(1);
+Observable.create(observer => {
+  // $FlowExpectedError[incompatible-call]
+  numbers.subscribe(observer);
+});
+
+// $FlowExpectedError[incompatible-call]
+const distinct1: Observable<number> = Observable.of(1).distinct(1);
+const distinct2: Observable<number> = Observable.of(1).distinct();
+const distinct3: Observable<{ a: string, ... }> = Observable.of({ a: "a" }).distinct(
+  field => field.a
+);
+const distinct4: Observable<{ a: string, ... }> = Observable.of({ a: "a" }).distinct(
+  field => field.a,
+  Observable.never()
+);
+
+const timer$: Observable<number> = Observable.timer(1000).startWith(10);
+const numbers2: Observable<number> = Observable.of(1, 2, 3).repeat(2);
+
+const subscriber: Subscriber<number> = Subscriber.create(
+  console.log,
+  console.error,
+  console.log
+);
+const subscriber2: Subscriber<number> = new Subscriber(x => console.log(x));
+
+const numberObserver: Observer<number> = new Observer();
+
+const anonymousSubject: AnonymousSubject<number> = new AnonymousSubject(
+  numberObserver,
+  Observable.of(3)
+);
+anonymousSubject.next(5);
+anonymousSubject.error(new Error());
+
+const from: Observable<number> = Observable.from(Promise.resolve(1));
+
+// Standard projection operators
+const project: Array<Observable<string>> = [
+  numbers.switchMap(x => Promise.resolve("")),
+  numbers.switchMap(
+    x => [x],
+    (x, y, index1, index2) => String(x + y + index1 + index2)
+  ),
+  numbers.switchMap(
+    x => [x],
+    (x, y, index1, index2) => String(x + y + index1 + index2)
+  ),
+  numbers.concatMap(
+    x => [x],
+    (x, y, index1, index2) => String(x + y + index1 + index2)
+  ),
+  numbers.mergeMap(x => Observable.of("")),
+  numbers.mergeMap(x => Observable.of(""), 5),
+  numbers.mergeMap(
+    x => [x],
+    (x, y, index1, index2) => String(x + y + index1 + index2),
+    /* concurrency */ 5
+  ),
+  // $FlowExpectedError[incompatible-call]: the ordering is wrong
+  numbers.mergeMap(x => [x], 5, (x, y, index1, index2) =>
+    String(x + y + index1 + index2)
+  ),
+  numbers.exhaustMap(
+    x => [x],
+    (x, y, index1, index2) => String(x + y + index1 + index2)
+  )
+];
+
+(Observable.range(0, 10, Scheduler.asap): Observable<number>);
+(Observable.of(1).defaultIfEmpty(null): Observable<?number>);
+(Observable.of(1).defaultIfEmpty(1): Observable<number>);
+(Observable.of(1).timeoutWith(100, Observable.of(null)): Observable<?number>);
+
+(Observable.of(1).groupBy(elem => ""): Observable<
+  rxjs$GroupedObservable<string, number>
+>);
+(Observable.of(1).groupBy(
+  elem => elem,
+  elem => String(elem),
+  grouped => Observable.never()
+): Observable<rxjs$GroupedObservable<number, string>>);
+
+// http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-buffer
+var clicks = Observable.fromEvent(document, "click");
+var interval = Observable.interval(1000);
+var buffered = interval.buffer(clicks);
+buffered.subscribe(x => console.log(x));
+
+// http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-bufferCount
+// $FlowExpectedError[incompatible-call]
+clicks.bufferCount();
+var buffered = clicks.bufferCount(2);
+buffered.subscribe(x => console.log(x));
+
+var buffered = clicks.bufferCount(2, 1);
+buffered.subscribe(x => console.log(x));
+
+// http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-bufferTime
+// $FlowExpectedError[incompatible-call]
+clicks.bufferTime();
+var buffered = clicks.bufferTime(1000);
+buffered.subscribe(x => console.log(x));
+
+var buffered = clicks.bufferTime(2000, 5000);
+buffered.subscribe(x => console.log(x));
+
+// http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-bufferToggle
+var openings = Observable.interval(1000);
+var buffered = clicks.bufferToggle(
+  openings,
+  i => (i % 2 ? Observable.interval(500) : Observable.empty())
+);
+// $FlowExpectedError[prop-missing]
+clicks.bufferToggle(openings,i => (i.length % 2 ? Observable.interval(500) : Observable.empty()));
+buffered.subscribe(x => console.log(x));
+
+// http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-bufferWhen
+var buffered = clicks.bufferWhen(() =>
+  Observable.interval(1000 + Math.random() * 4000)
+);
+// $FlowExpectedError[cannot-resolve-name]
+click.bufferWhen(() => true);
+buffered.subscribe(x => console.log(x));
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/rxjs_v6.x.x.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/rxjs_v6.x.x.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/rxjs_v6.x.x.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/rxjs_v6.x.x.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_imports.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_imports.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_imports.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_imports.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_observable.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_observable.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_observable.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_observable.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_audit.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_audit.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_audit.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_audit.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_auditTime.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_auditTime.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_auditTime.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_auditTime.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatAll.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatAll.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatMap.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatMap.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_concatMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_concatMapTo.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_count.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_count.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_count.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_count.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_debounce.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_debounce.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_debounce.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_debounce.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_debounceTime.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_debounceTime.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_debounceTime.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_debounceTime.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_delay.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_delay.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_delay.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_delay.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinct.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinct.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinct.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinct.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinctUntilChanged.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilChanged.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinctUntilChanged.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilChanged.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinctUntilKeyChanged.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilKeyChanged.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_distinctUntilKeyChanged.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilKeyChanged.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_endWith.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_endWith.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_endWith.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_endWith.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_exhaust.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_exhaust.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_exhaust.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_exhaust.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_exhaustMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_exhaustMap.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_exhaustMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_exhaustMap.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_filter.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_filter.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_filter.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_filter.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_find.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_find.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_find.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_find.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_findIndex.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_findIndex.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_findIndex.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_findIndex.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_first.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_first.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_first.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_first.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_last.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_last.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_last.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_last.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeAll.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeAll.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMap.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMap.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_mergeMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMapTo.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_retry.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_retry.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_retry.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_retry.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_retryWhen.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_retryWhen.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_retryWhen.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_retryWhen.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skip.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skip.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skip.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skip.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipLast.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipLast.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipLast.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipLast.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipUntil.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipUntil.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipUntil.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipUntil.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipWhile.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipWhile.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_skipWhile.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_skipWhile.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_startWith.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_startWith.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_startWith.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_startWith.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchAll.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchAll.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchMap.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchMap.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_switchMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_switchMapTo.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_take.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_take.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_take.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_take.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeLast.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeLast.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeLast.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeLast.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeUntil.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeUntil.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeUntil.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeUntil.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeWhile.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeWhile.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_operator_takeWhile.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_operator_takeWhile.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_pipe.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_pipe.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_pipe.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_pipe.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_zip.js b/definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_zip.js
similarity index 100%
rename from definitions/npm/rxjs_v6.x.x/flow_v0.104.x-/test_zip.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.104.x-v.200.x/test_zip.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/rxjs_v6.x.x.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/rxjs_v6.x.x.js
new file mode 100644
index 0000000000..5713d29319
--- /dev/null
+++ b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/rxjs_v6.x.x.js
@@ -0,0 +1,3333 @@
+/** OPERATOR INTERFACES */
+declare interface rxjs$UnaryFunction<T, R> {
+  (source: T): R;
+}
+declare interface rxjs$OperatorFunction<T, R>
+  extends rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$Observable<R>> {}
+declare type rxjs$FactoryOrValue<T> = T | (() => T);
+declare interface rxjs$MonoTypeOperatorFunction<T>
+  extends rxjs$OperatorFunction<T, T> {}
+declare interface rxjs$Timestamp<T> {
+  value: T;
+  timestamp: number;
+}
+declare interface rxjs$TimeInterval<T> {
+  value: T;
+  interval: number;
+}
+/** SUBSCRIPTION INTERFACES */
+declare interface rxjs$Unsubscribable {
+  unsubscribe(): void;
+}
+declare type rxjs$TeardownLogic = rxjs$Unsubscribable | Function | void;
+declare interface rxjs$SubscriptionLike extends rxjs$Unsubscribable {
+  unsubscribe(): void;
+  +closed: boolean;
+}
+declare type rxjs$SubscribableOrPromise<T> =
+  | rxjs$Subscribable<T>
+  | rxjs$Subscribable<empty>
+  | Promise<T>
+  | rxjs$InteropObservable<T>;
+
+/** OBSERVABLE INTERFACES */
+declare interface rxjs$Subscribable<T> {
+  subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Unsubscribable;
+  subscribe(
+    next?: (value: T) => void,
+    error?: (error: any) => void,
+    complete?: () => void
+  ): rxjs$Unsubscribable;
+}
+declare type rxjs$ObservableInput<T> =
+  | rxjs$SubscribableOrPromise<T>
+  | Array<T>
+  | Iterable<T>;
+
+declare type rxjs$InteropObservable<T> = { [string | mixed]: () => rxjs$Subscribable<T>, ... };
+/** OBSERVER INTERFACES */
+declare interface rxjs$NextObserver<T> {
+  closed?: boolean;
+  +next: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete?: () => void;
+}
+declare interface rxjs$ErrorObserver<T> {
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error: (err: any) => void;
+  +complete?: () => void;
+}
+declare interface rxjs$CompletionObserver<T> {
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete: () => void;
+}
+declare type rxjs$PartialObserver<T> = {|
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete?: () => void;
+|}
+declare interface rxjs$Observer<T> {
+  closed: boolean;
+  next(value: T): void;
+  error(err: any): void;
+  complete(): void;
+}
+/** SCHEDULER INTERFACES */
+declare interface rxjs$SchedulerLike {
+  now(): number;
+  schedule<T>(
+    work: (state?: T) => void,
+    delay?: number,
+    state?: T
+  ): rxjs$Subscription;
+}
+declare interface rxjs$SchedulerAction<T> extends rxjs$Subscription {
+  schedule(state?: T, delay?: number): rxjs$Subscription;
+}
+
+declare interface rxjs$EventListenerOptions {
+  capture?: boolean;
+  passive?: boolean;
+  once?: boolean;
+}
+
+declare class rxjs$Observable<T> implements rxjs$Subscribable<T> {
+  // @internal
+  _isScalar: boolean;
+  // @deprecated  This is an internal implementation detail, do not use.
+  source: rxjs$Observable<any>;
+  // @deprecated  This is an internal implementation detail, do not use.
+  operator: rxjs$Operator<any, T>;
+  constructor(
+    subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
+  ): void;
+  static create(
+    subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
+  ): rxjs$Observable<T>;
+  lift<R>(operator: rxjs$Operator<T, R>): rxjs$Observable<R>;
+  subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Subscription;
+  subscribe(
+    next?: (value: T) => void,
+    error?: (error: any) => void,
+    complete?: () => void
+  ): rxjs$Subscription;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _trySubscribe(sink: rxjs$Subscriber<T>): rxjs$TeardownLogic;
+  forEach(
+    next: (value: T) => void,
+    promiseCtor?: typeof Promise.constructor
+  ): Promise<void>;
+  // @internal  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<any>): rxjs$TeardownLogic;
+  // @deprecated  In favor of iif creation function: import { iif } from 'rxjs';
+  static if: typeof rxjs$iif;
+  // @deprecated  In favor of throwError creation function: import { throwError } from 'rxjs';
+  static throw: typeof rxjs$throwError;
+  pipe(): rxjs$Observable<T>;
+  pipe<A>(op1: rxjs$OperatorFunction<T, A>): rxjs$Observable<A>;
+  pipe<A, B>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>
+  ): rxjs$Observable<B>;
+  pipe<A, B, C>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>
+  ): rxjs$Observable<C>;
+  pipe<A, B, C, D>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>
+  ): rxjs$Observable<D>;
+  pipe<A, B, C, D, E>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>
+  ): rxjs$Observable<E>;
+  pipe<A, B, C, D, E, F>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>
+  ): rxjs$Observable<F>;
+  pipe<A, B, C, D, E, F, G>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>
+  ): rxjs$Observable<G>;
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>
+  ): rxjs$Observable<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>,
+    op9: rxjs$OperatorFunction<H, I>
+  ): rxjs$Observable<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>,
+    op9: rxjs$OperatorFunction<H, I>,
+    ...operations: rxjs$OperatorFunction<any, any>[]
+  ): rxjs$Observable<{...}>;
+  toPromise<T>(): Promise<T>;
+  toPromise<T>(PromiseCtor: typeof Promise): Promise<T>;
+  toPromise<T>(PromiseCtor: typeof Promise.constructor): Promise<T>;
+}
+
+declare class rxjs$Subscription implements rxjs$SubscriptionLike {
+  static EMPTY: rxjs$Subscription;
+  closed: boolean;
+  // @internal
+  _parent: rxjs$Subscription;
+  // @internal
+  _parents: rxjs$Subscription[];
+  constructor(unsubscribe?: () => void): void;
+  unsubscribe(): void;
+  add(teardown: rxjs$TeardownLogic): rxjs$Subscription;
+  remove(subscription: rxjs$Subscription): void;
+}
+
+declare interface rxjs$Operator<T, R> {
+  call(subscriber: rxjs$Subscriber<R>, source: any): rxjs$TeardownLogic;
+}
+
+declare class rxjs$Subscriber<T> extends rxjs$Subscription
+  implements rxjs$Observer<T> {
+  static create<T>(
+    next?: (x?: T) => void,
+    error?: (e?: any) => void,
+    complete?: () => void
+  ): rxjs$Subscriber<T>;
+  // @internal
+  syncErrorValue: any;
+  // @internal
+  syncErrorThrown: boolean;
+  // @internal
+  syncErrorThrowable: boolean;
+  isStopped: boolean;
+  destination: rxjs$PartialObserver<any> | rxjs$Subscriber<any>;
+  constructor(
+    destinationOrNext?: rxjs$PartialObserver<any> | ((value: T) => void),
+    error?: (e?: any) => void,
+    complete?: () => void
+  ): void;
+  next(value?: T): void;
+  error(err?: any): void;
+  complete(): void;
+  unsubscribe(): void;
+  _next(value: T): void;
+  _error(err: any): void;
+  _complete(): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _unsubscribeAndRecycle(): rxjs$Subscriber<T>;
+}
+
+declare class rxjs$ConnectableObservable<T> extends rxjs$Observable<T> {
+  source: rxjs$Observable<T>;
+  subjectFactory: () => rxjs$Subject<T>;
+  _subject: rxjs$Subject<T>;
+  _refCount: number;
+  _connection: rxjs$Subscription;
+  // @internal
+  _isComplete: boolean;
+  constructor(
+    source: rxjs$Observable<T>,
+    subjectFactory: () => rxjs$Subject<T>
+  ): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  getSubject(): rxjs$Subject<T>;
+  connect(): rxjs$Subscription;
+  refCount(): rxjs$Observable<T>;
+}
+
+declare class rxjs$Subject<T> extends rxjs$Observable<T>
+  implements rxjs$SubscriptionLike {
+  observers: rxjs$Observer<T>[];
+  closed: boolean;
+  isStopped: boolean;
+  hasError: boolean;
+  thrownError: any;
+  constructor(): void;
+  static create: Function;
+  lift<R>(operator: rxjs$Operator<T, R>): rxjs$Observable<R>;
+  next(value?: T): void;
+  error(err: any): void;
+  complete(): void;
+  unsubscribe(): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _trySubscribe(subscriber: rxjs$Subscriber<T>): rxjs$TeardownLogic;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  asObservable(): rxjs$Observable<T>;
+}
+
+declare class rxjs$Notification<T> {
+  kind: string;
+  value: T;
+  error: any;
+  hasValue: boolean;
+  constructor(kind: string, value?: T, error?: any): void;
+  observe(observer: rxjs$PartialObserver<T>): any;
+  do(
+    next: (value: T) => void,
+    error?: (err: any) => void,
+    complete?: () => void
+  ): any;
+  accept(
+    nextOrObserver: rxjs$PartialObserver<T> | ((value: T) => void),
+    error?: (err: any) => void,
+    complete?: () => void
+  ): any;
+  toObservable(): rxjs$Observable<T>;
+  static createNext<T>(value: T): rxjs$Notification<T>;
+  static createError<T>(err?: any): rxjs$Notification<T>;
+  static createComplete(): rxjs$Notification<any>;
+}
+
+declare class rxjs$GroupedObservable<K, T> extends rxjs$Observable<T> {
+  key: K;
+  // @deprecated  Do not construct this type. Internal use only
+  constructor(
+    key: K,
+    groupSubject: rxjs$Subject<T>,
+    refCountSubscription?: rxjs$RefCountSubscription
+  ): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+}
+
+declare interface rxjs$RefCountSubscription {
+  count: number;
+  unsubscribe: () => void;
+  closed: boolean;
+  attemptedToUnsubscribe: boolean;
+}
+
+declare function rxjs$throwError(
+  error: any,
+  scheduler?: rxjs$SchedulerLike
+): rxjs$Observable<any>;
+
+declare function rxjs$iif<T, F>(
+  condition: () => boolean,
+  trueResult?: rxjs$SubscribableOrPromise<T>,
+  falseResult?: rxjs$SubscribableOrPromise<F>
+): rxjs$Observable<T | F>;
+
+declare module "rxjs" {
+  declare module.exports: {
+    Observable: typeof rxjs$Observable,
+    Subscriber: typeof rxjs$Subscriber,
+    Subscription: typeof rxjs$Subscription,
+    throwError: typeof rxjs$throwError,
+    iif: typeof rxjs$iif,
+    ConnectableObservable: typeof rxjs$ConnectableObservable,
+    GroupedObservable: typeof rxjs$GroupedObservable,
+    observable: string | mixed,
+    Subject: typeof rxjs$Subject,
+    BehaviorSubject: typeof BehaviorSubject,
+    ReplaySubject: typeof ReplaySubject,
+    AsyncSubject: typeof AsyncSubject,
+    asapScheduler: AsapScheduler,
+    asyncScheduler: AsyncScheduler,
+    queueScheduler: QueueScheduler,
+    animationFrameScheduler: AnimationFrameScheduler,
+    VirtualTimeScheduler: typeof VirtualTimeScheduler,
+    VirtualAction: typeof VirtualAction,
+    Scheduler: typeof Scheduler,
+    Notification: typeof rxjs$Notification,
+    pipe: (<T>() => rxjs$UnaryFunction<T, T>) &
+      (<T, A>(fn1: rxjs$UnaryFunction<T, A>) => rxjs$UnaryFunction<T, A>) &
+      (<T, A, B>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>
+      ) => rxjs$UnaryFunction<T, B>) &
+      (<T, A, B, C>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>
+      ) => rxjs$UnaryFunction<T, C>) &
+      (<T, A, B, C, D>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>
+      ) => rxjs$UnaryFunction<T, D>) &
+      (<T, A, B, C, D, E>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>
+      ) => rxjs$UnaryFunction<T, E>) &
+      (<T, A, B, C, D, E, F>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>
+      ) => rxjs$UnaryFunction<T, F>) &
+      (<T, A, B, C, D, E, F, G>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>
+      ) => rxjs$UnaryFunction<T, G>) &
+      (<T, A, B, C, D, E, F, G, H>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>
+      ) => rxjs$UnaryFunction<T, H>) &
+      (<T, A, B, C, D, E, F, G, H, I>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>,
+        fn9: rxjs$UnaryFunction<H, I>
+      ) => rxjs$UnaryFunction<T, I>) &
+      (<T, A, B, C, D, E, F, G, H, I>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>,
+        fn9: rxjs$UnaryFunction<H, I>,
+        ...fns: rxjs$UnaryFunction<any, any>[]
+      ) => rxjs$UnaryFunction<T, {...}>),
+    noop(): void,
+    identity<T>(x: T): T,
+    isObservable<T>(obj: any): boolean,
+    concat: (<T>(
+      v1: rxjs$ObservableInput<T>,
+      scheduler?: rxjs$SchedulerLike
+    ) => rxjs$Observable<T>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T>(
+        ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike)[]
+      ) => rxjs$Observable<T>) &
+      (<T, R>(
+        ...observables: (rxjs$ObservableInput<any> | rxjs$SchedulerLike)[]
+      ) => rxjs$Observable<R>),
+    defer<T>(
+      observableFactory: () => rxjs$SubscribableOrPromise<T> | null
+    ): rxjs$Observable<T>,
+    forkJoin: (<T>(
+      sources: [rxjs$ObservableInput<T>]
+    ) => rxjs$Observable<T[]>) &
+      (<T, T2>(
+        sources: [rxjs$ObservableInput<T>, rxjs$ObservableInput<T2>]
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>
+        ]
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>,
+          rxjs$ObservableInput<T5>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>,
+          rxjs$ObservableInput<T5>,
+          rxjs$ObservableInput<T6>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(sources: Array<rxjs$ObservableInput<T>>) => rxjs$Observable<T[]>) &
+      (<T>(v1: rxjs$ObservableInput<T>) => rxjs$Observable<T[]>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      // @deprecated resultSelector is deprecated, pipe to map instead
+      ((
+        ...args: Array<rxjs$ObservableInput<any> | Function>
+      ) => rxjs$Observable<any>) &
+      (<T>(...sources: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>),
+    from<T>(
+      input:
+        | rxjs$ObservableInput<T>
+        | rxjs$ObservableInput<rxjs$ObservableInput<T>>,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<T>,
+    ArgumentOutOfRangeError: ArgumentOutOfRangeError,
+    EmptyError: EmptyError,
+    ObjectUnsubscribedError: ObjectUnsubscribedError,
+    UnsubscriptionError: UnsubscriptionError,
+    TimeoutError: TimeoutError,
+    fromEvent: <T>(
+      target: mixed,
+      eventName: string,
+      options?: rxjs$EventListenerOptions | ((...args: any[]) => T),
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      resultSelector?: (...args: any[]) => T
+    ) => rxjs$Observable<T>,
+    fromEventPattern: (<T>(
+      addHandler: (handler: Function) => any,
+      removeHandler?: (handler: Function, signal?: any) => void
+    ) => rxjs$Observable<T>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T>(
+        addHandler: (handler: Function) => any,
+        removeHandler?: (handler: Function, signal?: any) => void,
+        resultSelector?: (...args: any[]) => T
+      ) => rxjs$Observable<T>),
+    generate<T, S>(
+      initialState: S,
+      condition: ConditionFunc<S>,
+      iterate: IterateFunc<S>,
+      resultSelector: ResultFunc<S, T>,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<T>,
+    interval(
+      period?: number,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    merge: (<T>(
+      ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike | number)[]
+    ) => rxjs$Observable<T>) &
+      (<T, R>(
+        ...observables: (
+          | rxjs$ObservableInput<any>
+          | rxjs$SchedulerLike
+          | number
+        )[]
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        v1: rxjs$ObservableInput<T>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T>) &
+      (<T>(
+        v1: rxjs$ObservableInput<T>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>),
+    of: (<T>(a: T, scheduler?: rxjs$SchedulerLike) => rxjs$Observable<T>) &
+      (<T, T2>(
+        a: T,
+        b: T2,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        a: T,
+        b: T2,
+        c: T3,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T, T2, T3, T4, T5, T6, T7>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7>) &
+      (<T, T2, T3, T4, T5, T6, T7, T8>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        h: T8,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8>) &
+      (<T, T2, T3, T4, T5, T6, T7, T8, T9>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        h: T8,
+        i: T9,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>) &
+      (<T>(...args: Array<T | rxjs$SchedulerLike>) => rxjs$Observable<T>),
+    onErrorResumeNext: (<R>(v: rxjs$ObservableInput<R>) => rxjs$Observable<R>) &
+      (<T2, T3, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, T5, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, T5, T6, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>),
+    pairs<T>(
+      obj: Object,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<[string, T]>,
+    race: (<T>(observables: Array<rxjs$Observable<T>>) => rxjs$Observable<T>) &
+      (<T>(observables: Array<rxjs$Observable<any>>) => rxjs$Observable<T>) &
+      (<T>(
+        ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
+      ) => rxjs$Observable<T>),
+    range(
+      start?: number,
+      count?: number,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    timer(
+      dueTime?: number | Date,
+      periodOrScheduler?: number | rxjs$SchedulerLike,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    using<T>(
+      resourceFactory: () => rxjs$Unsubscribable | void,
+      observableFactory: (
+        resource: rxjs$Unsubscribable | void
+      ) => rxjs$ObservableInput<T> | void
+    ): rxjs$Observable<T>,
+    config: {
+      Promise: typeof Promise.constructor,
+      useDeprecatedSynchronousErrorHandling: boolean,
+      ...
+    },
+    // @deprecated  resultSelector is no longer supported, pipe to map instead
+    zip: (<T, R>(
+      v1: rxjs$ObservableInput<T>,
+      resultSelector: (v1: T) => R
+    ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        resultSelector: (v1: T, v2: T2) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        resultSelector: (v1: T, v2: T2, v3: T3) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, T6, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+      ) => rxjs$Observable<R>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(array: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>) &
+      (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, R>(
+        array: rxjs$ObservableInput<T>[],
+        resultSelector: (...values: Array<T>) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        resultSelector: (...values: Array<any>) => R
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        ...observables: Array<rxjs$ObservableInput<T>>
+      ) => rxjs$Observable<T[]>) &
+      (<T, R>(
+        ...observables: Array<
+          rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
+        >
+      ) => rxjs$Observable<R>),
+    // @deprecated  Deprecated in favor of using {@link  NEVER} constant.
+    never(): rxjs$Observable<any>,
+    NEVER: rxjs$Observable<any>,
+    // @deprecated Deprecated in favor of using {@link EMPTY} constant.
+    empty(scheduler?: rxjs$SchedulerLike): rxjs$Observable<any>,
+    EMPTY: rxjs$Observable<any>,
+    // @deprecated resultSelector is no longer supported, use a mapping function.
+    bindCallback: ((
+      callbackFunc: Function,
+      resultSelector: Function,
+      scheduler?: rxjs$SchedulerLike
+    ) => (...args: any[]) => rxjs$Observable<any>) &
+      (<R1, R2, R3, R4>(
+        callbackFunc: (
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<mixed[]>) &
+      (<R1, R2, R3>(
+        callbackFunc: (callback: (res1: R1, res2: R2, res3: R3) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2, R3]>) &
+      (<R1, R2>(
+        callbackFunc: (callback: (res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2]>) &
+      (<R1>(
+        callbackFunc: (callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<R1>) &
+      ((
+        callbackFunc: (callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<void>) &
+      (<A1, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<mixed[]>) &
+      (<A1, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, R1, R2>(
+        callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
+      (<A1, R1>(
+        callbackFunc: (arg1: A1, callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<R1>) &
+      (<A1>(
+        callbackFunc: (arg1: A1, callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<void>) &
+      (<A1, A2, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, R1>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
+      (<A1, A2>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
+      (<A1, A2, A3, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
+      (<A1, A2, A3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, A5, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, A5, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4, A5>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<void>) &
+      (<A, R>(
+        callbackFunc: (...args: Array<A | ((result: R) => any)>) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: A[]) => rxjs$Observable<R>) &
+      (<A, R>(
+        callbackFunc: (...args: Array<A | ((...results: R[]) => any)>) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: A[]) => rxjs$Observable<R[]>) &
+      ((
+        callbackFunc: Function,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<any>),
+    // @deprecated resultSelector is deprecated, pipe to map instead
+    bindNodeCallback: ((
+      callbackFunc: Function,
+      resultSelector: Function,
+      scheduler?: rxjs$SchedulerLike
+    ) => (...args: any[]) => rxjs$Observable<any>) &
+      (<R1, R2, R3, R4>(
+        callbackFunc: (
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<R1, R2, R3>(
+        callbackFunc: (
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2, R3]>) &
+      (<R1, R2>(
+        callbackFunc: (callback: (err: any, res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2]>) &
+      (<R1>(
+        callbackFunc: (callback: (err: any, res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<R1>) &
+      ((
+        callbackFunc: (callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<void>) &
+      (<T, A1, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<T>) &
+      (<A1, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
+      (<A1, R1>(
+        callbackFunc: (arg1: A1, callback: (err: any, res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<R1>) &
+      (<A1>(
+        callbackFunc: (arg1: A1, callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<void>) &
+      (<A1, A2, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
+      (<A1, A2>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
+      (<T, A1, A2, A3, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<T>) &
+      (<A1, A2, A3, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
+      (<A1, A2, A3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, A5, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, A5, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4, A5>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<void>) &
+      ((
+        callbackFunc: Function,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>),
+    // @deprecated resultSelector no longer supported, pipe to map instead
+    combineLatest: (<T, R>(
+      v1: rxjs$ObservableInput<T>,
+      resultSelector: (v1: T) => R,
+      scheduler?: rxjs$SchedulerLike
+    ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        resultSelector: (v1: T, v2: T2) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        resultSelector: (v1: T, v2: T2, v3: T3) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, T6, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(
+        array: rxjs$ObservableInput<T>[],
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T[]>) &
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, R>(
+        array: rxjs$ObservableInput<T>[],
+        resultSelector: (...values: Array<T>) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        resultSelector: (...values: Array<any>) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
+      ) => rxjs$Observable<T[]>) &
+      (<T, R>(
+        ...observables: Array<
+          | rxjs$ObservableInput<T>
+          | ((...values: Array<T>) => R)
+          | rxjs$SchedulerLike
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          | rxjs$ObservableInput<any>
+          | ((...values: Array<any>) => R)
+          | rxjs$SchedulerLike
+        >
+      ) => rxjs$Observable<R>),
+    ...
+  };
+
+  declare class BehaviorSubject<T> extends rxjs$Subject<T> {
+    constructor(_value: T): void;
+    +value: T;
+    // @deprecated  This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+    getValue(): T;
+    next(value?: T): void;
+  }
+
+  declare class ReplaySubject<T> extends rxjs$Subject<T> {
+    constructor(
+      bufferSize?: number,
+      windowTime?: number,
+      scheduler?: rxjs$SchedulerLike
+    ): void;
+    // @deprecated  This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+    _getNow(): number;
+  }
+
+  declare class AsyncSubject<T> extends rxjs$Subject<T> {
+    // @deprecated  This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<any>): rxjs$Subscription;
+    next(value?: T): void;
+    error(error: any): void;
+    complete(): void;
+  }
+
+  declare class VirtualTimeScheduler extends AsyncScheduler {
+    maxFrames: number;
+    static frameTimeFactor: number;
+    frame: number;
+    index: number;
+    constructor(SchedulerAction?: typeof AsyncAction, maxFrames?: number): void;
+    flush(): void;
+  }
+
+  declare class VirtualAction<T> extends AsyncAction<T> {
+    scheduler: AsyncScheduler | VirtualTimeScheduler;
+    work: (state?: T) => void;
+    index: number;
+    active: boolean;
+    constructor(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      work: (state?: T) => void,
+      index?: number
+    ): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+    requestAsyncId(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      id?: any,
+      delay?: number
+    ): any;
+    recycleAsyncId(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      id?: any,
+      delay?: number
+    ): any;
+    _execute(state: T, delay: number): any;
+    static sortActions<T>(a: VirtualAction<T>, b: VirtualAction<T>): 1 | -1 | 0;
+  }
+
+  declare class Scheduler implements rxjs$SchedulerLike {
+    static now: () => number;
+    constructor(SchedulerAction: typeof Action, now?: () => number): void;
+    now: () => number;
+    schedule<T>(
+      work: (state?: T) => void,
+      delay?: number,
+      state?: T
+    ): rxjs$Subscription;
+  }
+
+  declare interface ArgumentOutOfRangeError extends Error {}
+
+  declare interface EmptyError extends Error {}
+
+  declare interface ObjectUnsubscribedError extends Error {}
+
+  declare interface UnsubscriptionError extends Error {
+    +errors: any[];
+  }
+
+  declare interface TimeoutError extends Error {}
+
+  declare type ConditionFunc<S> = (state: S) => boolean;
+  declare type IterateFunc<S> = (state: S) => S;
+  declare type ResultFunc<S, T> = (state: S) => T;
+  declare interface GenerateBaseOptions<S> {
+    initialState: S;
+    condition?: ConditionFunc<S>;
+    iterate: IterateFunc<S>;
+    scheduler?: rxjs$SchedulerLike;
+  }
+  declare interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
+    resultSelector: ResultFunc<S, T>;
+  }
+
+  declare class AsapScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<mixed>): void;
+  }
+
+  declare class AsyncScheduler extends Scheduler {
+    static delegate: Scheduler;
+    actions: Array<AsyncAction<mixed>>;
+    // @deprecated  internal use only
+    active: boolean;
+    // @deprecated  internal use only
+    scheduled: any;
+    constructor(SchedulerAction: typeof Action, now?: () => number): void;
+    schedule<T>(
+      work: (state?: T) => void,
+      delay?: number,
+      state?: T
+    ): rxjs$Subscription;
+    flush(action: AsyncAction<mixed>): void;
+  }
+
+  declare class QueueScheduler extends AsyncScheduler {}
+
+  declare class AnimationFrameScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<mixed>): void;
+  }
+
+  declare class AsyncAction<T> extends Action<T> {
+    scheduler: AsyncScheduler;
+    work: (state?: T) => void;
+    id: mixed;
+    state: T;
+    delay: number;
+    pending: boolean;
+    constructor(scheduler: AsyncScheduler, work: (state?: T) => void): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+    requestAsyncId(scheduler: AsyncScheduler, id?: mixed, delay?: number): any;
+    recycleAsyncId(scheduler: AsyncScheduler, id: mixed, delay?: number): any;
+    execute(state: T, delay: number): any;
+    _execute(state: T, delay: number): any;
+    // @deprecated  This is an internal implementation detail, do not use.
+    _unsubscribe(): void;
+  }
+
+  declare class Action<T> extends rxjs$Subscription {
+    constructor(scheduler: Scheduler, work: (state?: T) => void): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+  }
+}
+
+declare module "rxjs/operators" {
+  declare export function audit<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function auditTime<T>(
+    duration: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function buffer<T>(
+    closingNotifier: rxjs$Observable<any>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferCount<T>(
+    bufferSize: number,
+    startBufferEvery?: number
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    bufferCreationInterval: ?number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    bufferCreationInterval: ?number,
+    maxBufferSize: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferToggle<T, O>(
+    openings: rxjs$SubscribableOrPromise<O>,
+    closingSelector: (value: O) => rxjs$SubscribableOrPromise<mixed>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferWhen<T>(
+    closingSelector: () => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  // declare export function catchError<T>(selector: (err: any, caught: rxjs$Observable<T>) => empty): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function catchError<T, R>(
+    selector: (err: any, caught: rxjs$Observable<T>) => rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<T, T | R>;
+
+  declare export function combineAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T[]
+  >;
+
+  declare export function combineAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
+
+  declare export function combineAll<T, R>(
+    project: (...values: T[]) => R
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
+
+  declare export function combineAll<R>(
+    project: (...values: Array<mixed>) => R
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    array: rxjs$ObservableInput<T>[]
+  ): rxjs$OperatorFunction<T, Array<T>>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, TOther, R>(
+    array: rxjs$ObservableInput<TOther>[],
+    project: (v1: T, ...values: Array<TOther>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated  Deprecated in favor of static concat.
+  declare export function concat<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T>(
+    ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, R>(
+    ...observables: Array<rxjs$ObservableInput<mixed> | rxjs$SchedulerLike>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function concatAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function concatAll<R>(): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function concatMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function concatMapTo<T>(
+    observable: rxjs$ObservableInput<T>
+  ): rxjs$OperatorFunction<mixed, T>;
+
+  // @deprecated
+  declare export function concatMapTo<T>(
+    observable: rxjs$ObservableInput<T>,
+    resultSelector: void
+  ): rxjs$OperatorFunction<mixed, T>;
+  // @deprecated
+  declare export function concatMapTo<T, I, R>(
+    observable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function count<T>(
+    predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
+  ): rxjs$OperatorFunction<T, number>;
+
+  declare export function debounce<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function debounceTime<T>(
+    dueTime: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function defaultIfEmpty<T>(
+    defaultValue?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function delay<T>(
+    delay: number | Date,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function delayWhen<T>(
+    delayDurationSelector: (value: T, index: number) => rxjs$Observable<mixed>,
+    subscriptionDelay?: rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function dematerialize<T>(): rxjs$OperatorFunction<
+    rxjs$Notification<T>,
+    T
+  >;
+
+  declare export function distinct<T, K>(
+    keySelector?: (value: T) => K,
+    flushes?: rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilChanged<T>(
+    compare?: (x: T, y: T) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilChanged<T, K>(
+    compare: (x: K, y: K) => boolean,
+    keySelector: (x: T) => K
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilKeyChanged<T>(
+    key: $Keys<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilKeyChanged<T, K: $Keys<T>>(
+    key: K,
+    compare: (x: mixed, y: mixed) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function elementAt<T>(
+    index: number,
+    defaultValue?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function endWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function endWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    v5: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    v5: T,
+    v6: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    ...array: Array<T | rxjs$SchedulerLike>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function every<T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function exhaust<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function exhaust<R>(): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function exhaustMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector is no longer supported. Use inner map instead.
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function expand<T, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<R>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function expand<T>(
+    project: (value: T, index: number) => rxjs$ObservableInput<T>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function filter<T, S: T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, S>;
+
+  declare export function filter<T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function finalize<T>(
+    callback: () => void
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function find<T, S: T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, T | S | void>;
+
+  declare export function findIndex<T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, number>;
+
+  declare export function first<T>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean
+  ): rxjs$OperatorFunction<T, T>;
+
+  declare export function first<T, D>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    defaultValue?: D
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function groupBy<T, K>(
+    keySelector: (value: T) => K
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
+
+  declare export function groupBy<T, K>(
+    keySelector: (value: T) => K,
+    elementSelector: void,
+    durationSelector: (
+      grouped: rxjs$GroupedObservable<K, T>
+    ) => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
+
+  declare export function groupBy<T, K, R>(
+    keySelector: (value: T) => K,
+    elementSelector?: (value: T) => R,
+    durationSelector?: (
+      grouped: rxjs$GroupedObservable<K, R>
+    ) => rxjs$Observable<mixed>,
+    subjectSelector?: () => rxjs$Subject<R>
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, R>>;
+
+  declare export function ignoreElements<T, U>(): rxjs$OperatorFunction<T, U>;
+
+  declare export function isEmpty<T>(): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function last<T>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean
+  ): rxjs$OperatorFunction<T, T>;
+
+  declare export function last<T, D>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    defaultValue?: D
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function map<T, R>(
+    project: (value: T, index: number) => R,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mapTo<T, R>(value: R): rxjs$OperatorFunction<T, R>;
+
+  declare export function materialize<T>(): rxjs$OperatorFunction<
+    T,
+    rxjs$Notification<T>
+  >;
+
+  declare export function max<T>(
+    comparer?: (x: T, y: T) => number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated  Deprecated in favor of static merge.
+  declare export function merge<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T>(
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T>(
+    ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike | number>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | rxjs$SchedulerLike | number
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeAll<T>(
+    concurrent?: number
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, T>;
+
+  declare export function mergeMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector no longer supported, use inner map instead
+    resultSelector?:
+      | ((
+          outerValue: T,
+          innerValue: I,
+          outerIndex: number,
+          innerIndex: number
+        ) => R)
+      | number,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function flatMap<T, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<R>,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeMapTo<T>(
+    innerObservable: rxjs$ObservableInput<T>,
+    concurrent?: number
+  ): rxjs$OperatorFunction<mixed, T>;
+
+  // @deprecated
+  declare export function mergeMapTo<T, I, R>(
+    innerObservable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeScan<T, R>(
+    accumulator: (acc: R, value: T) => rxjs$ObservableInput<R>,
+    seed: R,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function min<T>(
+    comparer?: (x: T, y: T) => number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function multicast<T>(
+    subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
+
+  declare export function multicast<T>(
+    subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>,
+    selector?: rxjs$MonoTypeOperatorFunction<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function multicast<T, R>(
+    subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>, 
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<R>>;
+
+  declare export function multicast<T, R>(
+    subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>,
+    selector?: rxjs$OperatorFunction<T, R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function observeOn<T>(
+    scheduler: rxjs$SchedulerLike,
+    delay?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function onErrorResumeNext<T, R>(
+    v: rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<mixed>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    v: rxjs$ObservableInput<R>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
+    >
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$Observable<R>;
+
+  declare export function pairwise<T>(): rxjs$OperatorFunction<T, [T, T]>;
+
+  declare export function partition<T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    [rxjs$Observable<T>, rxjs$Observable<T>]
+  >;
+
+  declare export function pluck<T, R>(
+    ...properties: string[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publish<T>(): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    rxjs$ConnectableObservable<T>
+  >;
+
+  declare export function publish<T, R>(
+    selector: rxjs$OperatorFunction<T, R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publish<T>(
+    selector: rxjs$MonoTypeOperatorFunction<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function publishBehavior<T>(
+    value: T
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
+
+  declare export function publishLast<T>(): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    rxjs$ConnectableObservable<T>
+  >;
+
+  declare export function publishReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function publishReplay<T, R>(
+    bufferSize?: number,
+    windowTime?: number,
+    selector?: rxjs$OperatorFunction<T, R>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publishReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    selector?: rxjs$MonoTypeOperatorFunction<T>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated  Deprecated in favor of static race.
+  declare export function race<T>(
+    observables: Array<rxjs$Observable<T>>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T, R>(
+    observables: Array<rxjs$Observable<T>>
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T>(
+    ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T, R>(
+    ...observables: Array<
+      rxjs$Observable<mixed> | Array<rxjs$Observable<mixed>>
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function reduce<T>(
+    accumulator: (acc: T, value: T, index: number) => T,
+    seed?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function reduce<T>(
+    accumulator: (acc: T[], value: T, index: number) => T[],
+    seed: T[]
+  ): rxjs$OperatorFunction<T, T[]>;
+  declare export function reduce<T, R>(
+    accumulator: (acc: R, value: T, index: number) => R,
+    seed?: R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function repeat<T>(
+    count?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function repeatWhen<T>(
+    notifier: (notifications: rxjs$Observable<any>) => rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function retry<T>(
+    count?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function retryWhen<T>(
+    notifier: (errors: rxjs$Observable<any>) => rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function refCount<T>(): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function sample<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function sampleTime<T>(
+    period: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function scan<T>(
+    accumulator: (acc: T, value: T, index: number) => T,
+    seed?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function scan<T>(
+    accumulator: (acc: T[], value: T, index: number) => T[],
+    seed?: T[]
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function scan<T, R>(
+    accumulator: (acc: R, value: T, index: number) => R,
+    seed?: R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function sequenceEqual<T>(
+    compareTo: rxjs$Observable<T>,
+    comparor?: (a: T, b: T) => boolean
+  ): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function share<T>(): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function shareReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function single<T>(
+    predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skip<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipLast<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipUntil<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipWhile<T>(
+    predicate: (value: T, index: number) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T, D>(
+    v1: D,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function startWith<T, D, E>(
+    v1: D,
+    v2: E,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E>;
+
+  declare export function startWith<T, D, E, F>(
+    v1: D,
+    v2: E,
+    v3: F,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F>;
+
+  declare export function startWith<T, D, E, F, G>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G>;
+
+  declare export function startWith<T, D, E, F, G, H>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    v5: H,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G | H>;
+
+  declare export function startWith<T, D, E, F, G, H, I>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    v5: H,
+    v6: I,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G | H | I>;
+
+  declare export function startWith<T, D>(
+    ...array: Array<D | rxjs$SchedulerLike>
+  ): rxjs$OperatorFunction<T, D>;
+
+  declare export function subscribeOn<T>(
+    scheduler: rxjs$SchedulerLike,
+    delay?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function switchAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function switchMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector is no longer supported, use inner map instead
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function switchMapTo<R>(
+    observable: rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
+  declare export function switchMapTo<T, R>(
+    observable: rxjs$ObservableInput<R>,
+    resultSelector: void
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
+  declare export function switchMapTo<T, I, R>(
+    observable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function take<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeLast<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeUntil<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeWhile<T, S: T>(
+    predicate: (value: T, index: number) => S,
+    inclusive?: boolean
+  ): rxjs$OperatorFunction<T, S>;
+
+  declare export function takeWhile<T>(
+    predicate: (value: T, index: number) => boolean,
+    inclusive?: boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function tap<T>(
+    next?: (x: T) => mixed,
+    error?: (e: any) => mixed,
+    complete?: () => mixed
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function tap<T>(
+    observer: rxjs$PartialObserver<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare interface ThrottleConfig {
+    leading?: boolean;
+    trailing?: boolean;
+  }
+
+  declare export function throttle<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>,
+    config?: ThrottleConfig
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function throttleTime<T>(
+    duration: number,
+    scheduler?: rxjs$SchedulerLike,
+    config?: ThrottleConfig
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export var throwIfEmpty: <T>(
+    errorFactory?: () => any
+  ) => rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function timeInterval<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$TimeInterval<T>>;
+
+  declare export function timeout<T>(
+    due: number | Date,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function timeoutWith<T, R>(
+    due: number | Date,
+    withObservable: rxjs$ObservableInput<R>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | R>;
+
+  declare export function timestamp<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Timestamp<T>>;
+
+  declare export function toArray<T>(): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function window<T>(
+    windowBoundaries: rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowCount<T>(
+    windowSize: number,
+    startWindowEvery?: number
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    windowCreationInterval: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    windowCreationInterval: number,
+    maxWindowSize: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowToggle<T, O>(
+    openings: rxjs$Observable<O>,
+    closingSelector: (openValue: O) => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowWhen<T>(
+    closingSelector: () => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function withLatestFrom<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  declare export function withLatestFrom<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  declare export function withLatestFrom<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, R>(
+    array: rxjs$ObservableInput<mixed>[],
+    project: (...values: Array<any>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated  Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    array: Array<rxjs$ObservableInput<T>>
+  ): rxjs$OperatorFunction<T, R>;
+  // @deprecated Deprecated in favor of static zip.
+
+  declare export function zip<T, TOther, R>(
+    array: Array<rxjs$ObservableInput<TOther>>,
+    project: (v1: T, ...values: Array<TOther>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function zipAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T[]
+  >;
+
+  declare export function zipAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
+
+  declare export function zipAll<T, R>(
+    project: (...values: T[]) => R
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
+
+  declare export function zipAll<R>(
+    project: (...values: Array<any>) => R
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function iif<T, F>(
+    condition: () => boolean,
+    trueResult?: rxjs$SubscribableOrPromise<T>,
+    falseResult?: rxjs$SubscribableOrPromise<F>
+  ): rxjs$Observable<T | F>;
+
+  declare export function throwError(
+    error: any,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$Observable<mixed>;
+}
+
+declare module "rxjs/ajax" {
+  declare export interface AjaxRequest {
+    url?: string;
+    body?: any;
+    user?: string;
+    async?: boolean;
+    method?: string;
+    headers?: Object;
+    timeout?: number;
+    password?: string;
+    hasContent?: boolean;
+    crossDomain?: boolean;
+    withCredentials?: boolean;
+    createXHR?: () => XMLHttpRequest;
+    progressSubscriber?: rxjs$Subscriber<mixed>;
+    responseType?: string;
+  }
+
+  declare export class AjaxResponse {
+    originalEvent: Event;
+    xhr: XMLHttpRequest;
+    request: AjaxRequest;
+    status: number;
+    response: any;
+    responseText: string;
+    responseType: string;
+    constructor(
+      originalEvent: Event,
+      xhr: XMLHttpRequest,
+      request: AjaxRequest
+    ): void;
+  }
+
+  declare export interface AjaxError extends Error {
+    xhr: XMLHttpRequest;
+    request: AjaxRequest;
+    status: number;
+    responseType: string;
+    response: any;
+  }
+
+  declare export interface AjaxTimeoutError extends AjaxError {}
+
+  declare interface AjaxCreationMethod {
+    (urlOrRequest: string | AjaxRequest): rxjs$Observable<AjaxResponse>;
+    get(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
+    post(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    put(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    patch(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    delete(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
+    getJSON<T>(url: string, headers?: Object): rxjs$Observable<T>;
+  }
+
+  declare export var ajax: AjaxCreationMethod;
+}
+
+declare module "rxjs/webSocket" {
+  declare type WebSocketMessage = string | ArrayBuffer | Blob;
+
+  declare export interface WebSocketSubjectConfig<T> {
+    url: string;
+    protocol?: string | Array<string>;
+    // @deprecated use {@link deserializer}
+    resultSelector?: (e: MessageEvent) => T;
+    serializer?: (value: T) => WebSocketMessage;
+    deserializer?: (e: MessageEvent) => T;
+    openObserver?: rxjs$NextObserver<Event>;
+    closeObserver?: rxjs$NextObserver<CloseEvent>;
+    closingObserver?: rxjs$NextObserver<void>;
+    WebSocketCtor?: { new(url: string, protocols?: string | string[]): WebSocket, ... };
+    binaryType?: "blob" | "arraybuffer";
+  }
+
+  declare class AnonymousSubject<T> extends rxjs$Subject<T> {
+    constructor(
+      destination?: rxjs$Observer<T>,
+      source?: rxjs$Observable<T>
+    ): void;
+    next(value: ?T): void;
+    error(err: any): void;
+    complete(): void;
+    // @deprecated This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  }
+
+  declare export class WebSocketSubject<T> extends AnonymousSubject<T> {
+    // @deprecated This is an internal implementation detail, do not use.
+    _output: rxjs$Subject<T>;
+    constructor(
+      urlConfigOrSource:
+        | string
+        | WebSocketSubjectConfig<T>
+        | rxjs$Observable<T>,
+      destination?: rxjs$Observer<T>
+    ): void;
+    lift<R>(operator: rxjs$Operator<T, R>): WebSocketSubject<R>;
+    multiplex(
+      subMsg: () => any,
+      unsubMsg: () => any,
+      messageFilter: (value: T) => boolean
+    ): rxjs$Observable<mixed>;
+    // @deprecated This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+    unsubscribe(): void;
+  }
+
+  declare export function webSocket<T>(
+    urlConfigOrSource: string | WebSocketSubjectConfig<T>
+  ): WebSocketSubject<T>;
+}
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_imports.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_imports.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_imports.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_imports.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_observable.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_observable.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_observable.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_observable.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_audit.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_audit.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_audit.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_audit.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_auditTime.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_auditTime.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_auditTime.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_auditTime.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatAll.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatAll.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatMap.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatMap.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_concatMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_concatMapTo.js
diff --git a/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_count.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_count.js
new file mode 100644
index 0000000000..dacf7826bf
--- /dev/null
+++ b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_count.js
@@ -0,0 +1,26 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, Observable } from "rxjs";
+import { count, buffer } from "rxjs/operators";
+
+it("should always infer number", () => {
+  const o = of(1, 2, 3).pipe(count(x => x > 1));
+  const j = of("a", "b", "c").pipe(count(x => x === "a"));
+});
+
+it("should accept empty parameter", () => {
+  const o = of(1, 2, 3).pipe(count());
+});
+
+it("should infer source observable type in parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(
+    count((x, i, source: Observable<string>) => x === 3)
+  );
+});
+
+it("should expect function parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(count(9));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_debounce.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_debounce.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_debounce.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_debounce.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_debounceTime.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_debounceTime.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_debounceTime.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_debounceTime.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_delay.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_delay.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_delay.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_delay.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinct.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinct.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinct.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinct.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinctUntilChanged.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinctUntilChanged.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinctUntilChanged.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinctUntilChanged.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinctUntilKeyChanged.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinctUntilKeyChanged.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_distinctUntilKeyChanged.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_distinctUntilKeyChanged.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_endWith.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_endWith.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_endWith.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_endWith.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_exhaust.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_exhaust.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_exhaust.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_exhaust.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_exhaustMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_exhaustMap.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_exhaustMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_exhaustMap.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_filter.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_filter.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_filter.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_filter.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_find.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_find.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_find.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_find.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_findIndex.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_findIndex.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_findIndex.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_findIndex.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_first.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_first.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_first.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_first.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_last.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_last.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_last.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_last.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeAll.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeAll.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeMap.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeMap.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_mergeMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_mergeMapTo.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_retry.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_retry.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_retry.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_retry.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_retryWhen.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_retryWhen.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_retryWhen.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_retryWhen.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skip.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skip.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skip.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skip.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipLast.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipLast.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipLast.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipLast.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipUntil.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipUntil.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipUntil.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipUntil.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipWhile.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipWhile.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_skipWhile.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_skipWhile.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_startWith.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_startWith.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_startWith.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_startWith.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchAll.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchAll.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchAll.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchAll.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchMap.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchMap.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchMap.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchMap.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchMapTo.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchMapTo.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_switchMapTo.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_switchMapTo.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_take.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_take.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_take.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_take.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeLast.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeLast.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeLast.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeLast.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeUntil.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeUntil.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeUntil.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeUntil.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeWhile.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeWhile.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_takeWhile.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_operator_takeWhile.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_pipe.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_pipe.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_pipe.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_pipe.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_zip.js b/definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_zip.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_zip.js
rename to definitions/npm/rxjs_v6.x.x/flow_v0.201.x-/test_zip.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/rxjs_v7.x.x.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/rxjs_v7.x.x.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/rxjs_v7.x.x.js
rename to definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/rxjs_v7.x.x.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_imports.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_imports.js
new file mode 100644
index 0000000000..36cc82c2b5
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_imports.js
@@ -0,0 +1,164 @@
+// @flow
+
+import {
+  Observable,
+  ConnectableObservable,
+  GroupedObservable,
+  observable,
+  Subject,
+  BehaviorSubject,
+  ReplaySubject,
+  AsyncSubject,
+  asapScheduler,
+  asyncScheduler,
+  queueScheduler,
+  animationFrameScheduler,
+  VirtualTimeScheduler,
+  Scheduler,
+  Subscription,
+  Subscriber,
+  Notification,
+  pipe,
+  noop,
+  identity,
+  isObservable,
+  type ArgumentOutOfRangeError,
+  type EmptyError,
+  type ObjectUnsubscribedError,
+  type UnsubscriptionError,
+  type TimeoutError,
+  bindCallback,
+  bindNodeCallback,
+  combineLatest,
+  concat,
+  defer,
+  empty,
+  forkJoin,
+  from,
+  fromEvent,
+  fromEventPattern,
+  generate,
+  iif,
+  interval,
+  merge,
+  never,
+  of,
+  onErrorResumeNext,
+  pairs,
+  race,
+  range,
+  throwError,
+  timer,
+  using,
+  zip,
+  EMPTY,
+  NEVER,
+  config
+} from "rxjs";
+
+import {
+  audit,
+  auditTime,
+  buffer,
+  bufferCount,
+  bufferTime,
+  bufferToggle,
+  bufferWhen,
+  catchError,
+  combineAll,
+  combineLatest as combineLatestOp,
+  concat as concatOp,
+  concatAll,
+  concatMap,
+  concatMapTo,
+  count,
+  debounce,
+  debounceTime,
+  defaultIfEmpty,
+  delay,
+  delayWhen,
+  dematerialize,
+  distinct,
+  distinctUntilChanged,
+  distinctUntilKeyChanged,
+  elementAt,
+  endWith,
+  every,
+  exhaust,
+  exhaustMap,
+  expand,
+  filter,
+  finalize,
+  find,
+  findIndex,
+  first,
+  groupBy,
+  ignoreElements,
+  isEmpty,
+  last,
+  map,
+  mapTo,
+  materialize,
+  max,
+  merge as mergeOp,
+  mergeAll,
+  mergeMap as mergeMapOp,
+  flatMap,
+  mergeMapTo,
+  mergeScan,
+  min,
+  multicast,
+  observeOn,
+  onErrorResumeNext as onErrorResumeNextOp,
+  pairwise,
+  partition,
+  pluck,
+  publish,
+  publishBehavior,
+  publishLast,
+  publishReplay,
+  race as raceOp,
+  reduce,
+  repeat,
+  repeatWhen,
+  retry,
+  retryWhen,
+  refCount,
+  sample,
+  sampleTime,
+  scan,
+  sequenceEqual,
+  share,
+  shareReplay,
+  single,
+  skip,
+  skipLast,
+  skipUntil,
+  skipWhile,
+  startWith,
+  subscribeOn,
+  switchAll,
+  switchMap,
+  switchMapTo,
+  take,
+  takeLast,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
+  throwIfEmpty,
+  timeInterval,
+  timeout,
+  timeoutWith,
+  timestamp,
+  toArray,
+  window,
+  windowCount,
+  windowTime,
+  windowToggle,
+  windowWhen,
+  withLatestFrom,
+  zip as zipOp,
+  zipAll
+} from "rxjs/operators";
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_observable.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_observable.js
new file mode 100644
index 0000000000..832bcd5b53
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_observable.js
@@ -0,0 +1,140 @@
+// @flow
+
+import { describe, it } from "flow-typed-test";
+import { Observable, of } from "rxjs";
+import { mapTo } from "rxjs/operators";
+
+declare function a<I: string, O: string>(
+  output: O
+): rxjs$OperatorFunction<I, O>;
+
+describe("pipe", () => {
+  it("should infer for no arguments", () => {
+    const o = of("foo").pipe();
+  });
+
+  it("should infer for 1 argument", () => {
+    const o = of("foo").pipe(a("1"));
+  });
+
+  it("should infer for 2 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2")
+    );
+  });
+
+  it("should infer for 3 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3")
+    );
+  });
+
+  it("should infer for 4 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4")
+    );
+  });
+
+  it("should infer for 5 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5")
+    );
+  });
+
+  it("should infer for 6 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6")
+    );
+  });
+
+  it("should infer for 7 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7")
+    );
+  });
+
+  it("should infer for 8 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8")
+    );
+  });
+
+  it("should infer for 9 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9")
+    );
+  });
+
+  it("should infer {} for more than 9 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9"),
+      a("10")
+    );
+  });
+
+  it("should require a type assertion for more than 9 arguments", () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const o: Observable<"10"> = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9"),
+      a("10")
+    );
+  });
+
+  // TODO I don't know what this test does or how to fix it
+  // it("should support operators that return generics", () => {
+  //   const customOperator = () => (a: Observable<*>) => a;
+  //   const o = of("foo").pipe(customOperator());
+  // });
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_audit.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_audit.js
new file mode 100644
index 0000000000..7db3d7a743
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_audit.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+
+import { of, NEVER } from "rxjs";
+import { audit } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(audit(() => of("foo")));
+  const p = of(1, 2, 3).pipe(audit(() => NEVER));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(audit(() => new Promise(() => {})));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(audit());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(audit((p: string) => of("foo")));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_auditTime.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_auditTime.js
new file mode 100644
index 0000000000..04afffba0d
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_auditTime.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { auditTime } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("a", "b", "c").pipe(auditTime(47));
+});
+
+it("should support a scheduler", () => {
+  const o = of("a", "b", "c").pipe(auditTime(47, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("a", "b", "c").pipe(auditTime());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("a", "b", "c").pipe(auditTime("47"));
+  // $FlowExpectedError[prop-missing]
+  const q = of("a", "b", "c").pipe(auditTime(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatAll.js
new file mode 100644
index 0000000000..0aea17bd47
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatAll.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(concatAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMap.js
new file mode 100644
index 0000000000..69be3b05b8
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMap.js
@@ -0,0 +1,47 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(concatMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMapTo.js
new file mode 100644
index 0000000000..8b15053564
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_concatMapTo.js
@@ -0,0 +1,55 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo")));
+});
+
+it("should infer correctly with multiple types", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(new Promise<string>(() => {})));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(concatMapTo(4));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_count.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_count.js
similarity index 100%
rename from definitions/npm/rxjs_v7.x.x/flow_v0.104.x-/test_operator_count.js
rename to definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_count.js
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounce.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounce.js
new file mode 100644
index 0000000000..9c2754c51f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounce.js
@@ -0,0 +1,20 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, timer } from "rxjs";
+import { debounce } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(debounce(() => timer(47)));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(debounce(() => new Promise<boolean>(() => {})));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(debounce());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(debounce(() => {}));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounceTime.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounceTime.js
new file mode 100644
index 0000000000..551eb7f621
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_debounceTime.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { debounceTime } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(debounceTime(47));
+});
+
+it("should support a scheduler", () => {
+  const o = of(1, 2, 3).pipe(debounceTime(47, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(debounceTime());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(debounceTime("foo"));
+  // $FlowExpectedError[prop-missing]
+  const q = of(1, 2, 3).pipe(debounceTime(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_delay.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_delay.js
new file mode 100644
index 0000000000..4b8ce6c761
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_delay.js
@@ -0,0 +1,26 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { delay } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(delay(100));
+});
+
+it("should support date parameter", () => {
+  const o = of(1, 2, 3).pipe(delay(new Date(2018, 9, 18)));
+});
+
+it("should support a scheduler", () => {
+  const o = of(1, 2, 3).pipe(delay(100, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(delay());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(delay("foo"));
+  // $FlowExpectedError[prop-missing]
+  const q = of(1, 2, 3).pipe(delay(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinct.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinct.js
new file mode 100644
index 0000000000..93eb08884f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinct.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinct } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(distinct());
+});
+
+it("should accept a keySelector", () => {
+  interface Person { name: string }
+  const o = of<Person>({ name: "Tim" }).pipe(distinct(person => person.name));
+});
+
+it("should accept flushes", () => {
+  const o = of(1, 2, 3).pipe(distinct(n => n, of("t", "i", "m")));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(distinct("F00D"));
+});
+
+it("should enforce types of keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  // $FlowExpectedError[implicit-inexact-object]
+  const o = of<{ id: string }>({ id: "F00D" }).pipe(distinct(item => item.foo));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilChanged.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilChanged.js
new file mode 100644
index 0000000000..fd1fdfeabc
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilChanged.js
@@ -0,0 +1,58 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinctUntilChanged } from "rxjs/operators";
+
+interface Person { name: string }
+const sample: Person = { name: "Tim" };
+
+it("should infer correctly", () => {
+  const o = of(sample).pipe(distinctUntilChanged());
+});
+
+it("should accept a compare", () => {
+  const o = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.name === p2.name)
+  );
+});
+
+it("should accept a keySelector", () => {
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1, name2) => name1 === name2, p => p.name)
+  );
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilChanged("F00D"));
+});
+
+it("should enforce types of compare", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.foo === p2.name)
+  );
+  // $FlowExpectedError[incompatible-call]
+  const p = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.name === p2.foo)
+  );
+});
+
+it("should enforce types of keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1, name2) => name1 === name2, p => p.foo)
+  );
+});
+
+it("should enforce types of compare in combination with keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1: number, name2) => name1 === name2, p => p.name)
+  );
+  // $FlowExpectedError[incompatible-call]
+  const p = of(sample).pipe(
+    distinctUntilChanged((name1, name2: number) => name1 === name2, p => p.name)
+  );
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilKeyChanged.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilKeyChanged.js
new file mode 100644
index 0000000000..1e5a6b20ef
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_distinctUntilKeyChanged.js
@@ -0,0 +1,35 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinctUntilKeyChanged } from "rxjs/operators";
+
+const sample = { name: "foobar", num: 42 };
+
+it("should infer correctly", () => {
+  const o = of(sample).pipe(distinctUntilKeyChanged("name"));
+});
+
+it("should infer correctly with compare", () => {
+  const o = of(sample).pipe(distinctUntilKeyChanged("name", () => true));
+});
+
+it("should enforce key set", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something"));
+});
+
+it("should enforce key set with compare", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something", () => true));
+});
+
+it("should enforce compare's type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("name", (a: number, b: number) => true));
+});
+
+it("should enforce key set and compare's type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something", (a: number, b: number) => true));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_endWith.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_endWith.js
new file mode 100644
index 0000000000..755f06982e
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_endWith.js
@@ -0,0 +1,41 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { endWith } from "rxjs/operators";
+
+it("should support a scheduler", () => {
+  const a = of(1, 2, 3).pipe(endWith(asyncScheduler));
+});
+
+it("should infer type for 1 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4));
+});
+
+it("should infer type for 2 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5));
+});
+
+it("should infer type for 3 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6));
+});
+
+it("should infer type for 4 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7));
+});
+
+it("should infer type for 5 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8));
+});
+
+it("should infer type for 6 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8, 9));
+});
+
+it("should infer type for rest parameters", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8, 9, 10));
+});
+
+it("should accept empty parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaust.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaust.js
new file mode 100644
index 0000000000..9b50b1417f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaust.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { exhaust } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(exhaust());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaust());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaustMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaustMap.js
new file mode 100644
index 0000000000..ca30684325
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_exhaustMap.js
@@ -0,0 +1,47 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { exhaustMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    exhaustMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    exhaustMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaustMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaustMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_filter.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_filter.js
new file mode 100644
index 0000000000..a98d1ae215
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_filter.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { filter } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of(1, 2, 3).pipe(filter(value => value < 3));
+});
+
+it("should support a predicate with an index", () => {
+  const o = of(1, 2, 3).pipe(filter((value, index) => index < 3));
+});
+
+it("should support a predicate and an argument", () => {
+  const o = of(1, 2, 3).pipe(filter(value => value < 3, "bonjour"));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(filter());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(filter(value => value < "3"));
+  // $FlowExpectedError[invalid-compare]
+  const p = of(1, 2, 3).pipe(filter((value, index) => index < "3"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_find.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_find.js
new file mode 100644
index 0000000000..97cdc6b7b6
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_find.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { find } from "rxjs/operators";
+
+it("should support a user-defined type guard", () => {
+  const o = of("foo").pipe(find((s: "foo") => true));
+});
+
+it("should support a user-defined type guard that takes an index", () => {
+  const o = of("foo").pipe(find((s: "foo", index) => true));
+});
+
+it("should support a user-defined type guard that takes an index and the source", () => {
+  const o = of("foo").pipe(find((s: "foo", index, source) => true));
+});
+
+it("should support a predicate", () => {
+  const o = of("foo").pipe(find(s => true));
+});
+
+it("should support a predicate that takes an index", () => {
+  const o = of("foo").pipe(find((s, index) => true));
+});
+
+it("should support a predicate that takes an index and the source", () => {
+  const o = of("foo").pipe(find((s, index, source) => true));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_findIndex.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_findIndex.js
new file mode 100644
index 0000000000..4fa811a5f4
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_findIndex.js
@@ -0,0 +1,42 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, Observable } from "rxjs";
+import { findIndex } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p === "foo"));
+});
+
+it("should support a predicate that takes an index ", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex((p, index) => index === 3));
+});
+
+it("should support a predicate that takes a source ", () => {
+  const o = of("foo", "bar", "baz").pipe(
+    findIndex((p, index, source) => p === "foo")
+  );
+});
+
+it("should support an argument ", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p === "foo", 123));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex((p: number) => p === 3));
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(findIndex((p, index: string) => p === 3));
+  // $FlowExpectedError[incompatible-call]
+  const q = of("foo", "bar", "baz").pipe(findIndex((p, index, source: Observable<number>) => p === 3));
+});
+
+it("should enforce predicate return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_first.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_first.js
new file mode 100644
index 0000000000..c181449cd6
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_first.js
@@ -0,0 +1,67 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { first } from "rxjs/operators";
+
+const isFooBar = (value: "foo" | "bar") => /^(foo|bar)$/.test(value);
+
+it("should support an undefined predicate with no default", () => {
+  const o = of("foo").pipe(first(undefined));
+});
+
+it("should support an undefined predicate with a T default", () => {
+  const o = of("foo").pipe(first(undefined, "bar"));
+});
+
+it("should support an undefined predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(undefined, false));
+});
+
+it("should default D to T with an undfined predicate", () => {
+  const o = of("foo").pipe(first<string>(undefined));
+});
+
+it("should support a null predicate with no default", () => {
+  const o = of("foo").pipe(first(null));
+});
+
+it("should support a null predicate with a T default", () => {
+  const o = of("foo").pipe(first(null, "bar"));
+});
+
+it("should support a null predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(null, false));
+});
+
+it("should default D to T with a null predicate", () => {
+  const o = of("foo").pipe(first<string>(null));
+});
+
+it("should support a user-defined type guard with no default", () => {
+  const o = of("foo").pipe(first(isFooBar));
+});
+
+it("should support a user-defined type guard with an S default", () => {
+  const o = of("foo").pipe(first(isFooBar, "bar"));
+});
+
+it("should widen a user-defined type guard with a non-S default", () => {
+  const o = of("foo").pipe(first(isFooBar, false));
+});
+
+it("should support a predicate with no default", () => {
+  const o = of("foo").pipe(first(x => !!x));
+});
+
+it("should support a predicate with a T default", () => {
+  const o = of("foo").pipe(first(x => !!x, "bar"));
+});
+
+it("should support a predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(x => !!x, false));
+});
+
+it("should default D to T with a predicate", () => {
+  const o = of("foo").pipe(first<string>(x => !!x)); // $Observable<string>
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_last.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_last.js
new file mode 100644
index 0000000000..bbd02e1009
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_last.js
@@ -0,0 +1,67 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { last } from "rxjs/operators";
+
+const isFooBar = (value: "foo" | "bar") => /^(foo|bar)$/.test(value);
+
+it("should support an undefined predicate with no default", () => {
+  const o = of("foo").pipe(last(undefined));
+});
+
+it("should support an undefined predicate with a T default", () => {
+  const o = of("foo").pipe(last(undefined, "bar"));
+});
+
+it("should support an undefined predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(undefined, false));
+});
+
+it("should default D to T with an undfined predicate", () => {
+  const o = of("foo").pipe(last<string>(undefined));
+});
+
+it("should support a null predicate with no default", () => {
+  const o = of("foo").pipe(last(null));
+});
+
+it("should support a null predicate with a T default", () => {
+  const o = of("foo").pipe(last(null, "bar"));
+});
+
+it("should support a null predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(null, false));
+});
+
+it("should default D to T with a null predicate", () => {
+  const o = of("foo").pipe(last<string>(null));
+});
+
+it("should support a user-defined type guard with no default", () => {
+  const o = of("foo").pipe(last(isFooBar));
+});
+
+it("should support a user-defined type guard with an S default", () => {
+  const o = of("foo").pipe(last(isFooBar, "bar"));
+});
+
+it("should widen a user-defined type guard with a non-S default", () => {
+  const o = of("foo").pipe(last(isFooBar, false));
+});
+
+it("should support a predicate with no default", () => {
+  const o = of("foo").pipe(last(x => !!x));
+});
+
+it("should support a predicate with a T default", () => {
+  const o = of("foo").pipe(last(x => !!x, "bar"));
+});
+
+it("should support a predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(x => !!x, false));
+});
+
+it("should default D to T with a predicate", () => {
+  const o = of("foo").pipe(last<string>(x => !!x)); // $Observable<string>
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeAll.js
new file mode 100644
index 0000000000..7cff7afeba
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeAll.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(mergeAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMap.js
new file mode 100644
index 0000000000..1005071dce
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMap.js
@@ -0,0 +1,74 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(mergeMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined));
+});
+
+it("should support a concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), 4));
+});
+
+it("should support a resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), (a, b) => b, 4));
+});
+
+it("should support a undefined resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined, 4));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => p));
+});
+
+it("should enforce types of the concurrent parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), "4"));
+});
+
+it("should enforce types of the concurrent parameter with a resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), a => a, "4"));
+});
+
+it("should enforce types of the concurrent parameter with an undefined resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined, "4"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMapTo.js
new file mode 100644
index 0000000000..117d72a6e9
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_mergeMapTo.js
@@ -0,0 +1,69 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo")));
+});
+
+it("should infer correctly multiple types", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(new Promise<string>(() => {})));
+});
+
+it("should support a concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), 4));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support a resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b) => b, 4));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(mergeMapTo(4));
+});
+
+it("should enforce types of the concurrent parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), "4"));
+});
+
+it("should enforce types of the concurrent parameter with a resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), a => a, "4"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retry.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retry.js
new file mode 100644
index 0000000000..8b2c4c1607
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retry.js
@@ -0,0 +1,18 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { retry } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(retry());
+});
+
+it("should accept a count parameter", () => {
+  const o = of(1, 2, 3).pipe(retry(47));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retry("aa"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retryWhen.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retryWhen.js
new file mode 100644
index 0000000000..35aace146f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_retryWhen.js
@@ -0,0 +1,23 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { retryWhen } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(retryWhen(errors => errors));
+});
+
+it("should infer correctly when the error observable has a different type", () => {
+  const o = of(1, 2, 3).pipe(retryWhen(errors => of("a", "b", "c")));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retryWhen());
+});
+
+it("should enforce types of the notifier", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retryWhen(() => 8));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skip.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skip.js
new file mode 100644
index 0000000000..9b557ac496
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skip.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skip } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skip(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skip());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skip("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipLast.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipLast.js
new file mode 100644
index 0000000000..b71a71afe8
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipLast.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipLast } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skipLast(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipLast());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skipLast("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipUntil.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipUntil.js
new file mode 100644
index 0000000000..33e6c47744
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipUntil.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipUntil } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skipUntil(of(4, "RxJS", 7)));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipUntil());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skipUntil("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipWhile.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipWhile.js
new file mode 100644
index 0000000000..c298bde435
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_skipWhile.js
@@ -0,0 +1,32 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipWhile } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value === "bar"));
+});
+
+it("should support a predicate with an index", () => {
+  const o = of("foo", "bar", "baz").pipe(
+    skipWhile((value, index) => index < 3)
+  );
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value < 3));
+  // $FlowExpectedError[invalid-compare]
+  const p = of("foo", "bar", "baz").pipe(skipWhile((value, index) => index < "3"));
+});
+
+it("should enforce predicate return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_startWith.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_startWith.js
new file mode 100644
index 0000000000..a59cc8a706
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_startWith.js
@@ -0,0 +1,33 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { startWith } from "rxjs/operators";
+
+it("should infer correctly with one value", () => {
+  const o = of(1, 2, 3).pipe(startWith(4));
+});
+
+it("should infer correctly with multiple values", () => {
+  const o = of(1, 2, 3).pipe(startWith(4, 5, 6));
+});
+
+it("should infer correctly with no value", () => {
+  const o = of(1, 2, 3).pipe(startWith());
+});
+
+it("should infer correctly with a value and a scheduler", () => {
+  const o = of(1, 2, 3).pipe(startWith(5, asyncScheduler));
+});
+
+it("should infer correctly with a different type", () => {
+  const o = of(1, 2, 3).pipe(startWith("foo"));
+});
+
+it("should infer correctly with multiple different types", () => {
+  const o = of(1, 2, 3).pipe(startWith("foo", 4, true));
+});
+
+it("should infer correctly with only a scheduler", () => {
+  const o = of(1, 2, 3).pipe(startWith(asyncScheduler));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchAll.js
new file mode 100644
index 0000000000..1236a076a1
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchAll.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(switchAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMap.js
new file mode 100644
index 0000000000..8f65e2120a
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMap.js
@@ -0,0 +1,47 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(switchMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMapTo.js
new file mode 100644
index 0000000000..8c75e9219f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_switchMapTo.js
@@ -0,0 +1,55 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo")));
+});
+
+it("should infer correctly with multiple types", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(new Promise<string>(() => {})));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(switchMapTo(4));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_take.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_take.js
new file mode 100644
index 0000000000..6f3ac98fa1
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_take.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { take } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(take(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(take("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeLast.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeLast.js
new file mode 100644
index 0000000000..35500716e0
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeLast.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeLast } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(takeLast(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(takeLast("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeUntil.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeUntil.js
new file mode 100644
index 0000000000..b6c93bf319
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeUntil.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(takeUntil(of(1, 2, 3)));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(takeUntil(value => value < 3));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeWhile.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeWhile.js
new file mode 100644
index 0000000000..8908b4a662
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_operator_takeWhile.js
@@ -0,0 +1,9 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeWhile } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of("foo").pipe(takeWhile(s => true, false));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_pipe.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_pipe.js
new file mode 100644
index 0000000000..477f120739
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_pipe.js
@@ -0,0 +1,163 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { pipe, of, Observable } from "rxjs";
+
+function a<I: string, O: string>(
+  input: I,
+  output: O
+): rxjs$UnaryFunction<I, O> {
+  return i => output;
+}
+
+it("should infer {} for no arguments", () => {
+  const o = pipe();
+});
+
+it("should infer for 1 argument", () => {
+  const o = pipe(a("0", "1"));
+});
+
+it("should infer for 2 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2")
+  );
+});
+
+it("should infer for 3 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3")
+  );
+});
+
+it("should infer for 4 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4")
+  );
+});
+
+it("should infer for 5 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5")
+  );
+});
+
+it("should infer for 6 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6")
+  );
+});
+
+it("should infer for 7 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7")
+  );
+});
+
+it("should infer for 8 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8")
+  );
+});
+
+it("should infer for 9 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9")
+  );
+});
+
+it("should infer {} for more than 9 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9"),
+    a("9", "10")
+  );
+});
+
+it("should require a type assertion for more than 9 arguments", () => {
+  // $FlowExpectedError[incompatible-type-arg]
+  const o: rxjs$UnaryFunction<"0", "10"> = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9"),
+    a("9", "10")
+  );
+});
+
+it("should return generic OperatorFunction 1", () => {
+  const customOperator = p => (a: Observable<any>) => a;
+
+  const staticPipe = pipe(customOperator("infer"));
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic OperatorFunction 2", () => {
+  const customOperator = () => (a: Observable<string>) => a;
+
+  const staticPipe = pipe(customOperator());
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic OperatorFunction 3", () => {
+  const customOperator = () => (a: Observable<any>) => a;
+
+  const staticPipe = pipe(customOperator());
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic function", () => {
+  const func = pipe(
+    (value: string) => value,
+    (value: string) => value + value
+  );
+  const value = func("foo");
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_zip.js b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_zip.js
new file mode 100644
index 0000000000..b9ab0763c3
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.104.x-v.200.x/test_zip.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { Observable, of, zip } from "rxjs";
+
+it("should support observables", () => {
+  const a = of(1);
+  const b = of("foo");
+  const c = of(true);
+  const o1 = zip(a, b, c);
+});
+
+it("should support mixed observables and promises", () => {
+  const a = Promise.resolve(1);
+  const b = of("foo");
+  const c = of(true);
+  const d = of(["bar"]);
+  const o1 = zip(a, b, c, d);
+});
+
+it("should return Array<T> when given a single promise", () => {
+  const a = Promise.resolve(1);
+  const o1 = zip(a);
+});
+
+it("should return Array<T> when given a single observable", () => {
+  const a = of(1);
+  const o1 = zip(a);
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/rxjs_v7.x.x.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/rxjs_v7.x.x.js
new file mode 100644
index 0000000000..949cb0a6f8
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/rxjs_v7.x.x.js
@@ -0,0 +1,3340 @@
+/** OPERATOR INTERFACES */
+declare interface rxjs$UnaryFunction<T, R> {
+  (source: T): R;
+}
+declare interface rxjs$OperatorFunction<T, R>
+  extends rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$Observable<R>> {}
+declare type rxjs$FactoryOrValue<T> = T | (() => T);
+declare interface rxjs$MonoTypeOperatorFunction<T>
+  extends rxjs$OperatorFunction<T, T> {}
+declare interface rxjs$Timestamp<T> {
+  value: T;
+  timestamp: number;
+}
+declare interface rxjs$TimeInterval<T> {
+  value: T;
+  interval: number;
+}
+/** SUBSCRIPTION INTERFACES */
+declare interface rxjs$Unsubscribable {
+  unsubscribe(): void;
+}
+declare type rxjs$TeardownLogic = rxjs$Unsubscribable | Function | void;
+declare interface rxjs$SubscriptionLike extends rxjs$Unsubscribable {
+  unsubscribe(): void;
+  +closed: boolean;
+}
+declare type rxjs$SubscribableOrPromise<T> =
+  | rxjs$Subscribable<T>
+  | rxjs$Subscribable<empty>
+  | Promise<T>
+  | rxjs$InteropObservable<T>;
+
+/** OBSERVABLE INTERFACES */
+declare interface rxjs$Subscribable<T> {
+  subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Unsubscribable;
+}
+declare type rxjs$ObservableInput<T> =
+  | rxjs$SubscribableOrPromise<T>
+  | Array<T>
+  | Iterable<T>;
+
+declare type rxjs$InteropObservable<T> = { [string | mixed]: () => rxjs$Subscribable<T>, ... };
+/** OBSERVER INTERFACES */
+declare interface rxjs$NextObserver<T> {
+  closed?: boolean;
+  +next: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete?: () => void;
+}
+declare interface rxjs$ErrorObserver<T> {
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error: (err: any) => void;
+  +complete?: () => void;
+}
+declare interface rxjs$CompletionObserver<T> {
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete: () => void;
+}
+declare type rxjs$PartialObserver<T> = {|
+  closed?: boolean;
+  +next?: (value: T) => void;
+  +error?: (err: any) => void;
+  +complete?: () => void;
+|}
+declare interface rxjs$Observer<T> {
+  closed: boolean;
+  next(value: T): void;
+  error(err: any): void;
+  complete(): void;
+}
+/** SCHEDULER INTERFACES */
+declare interface rxjs$TimestampProvider {
+  now(): number;
+}
+declare interface rxjs$SchedulerLike extends rxjs$TimestampProvider {
+  schedule<T>(
+    work: (state?: T) => void,
+    delay?: number,
+    state?: T
+  ): rxjs$Subscription;
+}
+declare interface rxjs$SchedulerAction<T> extends rxjs$Subscription {
+  schedule(state?: T, delay?: number): rxjs$Subscription;
+}
+
+declare interface rxjs$EventListenerOptions {
+  capture?: boolean;
+  passive?: boolean;
+  once?: boolean;
+}
+
+declare class rxjs$Observable<T> implements rxjs$Subscribable<T> {
+  // @deprecated  This is an internal implementation detail, do not use.
+  source: rxjs$Observable<any>;
+  // @deprecated  This is an internal implementation detail, do not use.
+  operator: rxjs$Operator<any, T>;
+  constructor(
+    subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
+  ): void;
+  static create(
+    subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
+  ): rxjs$Observable<T>;
+  subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Subscription;
+  subscribe(
+    next?: (value: T) => void,
+    error?: (error: any) => void,
+    complete?: () => void
+  ): rxjs$Subscription;
+  forEach(
+    next: (value: T) => void,
+    promiseCtor?: typeof Promise.constructor
+  ): Promise<void>;
+  pipe(): rxjs$Observable<T>;
+  pipe<A>(op1: rxjs$OperatorFunction<T, A>): rxjs$Observable<A>;
+  pipe<A, B>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>
+  ): rxjs$Observable<B>;
+  pipe<A, B, C>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>
+  ): rxjs$Observable<C>;
+  pipe<A, B, C, D>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>
+  ): rxjs$Observable<D>;
+  pipe<A, B, C, D, E>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>
+  ): rxjs$Observable<E>;
+  pipe<A, B, C, D, E, F>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>
+  ): rxjs$Observable<F>;
+  pipe<A, B, C, D, E, F, G>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>
+  ): rxjs$Observable<G>;
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>
+  ): rxjs$Observable<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>,
+    op9: rxjs$OperatorFunction<H, I>
+  ): rxjs$Observable<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: rxjs$OperatorFunction<T, A>,
+    op2: rxjs$OperatorFunction<A, B>,
+    op3: rxjs$OperatorFunction<B, C>,
+    op4: rxjs$OperatorFunction<C, D>,
+    op5: rxjs$OperatorFunction<D, E>,
+    op6: rxjs$OperatorFunction<E, F>,
+    op7: rxjs$OperatorFunction<F, G>,
+    op8: rxjs$OperatorFunction<G, H>,
+    op9: rxjs$OperatorFunction<H, I>,
+    ...operations: rxjs$OperatorFunction<any, any>[]
+  ): rxjs$Observable<mixed>;
+  /** @deprecated use firstValueFrom or lastValueFrom */
+  toPromise<T>(): Promise<T | void>;
+  /** @deprecated use firstValueFrom or lastValueFrom */
+  toPromise<T>(PromiseCtor: typeof Promise): Promise<T | void>;
+  /** @deprecated use firstValueFrom or lastValueFrom */
+  toPromise<T>(PromiseCtor: typeof Promise.constructor): Promise<T | void>;
+}
+
+declare class rxjs$Subscription implements rxjs$SubscriptionLike {
+  static EMPTY: rxjs$Subscription;
+  closed: boolean;
+  constructor(unsubscribe?: () => void): void;
+  unsubscribe(): void;
+  add(teardown: rxjs$TeardownLogic): void;
+  remove(subscription: rxjs$Subscription | rxjs$Unsubscribable | () => void): void;
+}
+
+declare interface rxjs$Operator<T, R> {
+  call(subscriber: rxjs$Subscriber<R>, source: any): rxjs$TeardownLogic;
+}
+
+declare class rxjs$Subscriber<T> extends rxjs$Subscription
+  implements rxjs$Observer<T> {
+  static create<T>(
+    next?: (x?: T) => void,
+    error?: (e?: any) => void,
+    complete?: () => void
+  ): rxjs$Subscriber<T>;
+  isStopped: boolean;
+  destination: rxjs$Observer<any> | rxjs$Subscriber<any>;
+  constructor(destination?: rxjs$Subscriber<T> | rxjs$Observer<T>): void;
+  next(value?: T): void;
+  error(err?: any): void;
+  complete(): void;
+  unsubscribe(): void;
+  _next(value: T): void;
+  _error(err: any): void;
+  _complete(): void;
+}
+
+declare class rxjs$ConnectableObservable<T> extends rxjs$Observable<T> {
+  source: rxjs$Observable<T>;
+  subjectFactory: () => rxjs$Subject<T>;
+  _subject: rxjs$Subject<T>;
+  _refCount: number;
+  _connection: rxjs$Subscription;
+  constructor(
+    source: rxjs$Observable<T>,
+    subjectFactory: () => rxjs$Subject<T>
+  ): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  getSubject(): rxjs$Subject<T>;
+  connect(): rxjs$Subscription;
+  refCount(): rxjs$Observable<T>;
+}
+
+declare class rxjs$Subject<T> extends rxjs$Observable<T>
+  implements rxjs$SubscriptionLike {
+  observers: rxjs$Observer<T>[];
+  closed: boolean;
+  isStopped: boolean;
+  hasError: boolean;
+  thrownError: any;
+  constructor(): void;
+  static create: Function;
+  next(value?: T): void;
+  error(err: any): void;
+  complete(): void;
+  unsubscribe(): void;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _trySubscribe(subscriber: rxjs$Subscriber<T>): rxjs$TeardownLogic;
+  // @deprecated  This is an internal implementation detail, do not use.
+  _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  asObservable(): rxjs$Observable<T>;
+}
+
+declare class rxjs$Notification<T> {
+  +kind: string;
+  +value: T;
+  +error: any;
+  +hasValue: boolean;
+  constructor(kind: string, value?: T, error?: any): void;
+  observe(observer: rxjs$PartialObserver<T>): any;
+  do(
+    next: (value: T) => void,
+    error?: (err: any) => void,
+    complete?: () => void
+  ): any;
+  accept(
+    nextOrObserver: rxjs$PartialObserver<T> | ((value: T) => void),
+    error?: (err: any) => void,
+    complete?: () => void
+  ): any;
+  toObservable(): rxjs$Observable<T>;
+  static createNext<T>(value: T): rxjs$Notification<T>;
+  static createError<T>(err?: any): rxjs$Notification<T>;
+  static createComplete(): rxjs$Notification<any>;
+}
+
+declare class rxjs$GroupedObservable<K, T> extends rxjs$Observable<T> {
+  +key: K;
+}
+
+declare interface rxjs$RefCountSubscription {
+  count: number;
+  unsubscribe: () => void;
+  closed: boolean;
+  attemptedToUnsubscribe: boolean;
+}
+
+declare function rxjs$throwError(
+  error: any,
+  scheduler?: rxjs$SchedulerLike
+): rxjs$Observable<any>;
+
+declare function rxjs$iif<T, F>(
+  condition: () => boolean,
+  trueResult?: rxjs$SubscribableOrPromise<T>,
+  falseResult?: rxjs$SubscribableOrPromise<F>
+): rxjs$Observable<T | F>;
+
+declare module "rxjs" {
+  declare interface FirstValueFromConfig<T> {
+    defaultValue: T
+  }
+
+  declare interface LastValueFromConfig<T> {
+    defaultValue: T
+  }
+
+  declare module.exports: {
+    Observable: typeof rxjs$Observable,
+    Subscriber: typeof rxjs$Subscriber,
+    Subscription: typeof rxjs$Subscription,
+    throwError: typeof rxjs$throwError,
+    iif: typeof rxjs$iif,
+    ConnectableObservable: typeof rxjs$ConnectableObservable,
+    GroupedObservable: typeof rxjs$GroupedObservable,
+    observable: string | mixed,
+    Subject: typeof rxjs$Subject,
+    BehaviorSubject: typeof BehaviorSubject,
+    ReplaySubject: typeof ReplaySubject,
+    AsyncSubject: typeof AsyncSubject,
+    asapScheduler: AsapScheduler,
+    asyncScheduler: AsyncScheduler,
+    queueScheduler: QueueScheduler,
+    animationFrameScheduler: AnimationFrameScheduler,
+    VirtualTimeScheduler: typeof VirtualTimeScheduler,
+    VirtualAction: typeof VirtualAction,
+    Scheduler: typeof Scheduler,
+    Notification: typeof rxjs$Notification,
+    pipe: (<T>() => rxjs$UnaryFunction<T, T>) &
+      (<T, A>(fn1: rxjs$UnaryFunction<T, A>) => rxjs$UnaryFunction<T, A>) &
+      (<T, A, B>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>
+      ) => rxjs$UnaryFunction<T, B>) &
+      (<T, A, B, C>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>
+      ) => rxjs$UnaryFunction<T, C>) &
+      (<T, A, B, C, D>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>
+      ) => rxjs$UnaryFunction<T, D>) &
+      (<T, A, B, C, D, E>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>
+      ) => rxjs$UnaryFunction<T, E>) &
+      (<T, A, B, C, D, E, F>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>
+      ) => rxjs$UnaryFunction<T, F>) &
+      (<T, A, B, C, D, E, F, G>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>
+      ) => rxjs$UnaryFunction<T, G>) &
+      (<T, A, B, C, D, E, F, G, H>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>
+      ) => rxjs$UnaryFunction<T, H>) &
+      (<T, A, B, C, D, E, F, G, H, I>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>,
+        fn9: rxjs$UnaryFunction<H, I>
+      ) => rxjs$UnaryFunction<T, I>) &
+      (<T, A, B, C, D, E, F, G, H, I>(
+        fn1: rxjs$UnaryFunction<T, A>,
+        fn2: rxjs$UnaryFunction<A, B>,
+        fn3: rxjs$UnaryFunction<B, C>,
+        fn4: rxjs$UnaryFunction<C, D>,
+        fn5: rxjs$UnaryFunction<D, E>,
+        fn6: rxjs$UnaryFunction<E, F>,
+        fn7: rxjs$UnaryFunction<F, G>,
+        fn8: rxjs$UnaryFunction<G, H>,
+        fn9: rxjs$UnaryFunction<H, I>,
+        ...fns: rxjs$UnaryFunction<any, any>[]
+      ) => rxjs$UnaryFunction<T, mixed>),
+    noop(): void,
+    identity<T>(x: T): T,
+    isObservable<T>(obj: any): boolean,
+    concat: (<T>(
+      v1: rxjs$ObservableInput<T>,
+      scheduler?: rxjs$SchedulerLike
+    ) => rxjs$Observable<T>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T>(
+        ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike)[]
+      ) => rxjs$Observable<T>) &
+      (<T, R>(
+        ...observables: (rxjs$ObservableInput<any> | rxjs$SchedulerLike)[]
+      ) => rxjs$Observable<R>),
+    defer<T>(
+      observableFactory: () => rxjs$SubscribableOrPromise<T>
+    ): rxjs$Observable<T>,
+    forkJoin: (<T>(
+      sources: [rxjs$ObservableInput<T>]
+    ) => rxjs$Observable<T[]>) &
+      (<T, T2>(
+        sources: [rxjs$ObservableInput<T>, rxjs$ObservableInput<T2>]
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>
+        ]
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>,
+          rxjs$ObservableInput<T5>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        sources: [
+          rxjs$ObservableInput<T>,
+          rxjs$ObservableInput<T2>,
+          rxjs$ObservableInput<T3>,
+          rxjs$ObservableInput<T4>,
+          rxjs$ObservableInput<T5>,
+          rxjs$ObservableInput<T6>
+        ]
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(sources: Array<rxjs$ObservableInput<T>>) => rxjs$Observable<T[]>) &
+      (<T>(v1: rxjs$ObservableInput<T>) => rxjs$Observable<T[]>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      // @deprecated resultSelector is deprecated, pipe to map instead
+      ((
+        ...args: Array<rxjs$ObservableInput<any> | Function>
+      ) => rxjs$Observable<any>) &
+      (<T>(...sources: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>),
+    from<T>(
+      input:
+        | rxjs$ObservableInput<T>
+        | rxjs$ObservableInput<rxjs$ObservableInput<T>>,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<T>,
+    ArgumentOutOfRangeError: ArgumentOutOfRangeError,
+    EmptyError: EmptyError,
+    ObjectUnsubscribedError: ObjectUnsubscribedError,
+    UnsubscriptionError: UnsubscriptionError,
+    TimeoutError: TimeoutError,
+    fromEvent: <T>(
+      target: mixed,
+      eventName: string,
+      options?: rxjs$EventListenerOptions | ((...args: any[]) => T),
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      resultSelector?: (...args: any[]) => T
+    ) => rxjs$Observable<T>,
+    fromEventPattern: (<T>(
+      addHandler: (handler: Function) => any,
+      removeHandler?: (handler: Function, signal?: any) => void
+    ) => rxjs$Observable<T>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T>(
+        addHandler: (handler: Function) => any,
+        removeHandler?: (handler: Function, signal?: any) => void,
+        resultSelector?: (...args: any[]) => T
+      ) => rxjs$Observable<T>),
+    generate<T, S>(
+      initialState: S,
+      condition: ConditionFunc<S>,
+      iterate: IterateFunc<S>,
+      resultSelector: ResultFunc<S, T>,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<T>,
+    interval(
+      period?: number,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    merge: (<T>(
+      ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike | number)[]
+    ) => rxjs$Observable<T>) &
+      (<T, R>(
+        ...observables: (
+          | rxjs$ObservableInput<any>
+          | rxjs$SchedulerLike
+          | number
+        )[]
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        v1: rxjs$ObservableInput<T>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T>) &
+      (<T>(
+        v1: rxjs$ObservableInput<T>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        concurrent?: number,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>),
+    of: (<T>(
+      a: T,
+      /** @deprecated Used scheduled function instead */
+      scheduler?: rxjs$SchedulerLike
+    ) => rxjs$Observable<T>) &
+      (<T, T2>(
+        a: T,
+        b: T2,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2>) &
+      (<T, T2, T3>(
+        a: T,
+        b: T2,
+        c: T3,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3>) &
+      (<T, T2, T3, T4>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4>) &
+      (<T, T2, T3, T4, T5>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
+      (<T, T2, T3, T4, T5, T6>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
+      (<T, T2, T3, T4, T5, T6, T7>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7>) &
+      (<T, T2, T3, T4, T5, T6, T7, T8>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        h: T8,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8>) &
+      (<T, T2, T3, T4, T5, T6, T7, T8, T9>(
+        a: T,
+        b: T2,
+        c: T3,
+        d: T4,
+        e: T5,
+        f: T6,
+        g: T7,
+        h: T8,
+        i: T9,
+        /** @deprecated Used scheduled function instead */
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>) &
+      (<T>(...args: Array<T>) => rxjs$Observable<T>),
+    onErrorResumeNext: (<R>(v: rxjs$ObservableInput<R>) => rxjs$Observable<R>) &
+      (<T2, T3, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, T5, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<R>) &
+      (<T2, T3, T4, T5, T6, R>(
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>),
+    // @deprecated use Object.entries instead
+    pairs<T>(
+      obj: Object,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<[string, T]>,
+    race: (<T>(observables: Array<rxjs$Observable<T>>) => rxjs$Observable<T>) &
+      (<T>(observables: Array<rxjs$Observable<any>>) => rxjs$Observable<T>) &
+      (<T>(
+        ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
+      ) => rxjs$Observable<T>),
+    range(
+      start?: number,
+      count?: number,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    timer(
+      dueTime?: number | Date,
+      periodOrScheduler?: number | rxjs$SchedulerLike,
+      scheduler?: rxjs$SchedulerLike
+    ): rxjs$Observable<number>,
+    using<T>(
+      resourceFactory: () => rxjs$Unsubscribable | void,
+      observableFactory: (
+        resource: rxjs$Unsubscribable | void
+      ) => rxjs$ObservableInput<T> | void
+    ): rxjs$Observable<T>,
+    config: {
+      Promise: typeof Promise.constructor,
+      useDeprecatedSynchronousErrorHandling: boolean,
+      ...
+    },
+    // @deprecated  resultSelector is no longer supported, pipe to map instead
+    zip: (<T, R>(
+      v1: rxjs$ObservableInput<T>,
+      resultSelector: (v1: T) => R
+    ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        resultSelector: (v1: T, v2: T2) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        resultSelector: (v1: T, v2: T2, v3: T3) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, T6, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+      ) => rxjs$Observable<R>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(array: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>) &
+      (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<T, R>(
+        array: rxjs$ObservableInput<T>[],
+        resultSelector: (...values: Array<T>) => R
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector is no longer supported, pipe to map instead
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        resultSelector: (...values: Array<any>) => R
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        ...observables: Array<rxjs$ObservableInput<T>>
+      ) => rxjs$Observable<T[]>) &
+      (<T, R>(
+        ...observables: Array<
+          rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
+        >
+      ) => rxjs$Observable<R>),
+    // @deprecated  Deprecated in favor of using {@link  NEVER} constant.
+    never(): rxjs$Observable<any>,
+    NEVER: rxjs$Observable<any>,
+    // @deprecated Deprecated in favor of using {@link EMPTY} constant.
+    empty(scheduler?: rxjs$SchedulerLike): rxjs$Observable<any>,
+    EMPTY: rxjs$Observable<any>,
+    // @deprecated resultSelector is no longer supported, use a mapping function.
+    bindCallback: ((
+      callbackFunc: Function,
+      resultSelector: Function,
+      scheduler?: rxjs$SchedulerLike
+    ) => (...args: any[]) => rxjs$Observable<any>) &
+      (<R1, R2, R3, R4>(
+        callbackFunc: (
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<mixed[]>) &
+      (<R1, R2, R3>(
+        callbackFunc: (callback: (res1: R1, res2: R2, res3: R3) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2, R3]>) &
+      (<R1, R2>(
+        callbackFunc: (callback: (res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2]>) &
+      (<R1>(
+        callbackFunc: (callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<R1>) &
+      ((
+        callbackFunc: (callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<void>) &
+      (<A1, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<mixed[]>) &
+      (<A1, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, R1, R2>(
+        callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
+      (<A1, R1>(
+        callbackFunc: (arg1: A1, callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<R1>) &
+      (<A1>(
+        callbackFunc: (arg1: A1, callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<void>) &
+      (<A1, A2, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, R1>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
+      (<A1, A2>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: () => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
+      (<A1, A2, A3, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
+      (<A1, A2, A3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, A5, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, A5, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4, A5>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: () => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<void>) &
+      (<A, R>(
+        callbackFunc: (...args: Array<A | ((result: R) => any)>) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: A[]) => rxjs$Observable<R>) &
+      (<A, R>(
+        callbackFunc: (...args: Array<A | ((...results: R[]) => any)>) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: A[]) => rxjs$Observable<R[]>) &
+      ((
+        callbackFunc: Function,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<any>),
+    // @deprecated resultSelector is deprecated, pipe to map instead
+    bindNodeCallback: ((
+      callbackFunc: Function,
+      resultSelector: Function,
+      scheduler?: rxjs$SchedulerLike
+    ) => (...args: any[]) => rxjs$Observable<any>) &
+      (<R1, R2, R3, R4>(
+        callbackFunc: (
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<R1, R2, R3>(
+        callbackFunc: (
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2, R3]>) &
+      (<R1, R2>(
+        callbackFunc: (callback: (err: any, res1: R1, res2: R2) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<[R1, R2]>) &
+      (<R1>(
+        callbackFunc: (callback: (err: any, res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<R1>) &
+      ((
+        callbackFunc: (callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => () => rxjs$Observable<void>) &
+      (<T, A1, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<T>) &
+      (<A1, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
+      (<A1, R1>(
+        callbackFunc: (arg1: A1, callback: (err: any, res1: R1) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<R1>) &
+      (<A1>(
+        callbackFunc: (arg1: A1, callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1) => rxjs$Observable<void>) &
+      (<A1, A2, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
+      (<A1, A2>(
+        callbackFunc: (arg1: A1, arg2: A2, callback: (err: any) => any) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
+      (<T, A1, A2, A3, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<T>) &
+      (<A1, A2, A3, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
+      (<A1, A2, A3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (
+            err: any,
+            res1: R1,
+            res2: R2,
+            res3: R3,
+            res4: R4,
+            ...args: any[]
+          ) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
+      (<A1, A2, A3, A4, A5, R1, R2, R3>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1, res2: R2, res3: R3) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2, R3]>) &
+      (<A1, A2, A3, A4, A5, R1, R2>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1, res2: R2) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<[R1, R2]>) &
+      (<A1, A2, A3, A4, A5, R1>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any, res1: R1) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<R1>) &
+      (<A1, A2, A3, A4, A5>(
+        callbackFunc: (
+          arg1: A1,
+          arg2: A2,
+          arg3: A3,
+          arg4: A4,
+          arg5: A5,
+          callback: (err: any) => any
+        ) => any,
+        scheduler?: rxjs$SchedulerLike
+      ) => (
+        arg1: A1,
+        arg2: A2,
+        arg3: A3,
+        arg4: A4,
+        arg5: A5
+      ) => rxjs$Observable<void>) &
+      ((
+        callbackFunc: Function,
+        scheduler?: rxjs$SchedulerLike
+      ) => (...args: any[]) => rxjs$Observable<mixed[]>),
+    // @deprecated resultSelector no longer supported, pipe to map instead
+    combineLatest: (<T, R>(
+      v1: rxjs$ObservableInput<T>,
+      resultSelector: (v1: T) => R,
+      scheduler?: rxjs$SchedulerLike
+    ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        resultSelector: (v1: T, v2: T2) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        resultSelector: (v1: T, v2: T2, v3: T3) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, T2, T3, T4, T5, T6, R>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      (<T, T2>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2]>) &
+      (<T, T2, T3>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3]>) &
+      (<T, T2, T3, T4>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4]>) &
+      (<T, T2, T3, T4, T5>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
+      (<T, T2, T3, T4, T5, T6>(
+        v1: rxjs$ObservableInput<T>,
+        v2: rxjs$ObservableInput<T2>,
+        v3: rxjs$ObservableInput<T3>,
+        v4: rxjs$ObservableInput<T4>,
+        v5: rxjs$ObservableInput<T5>,
+        v6: rxjs$ObservableInput<T6>,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
+      (<T>(
+        array: rxjs$ObservableInput<T>[],
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<T[]>) &
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<T, R>(
+        array: rxjs$ObservableInput<T>[],
+        resultSelector: (...values: Array<T>) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      // @deprecated resultSelector no longer supported, pipe to map instead
+      (<R>(
+        array: rxjs$ObservableInput<any>[],
+        resultSelector: (...values: Array<any>) => R,
+        scheduler?: rxjs$SchedulerLike
+      ) => rxjs$Observable<R>) &
+      (<T>(
+        ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
+      ) => rxjs$Observable<T[]>) &
+      (<T, R>(
+        ...observables: Array<
+          | rxjs$ObservableInput<T>
+          | ((...values: Array<T>) => R)
+          | rxjs$SchedulerLike
+        >
+      ) => rxjs$Observable<R>) &
+      (<R>(
+        ...observables: Array<
+          | rxjs$ObservableInput<any>
+          | ((...values: Array<any>) => R)
+          | rxjs$SchedulerLike
+        >
+      ) => rxjs$Observable<R>),
+    firstValueFrom: <+T, +D>(source: rxjs$Observable<T>, config?: FirstValueFromConfig<D>) => Promise<T | D>,
+    lastValueFrom: <+T, +D>(source: rxjs$Observable<T>, config?: LastValueFromConfig<D>) => Promise<T | D>,
+    ...
+  };
+
+  declare class BehaviorSubject<T> extends rxjs$Subject<T> {
+    constructor(_value: T): void;
+    get value(): T;
+    getValue(): T;
+    next(value?: T): void;
+  }
+
+  declare class ReplaySubject<T> extends rxjs$Subject<T> {
+    constructor(
+      bufferSize?: number,
+      windowTime?: number,
+      timestampProvider?: rxjs$TimestampProvider
+    ): void;
+  }
+
+  declare class AsyncSubject<T> extends rxjs$Subject<T> {
+    next(value?: T): void;
+    complete(): void;
+  }
+
+  declare class VirtualTimeScheduler extends AsyncScheduler {
+    maxFrames: number;
+    static frameTimeFactor: number;
+    frame: number;
+    index: number;
+    constructor(SchedulerAction?: typeof AsyncAction, maxFrames?: number): void;
+    flush(): void;
+  }
+
+  declare class VirtualAction<T> extends AsyncAction<T> {
+    scheduler: AsyncScheduler | VirtualTimeScheduler;
+    work: (state?: T) => void;
+    index: number;
+    active: boolean;
+    constructor(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      work: (state?: T) => void,
+      index?: number
+    ): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+    requestAsyncId(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      id?: any,
+      delay?: number
+    ): any;
+    recycleAsyncId(
+      scheduler: AsyncScheduler | VirtualTimeScheduler,
+      id?: any,
+      delay?: number
+    ): any;
+    _execute(state: T, delay: number): any;
+  }
+
+  declare class Scheduler implements rxjs$SchedulerLike {
+    static now: () => number;
+    constructor(SchedulerAction: typeof Action, now?: () => number): void;
+    now: () => number;
+    schedule<T>(
+      work: (state?: T) => void,
+      delay?: number,
+      state?: T
+    ): rxjs$Subscription;
+  }
+
+  declare interface ArgumentOutOfRangeError extends Error {}
+
+  declare interface EmptyError extends Error {}
+
+  declare interface ObjectUnsubscribedError extends Error {}
+
+  declare interface UnsubscriptionError extends Error {
+    +errors: any[];
+  }
+
+  declare interface TimeoutError extends Error {}
+
+  declare type ConditionFunc<S> = (state: S) => boolean;
+  declare type IterateFunc<S> = (state: S) => S;
+  declare type ResultFunc<S, T> = (state: S) => T;
+  declare interface GenerateBaseOptions<S> {
+    initialState: S;
+    condition?: ConditionFunc<S>;
+    iterate: IterateFunc<S>;
+    scheduler?: rxjs$SchedulerLike;
+  }
+  declare interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
+    resultSelector: ResultFunc<S, T>;
+  }
+
+  declare class AsapScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<mixed>): void;
+  }
+
+  declare class AsyncScheduler extends Scheduler {
+    static delegate: Scheduler;
+    actions: Array<AsyncAction<mixed>>;
+    // @deprecated  internal use only
+    active: boolean;
+    // @deprecated  internal use only
+    scheduled: any;
+    constructor(SchedulerAction: typeof Action, now?: () => number): void;
+    schedule<T>(
+      work: (state?: T) => void,
+      delay?: number,
+      state?: T
+    ): rxjs$Subscription;
+    flush(action: AsyncAction<mixed>): void;
+  }
+
+  declare class QueueScheduler extends AsyncScheduler {}
+
+  declare class AnimationFrameScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<mixed>): void;
+  }
+
+  declare class AsyncAction<T> extends Action<T> {
+    scheduler: AsyncScheduler;
+    work: (state?: T) => void;
+    id: mixed;
+    state: T;
+    delay: number;
+    pending: boolean;
+    constructor(scheduler: AsyncScheduler, work: (state?: T) => void): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+    requestAsyncId(scheduler: AsyncScheduler, id?: mixed, delay?: number): any;
+    recycleAsyncId(scheduler: AsyncScheduler, id: mixed, delay?: number): any;
+    execute(state: T, delay: number): any;
+    _execute(state: T, delay: number): any;
+    // @deprecated  This is an internal implementation detail, do not use.
+    _unsubscribe(): void;
+  }
+
+  declare class Action<T> extends rxjs$Subscription {
+    constructor(scheduler: Scheduler, work: (state?: T) => void): void;
+    schedule(state?: T, delay?: number): rxjs$Subscription;
+  }
+}
+
+declare module "rxjs/operators" {
+  declare export function audit<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function auditTime<T>(
+    duration: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function buffer<T>(
+    closingNotifier: rxjs$Observable<any>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferCount<T>(
+    bufferSize: number,
+    startBufferEvery?: number
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    bufferCreationInterval: ?number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferTime<T>(
+    bufferTimeSpan: number,
+    bufferCreationInterval: ?number,
+    maxBufferSize: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferToggle<T, O>(
+    openings: rxjs$SubscribableOrPromise<O>,
+    closingSelector: (value: O) => rxjs$SubscribableOrPromise<mixed>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function bufferWhen<T>(
+    closingSelector: () => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  // declare export function catchError<T>(selector: (err: any, caught: rxjs$Observable<T>) => empty): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function catchError<T, R>(
+    selector: (err: any, caught: rxjs$Observable<T>) => rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<T, T | R>;
+
+  declare export function combineAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T[]
+  >;
+
+  declare export function combineAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
+
+  declare export function combineAll<T, R>(
+    project: (...values: T[]) => R
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
+
+  declare export function combineAll<R>(
+    project: (...values: Array<mixed>) => R
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, R>(
+    array: rxjs$ObservableInput<T>[]
+  ): rxjs$OperatorFunction<T, Array<T>>;
+
+  // @deprecated Deprecated in favor of static combineLatest.
+  declare export function combineLatest<T, TOther, R>(
+    array: rxjs$ObservableInput<TOther>[],
+    project: (v1: T, ...values: Array<TOther>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated  Deprecated in favor of static concat.
+  declare export function concat<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T>(
+    ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  // @deprecated Deprecated in favor of static concat.
+  declare export function concat<T, R>(
+    ...observables: Array<rxjs$ObservableInput<mixed> | rxjs$SchedulerLike>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function concatAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function concatAll<R>(): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function concatMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function concatMapTo<T>(
+    observable: rxjs$ObservableInput<T>
+  ): rxjs$OperatorFunction<mixed, T>;
+
+  // @deprecated
+  declare export function concatMapTo<T>(
+    observable: rxjs$ObservableInput<T>,
+    resultSelector: void
+  ): rxjs$OperatorFunction<mixed, T>;
+  // @deprecated
+  declare export function concatMapTo<T, I, R>(
+    observable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function count<T>(
+    predicate?: (value: T, index: number) => boolean
+  ): rxjs$OperatorFunction<T, number>;
+
+  declare export function debounce<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function debounceTime<T>(
+    dueTime: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function defaultIfEmpty<T>(
+    defaultValue?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function delay<T>(
+    delay: number | Date,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function delayWhen<T>(
+    delayDurationSelector: (value: T, index: number) => rxjs$Observable<mixed>,
+    subscriptionDelay?: rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function dematerialize<T>(): rxjs$OperatorFunction<
+    rxjs$Notification<T>,
+    T
+  >;
+
+  declare export function distinct<T, K>(
+    keySelector?: (value: T) => K,
+    flushes?: rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilChanged<T>(
+    compare?: (x: T, y: T) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilChanged<T, K>(
+    compare: (x: K, y: K) => boolean,
+    keySelector: (x: T) => K
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilKeyChanged<T>(
+    key: $Keys<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function distinctUntilKeyChanged<T, K: $Keys<T>>(
+    key: K,
+    compare: (x: mixed, y: mixed) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function elementAt<T>(
+    index: number,
+    defaultValue?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function endWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function endWith<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    v5: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    v1: T,
+    v2: T,
+    v3: T,
+    v4: T,
+    v5: T,
+    v6: T,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+  declare export function endWith<T>(
+    ...array: Array<T | rxjs$SchedulerLike>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function every<T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function exhaust<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function exhaust<R>(): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function exhaustMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector is no longer supported. Use inner map instead.
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function expand<T, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<R>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function expand<T>(
+    project: (value: T, index: number) => rxjs$ObservableInput<T>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function filter<T, S: T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, S>;
+
+  declare export function filter<T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function finalize<T>(
+    callback: () => void
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function find<T, S: T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, T | S | void>;
+
+  declare export function findIndex<T>(
+    predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, number>;
+
+  declare export function first<T>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean
+  ): rxjs$OperatorFunction<T, T>;
+
+  declare export function first<T, D>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    defaultValue?: D
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function groupBy<T, K>(
+    keySelector: (value: T) => K
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
+
+  declare export function groupBy<T, K>(
+    keySelector: (value: T) => K,
+    elementSelector: void,
+    durationSelector: (
+      grouped: rxjs$GroupedObservable<K, T>
+    ) => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
+
+  declare export function groupBy<T, K, R>(
+    keySelector: (value: T) => K,
+    elementSelector?: (value: T) => R,
+    durationSelector?: (
+      grouped: rxjs$GroupedObservable<K, R>
+    ) => rxjs$Observable<mixed>,
+    subjectSelector?: () => rxjs$Subject<R>
+  ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, R>>;
+
+  declare export function ignoreElements<T, U>(): rxjs$OperatorFunction<T, U>;
+
+  declare export function isEmpty<T>(): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function last<T>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean
+  ): rxjs$OperatorFunction<T, T>;
+
+  declare export function last<T, D>(
+    predicate?: ?(
+      value: T,
+      index: number,
+      source: rxjs$Observable<T>
+    ) => boolean,
+    defaultValue?: D
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function map<T, R>(
+    project: (value: T, index: number) => R,
+    thisArg?: any
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mapTo<T, R>(value: R): rxjs$OperatorFunction<T, R>;
+
+  declare export function materialize<T>(): rxjs$OperatorFunction<
+    T,
+    rxjs$Notification<T>
+  >;
+
+  declare export function max<T>(
+    comparer?: (x: T, y: T) => number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated  Deprecated in favor of static merge.
+  declare export function merge<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T>(
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2>(
+    v2: rxjs$ObservableInput<T2>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    concurrent?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T>(
+    ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike | number>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static merge.
+  declare export function merge<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | rxjs$SchedulerLike | number
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeAll<T>(
+    concurrent?: number
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, T>;
+
+  declare export function mergeMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector no longer supported, use inner map instead
+    resultSelector?:
+      | ((
+          outerValue: T,
+          innerValue: I,
+          outerIndex: number,
+          innerIndex: number
+        ) => R)
+      | number,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function flatMap<T, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<R>,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeMapTo<T>(
+    innerObservable: rxjs$ObservableInput<T>,
+    concurrent?: number
+  ): rxjs$OperatorFunction<mixed, T>;
+
+  // @deprecated
+  declare export function mergeMapTo<T, I, R>(
+    innerObservable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function mergeScan<T, R>(
+    accumulator: (acc: R, value: T) => rxjs$ObservableInput<R>,
+    seed: R,
+    concurrent?: number
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function min<T>(
+    comparer?: (x: T, y: T) => number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function multicast<T>(
+    subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
+
+  declare export function multicast<T>(
+    rxjs$SubjectFactory: () => rxjs$Subject<T>
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
+
+  declare export function multicast<T>(
+    rxjs$SubjectFactory: () => rxjs$Subject<T>,
+    selector?: rxjs$MonoTypeOperatorFunction<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function multicast<T, R>(
+    rxjs$SubjectFactory: () => rxjs$Subject<T>
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<R>>;
+
+  declare export function multicast<T, R>(
+    rxjs$SubjectFactory: () => rxjs$Subject<T>,
+    selector?: rxjs$OperatorFunction<T, R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function observeOn<T>(
+    scheduler: rxjs$SchedulerLike,
+    delay?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function onErrorResumeNext<T, R>(
+    v: rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<mixed>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNext<T, R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    v: rxjs$ObservableInput<R>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
+    >
+  ): rxjs$Observable<R>;
+
+  declare export function onErrorResumeNextStatic<R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$Observable<R>;
+
+  declare export function pairwise<T>(): rxjs$OperatorFunction<T, [T, T]>;
+
+  declare export function partition<T>(
+    predicate: (value: T, index: number) => boolean,
+    thisArg?: any
+  ): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    [rxjs$Observable<T>, rxjs$Observable<T>]
+  >;
+
+  declare export function pluck<T, R>(
+    ...properties: string[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publish<T>(): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    rxjs$ConnectableObservable<T>
+  >;
+
+  declare export function publish<T, R>(
+    selector: rxjs$OperatorFunction<T, R>
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publish<T>(
+    selector: rxjs$MonoTypeOperatorFunction<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function publishBehavior<T>(
+    value: T
+  ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
+
+  declare export function publishLast<T>(): rxjs$UnaryFunction<
+    rxjs$Observable<T>,
+    rxjs$ConnectableObservable<T>
+  >;
+
+  declare export function publishReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function publishReplay<T, R>(
+    bufferSize?: number,
+    windowTime?: number,
+    selector?: rxjs$OperatorFunction<T, R>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function publishReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    selector?: rxjs$MonoTypeOperatorFunction<T>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated  Deprecated in favor of static race.
+  declare export function race<T>(
+    observables: Array<rxjs$Observable<T>>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T, R>(
+    observables: Array<rxjs$Observable<T>>
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T>(
+    ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  // @deprecated Deprecated in favor of static race.
+  declare export function race<T, R>(
+    ...observables: Array<
+      rxjs$Observable<mixed> | Array<rxjs$Observable<mixed>>
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function reduce<T>(
+    accumulator: (acc: T, value: T, index: number) => T,
+    seed?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function reduce<T>(
+    accumulator: (acc: T[], value: T, index: number) => T[],
+    seed: T[]
+  ): rxjs$OperatorFunction<T, T[]>;
+  declare export function reduce<T, R>(
+    accumulator: (acc: R, value: T, index: number) => R,
+    seed?: R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function repeat<T>(
+    count?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function repeatWhen<T>(
+    notifier: (notifications: rxjs$Observable<any>) => rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function retry<T>(
+    count?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function retryWhen<T>(
+    notifier: (errors: rxjs$Observable<any>) => rxjs$Observable<mixed>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function refCount<T>(): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function sample<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function sampleTime<T>(
+    period: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function scan<T>(
+    accumulator: (acc: T, value: T, index: number) => T,
+    seed?: T
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function scan<T>(
+    accumulator: (acc: T[], value: T, index: number) => T[],
+    seed?: T[]
+  ): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function scan<T, R>(
+    accumulator: (acc: R, value: T, index: number) => R,
+    seed?: R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function sequenceEqual<T>(
+    compareTo: rxjs$Observable<T>,
+    comparor?: (a: T, b: T) => boolean
+  ): rxjs$OperatorFunction<T, boolean>;
+
+  declare export function share<T>(): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function shareReplay<T>(
+    bufferSize?: number,
+    windowTime?: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function single<T>(
+    predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skip<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipLast<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipUntil<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function skipWhile<T>(
+    predicate: (value: T, index: number) => boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T>(
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T>(
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function startWith<T, D>(
+    v1: D,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D>;
+
+  declare export function startWith<T, D, E>(
+    v1: D,
+    v2: E,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E>;
+
+  declare export function startWith<T, D, E, F>(
+    v1: D,
+    v2: E,
+    v3: F,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F>;
+
+  declare export function startWith<T, D, E, F, G>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G>;
+
+  declare export function startWith<T, D, E, F, G, H>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    v5: H,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G | H>;
+
+  declare export function startWith<T, D, E, F, G, H, I>(
+    v1: D,
+    v2: E,
+    v3: F,
+    v4: G,
+    v5: H,
+    v6: I,
+    /** @deprecated */
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | D | E | F | G | H | I>;
+
+  declare export function startWith<T, D>(
+    ...array: Array<D>
+  ): rxjs$OperatorFunction<T, D>;
+
+  declare export function subscribeOn<T>(
+    scheduler: rxjs$SchedulerLike,
+    delay?: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function switchAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T
+  >;
+
+  declare export function switchMap<T, I, R>(
+    project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
+    // @deprecated resultSelector is no longer supported, use inner map instead
+    resultSelector?: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, I | R>;
+
+  declare export function switchMapTo<R>(
+    observable: rxjs$ObservableInput<R>
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
+  declare export function switchMapTo<T, R>(
+    observable: rxjs$ObservableInput<R>,
+    resultSelector: void
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
+  declare export function switchMapTo<T, I, R>(
+    observable: rxjs$ObservableInput<I>,
+    resultSelector: (
+      outerValue: T,
+      innerValue: I,
+      outerIndex: number,
+      innerIndex: number
+    ) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function take<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeLast<T>(
+    count: number
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeUntil<T>(
+    notifier: rxjs$Observable<any>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function takeWhile<T, S: T>(
+    predicate: (value: T, index: number) => S,
+    inclusive?: boolean
+  ): rxjs$OperatorFunction<T, S>;
+
+  declare export function takeWhile<T>(
+    predicate: (value: T, index: number) => boolean,
+    inclusive?: boolean
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function tap<T>(
+    next?: (x: T) => mixed,
+    error?: (e: any) => mixed,
+    complete?: () => mixed
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function tap<T>(
+    observer: rxjs$PartialObserver<T>
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare interface ThrottleConfig {
+    leading?: boolean;
+    trailing?: boolean;
+  }
+
+  declare export function throttle<T>(
+    durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>,
+    config?: ThrottleConfig
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function throttleTime<T>(
+    duration: number,
+    scheduler?: rxjs$SchedulerLike,
+    config?: ThrottleConfig
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export var throwIfEmpty: <T>(
+    errorFactory?: () => any
+  ) => rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function timeInterval<T>(
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$TimeInterval<T>>;
+
+  declare export function timeout<T>(
+    due: number | Date,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$MonoTypeOperatorFunction<T>;
+
+  declare export function timeoutWith<T, R>(
+    due: number | Date,
+    withObservable: rxjs$ObservableInput<R>,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, T | R>;
+
+  declare export function timestamp<T>(
+    scheduler?: rxjs$TimestampProvider
+  ): rxjs$OperatorFunction<T, rxjs$Timestamp<T>>;
+
+  declare export function toArray<T>(): rxjs$OperatorFunction<T, T[]>;
+
+  declare export function window<T>(
+    windowBoundaries: rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowCount<T>(
+    windowSize: number,
+    startWindowEvery?: number
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    windowCreationInterval: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowTime<T>(
+    windowTimeSpan: number,
+    windowCreationInterval: number,
+    maxWindowSize: number,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowToggle<T, O>(
+    openings: rxjs$Observable<O>,
+    closingSelector: (openValue: O) => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function windowWhen<T>(
+    closingSelector: () => rxjs$Observable<mixed>
+  ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
+
+  declare export function withLatestFrom<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  declare export function withLatestFrom<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  declare export function withLatestFrom<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  declare export function withLatestFrom<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, R>(
+    array: rxjs$ObservableInput<mixed>[]
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function withLatestFrom<T, R>(
+    array: rxjs$ObservableInput<mixed>[],
+    project: (...values: Array<any>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated  Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    project: (v1: T) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, R>(
+    v2: rxjs$ObservableInput<T2>,
+    project: (v1: T, v2: T2) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    project: (v1: T, v2: T2, v3: T3) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, T6, R>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>,
+    project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2>(
+    v2: rxjs$ObservableInput<T2>
+  ): rxjs$OperatorFunction<T, [T, T2]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>
+  ): rxjs$OperatorFunction<T, [T, T2, T3]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, T2, T3, T4, T5, T6>(
+    v2: rxjs$ObservableInput<T2>,
+    v3: rxjs$ObservableInput<T3>,
+    v4: rxjs$ObservableInput<T4>,
+    v5: rxjs$ObservableInput<T5>,
+    v6: rxjs$ObservableInput<T6>
+  ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    ...observables: Array<
+      rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
+    >
+  ): rxjs$OperatorFunction<T, R>;
+
+  // @deprecated Deprecated in favor of static zip.
+  declare export function zip<T, R>(
+    array: Array<rxjs$ObservableInput<T>>
+  ): rxjs$OperatorFunction<T, R>;
+  // @deprecated Deprecated in favor of static zip.
+
+  declare export function zip<T, TOther, R>(
+    array: Array<rxjs$ObservableInput<TOther>>,
+    project: (v1: T, ...values: Array<TOther>) => R
+  ): rxjs$OperatorFunction<T, R>;
+
+  declare export function zipAll<T>(): rxjs$OperatorFunction<
+    rxjs$ObservableInput<T>,
+    T[]
+  >;
+
+  declare export function zipAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
+
+  declare export function zipAll<T, R>(
+    project: (...values: T[]) => R
+  ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
+
+  declare export function zipAll<R>(
+    project: (...values: Array<any>) => R
+  ): rxjs$OperatorFunction<mixed, R>;
+
+  declare export function iif<T, F>(
+    condition: () => boolean,
+    trueResult?: rxjs$SubscribableOrPromise<T>,
+    falseResult?: rxjs$SubscribableOrPromise<F>
+  ): rxjs$Observable<T | F>;
+
+  declare export function throwError(
+    error: any,
+    scheduler?: rxjs$SchedulerLike
+  ): rxjs$Observable<mixed>;
+}
+
+declare module "rxjs/ajax" {
+  declare export interface AjaxRequest {
+    url: string;
+    body?: any;
+    method: string;
+    async: boolean;
+    headers: Object;
+    timeout: number;
+    user?: string;
+    password?: string;
+    crossDomain: boolean;
+    withCredentials: boolean;
+    responseType: string;
+  }
+
+  declare export interface AjaxConfig {
+    url: string;
+    body?: any;
+    async?: boolean;
+    method?: string;
+    headers?: Object;
+    timeout?: number;
+    user?: string;
+    password?: string;
+    crossDomain?: boolean;
+    withCredentials?: boolean;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+    responseType?: string;
+    createXHR?: () => XMLHttpRequest;
+    /** @deprecated */
+    progressSubscriber?: rxjs$Subscriber<mixed>;
+    includeDownloadProgress?: boolean;
+    includeUploadProgress?: boolean;
+    queryParams?: string | Object;
+  }
+
+
+  declare export class AjaxResponse {
+    originalEvent: Event;
+    xhr: XMLHttpRequest;
+    request: AjaxRequest;
+    status: number;
+    response: any;
+    responseText: string;
+    responseType: string;
+    constructor(
+      originalEvent: Event,
+      xhr: XMLHttpRequest,
+      request: AjaxRequest
+    ): void;
+  }
+
+  declare export interface AjaxError extends Error {
+    xhr: XMLHttpRequest;
+    request: AjaxRequest;
+    status: number;
+    responseType: string;
+    response: any;
+  }
+
+  declare export interface AjaxTimeoutError extends AjaxError {}
+
+  declare interface AjaxCreationMethod {
+    (urlOrRequest: string | AjaxConfig): rxjs$Observable<AjaxResponse>;
+    get(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
+    post(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    put(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    patch(
+      url: string,
+      body?: any,
+      headers?: Object
+    ): rxjs$Observable<AjaxResponse>;
+    delete(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
+    getJSON<T>(url: string, headers?: Object): rxjs$Observable<T>;
+  }
+
+  declare export var ajax: AjaxCreationMethod;
+}
+
+declare module "rxjs/webSocket" {
+  declare type WebSocketMessage = string | ArrayBuffer | Blob;
+
+  declare export interface WebSocketSubjectConfig<T> {
+    url: string;
+    protocol?: string | Array<string>;
+    // @deprecated use {@link deserializer}
+    resultSelector?: (e: MessageEvent) => T;
+    serializer?: (value: T) => WebSocketMessage;
+    deserializer?: (e: MessageEvent) => T;
+    openObserver?: rxjs$NextObserver<Event>;
+    closeObserver?: rxjs$NextObserver<CloseEvent>;
+    closingObserver?: rxjs$NextObserver<void>;
+    WebSocketCtor?: { new(url: string, protocols?: string | string[]): WebSocket, ... };
+    binaryType?: "blob" | "arraybuffer";
+  }
+
+  declare class AnonymousSubject<T> extends rxjs$Subject<T> {
+    constructor(
+      destination?: rxjs$Observer<T>,
+      source?: rxjs$Observable<T>
+    ): void;
+    next(value: ?T): void;
+    error(err: any): void;
+    complete(): void;
+    // @deprecated This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+  }
+
+  declare export class WebSocketSubject<T> extends AnonymousSubject<T> {
+    // @deprecated This is an internal implementation detail, do not use.
+    _output: rxjs$Subject<T>;
+    constructor(
+      urlConfigOrSource:
+        | string
+        | WebSocketSubjectConfig<T>
+        | rxjs$Observable<T>,
+      destination?: rxjs$Observer<T>
+    ): void;
+    multiplex(
+      subMsg: () => any,
+      unsubMsg: () => any,
+      messageFilter: (value: T) => boolean
+    ): rxjs$Observable<mixed>;
+    // @deprecated This is an internal implementation detail, do not use.
+    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
+    unsubscribe(): void;
+  }
+
+  declare export function webSocket<T>(
+    urlConfigOrSource: string | WebSocketSubjectConfig<T>
+  ): WebSocketSubject<T>;
+}
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_imports.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_imports.js
new file mode 100644
index 0000000000..36cc82c2b5
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_imports.js
@@ -0,0 +1,164 @@
+// @flow
+
+import {
+  Observable,
+  ConnectableObservable,
+  GroupedObservable,
+  observable,
+  Subject,
+  BehaviorSubject,
+  ReplaySubject,
+  AsyncSubject,
+  asapScheduler,
+  asyncScheduler,
+  queueScheduler,
+  animationFrameScheduler,
+  VirtualTimeScheduler,
+  Scheduler,
+  Subscription,
+  Subscriber,
+  Notification,
+  pipe,
+  noop,
+  identity,
+  isObservable,
+  type ArgumentOutOfRangeError,
+  type EmptyError,
+  type ObjectUnsubscribedError,
+  type UnsubscriptionError,
+  type TimeoutError,
+  bindCallback,
+  bindNodeCallback,
+  combineLatest,
+  concat,
+  defer,
+  empty,
+  forkJoin,
+  from,
+  fromEvent,
+  fromEventPattern,
+  generate,
+  iif,
+  interval,
+  merge,
+  never,
+  of,
+  onErrorResumeNext,
+  pairs,
+  race,
+  range,
+  throwError,
+  timer,
+  using,
+  zip,
+  EMPTY,
+  NEVER,
+  config
+} from "rxjs";
+
+import {
+  audit,
+  auditTime,
+  buffer,
+  bufferCount,
+  bufferTime,
+  bufferToggle,
+  bufferWhen,
+  catchError,
+  combineAll,
+  combineLatest as combineLatestOp,
+  concat as concatOp,
+  concatAll,
+  concatMap,
+  concatMapTo,
+  count,
+  debounce,
+  debounceTime,
+  defaultIfEmpty,
+  delay,
+  delayWhen,
+  dematerialize,
+  distinct,
+  distinctUntilChanged,
+  distinctUntilKeyChanged,
+  elementAt,
+  endWith,
+  every,
+  exhaust,
+  exhaustMap,
+  expand,
+  filter,
+  finalize,
+  find,
+  findIndex,
+  first,
+  groupBy,
+  ignoreElements,
+  isEmpty,
+  last,
+  map,
+  mapTo,
+  materialize,
+  max,
+  merge as mergeOp,
+  mergeAll,
+  mergeMap as mergeMapOp,
+  flatMap,
+  mergeMapTo,
+  mergeScan,
+  min,
+  multicast,
+  observeOn,
+  onErrorResumeNext as onErrorResumeNextOp,
+  pairwise,
+  partition,
+  pluck,
+  publish,
+  publishBehavior,
+  publishLast,
+  publishReplay,
+  race as raceOp,
+  reduce,
+  repeat,
+  repeatWhen,
+  retry,
+  retryWhen,
+  refCount,
+  sample,
+  sampleTime,
+  scan,
+  sequenceEqual,
+  share,
+  shareReplay,
+  single,
+  skip,
+  skipLast,
+  skipUntil,
+  skipWhile,
+  startWith,
+  subscribeOn,
+  switchAll,
+  switchMap,
+  switchMapTo,
+  take,
+  takeLast,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
+  throwIfEmpty,
+  timeInterval,
+  timeout,
+  timeoutWith,
+  timestamp,
+  toArray,
+  window,
+  windowCount,
+  windowTime,
+  windowToggle,
+  windowWhen,
+  withLatestFrom,
+  zip as zipOp,
+  zipAll
+} from "rxjs/operators";
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_observable.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_observable.js
new file mode 100644
index 0000000000..832bcd5b53
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_observable.js
@@ -0,0 +1,140 @@
+// @flow
+
+import { describe, it } from "flow-typed-test";
+import { Observable, of } from "rxjs";
+import { mapTo } from "rxjs/operators";
+
+declare function a<I: string, O: string>(
+  output: O
+): rxjs$OperatorFunction<I, O>;
+
+describe("pipe", () => {
+  it("should infer for no arguments", () => {
+    const o = of("foo").pipe();
+  });
+
+  it("should infer for 1 argument", () => {
+    const o = of("foo").pipe(a("1"));
+  });
+
+  it("should infer for 2 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2")
+    );
+  });
+
+  it("should infer for 3 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3")
+    );
+  });
+
+  it("should infer for 4 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4")
+    );
+  });
+
+  it("should infer for 5 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5")
+    );
+  });
+
+  it("should infer for 6 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6")
+    );
+  });
+
+  it("should infer for 7 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7")
+    );
+  });
+
+  it("should infer for 8 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8")
+    );
+  });
+
+  it("should infer for 9 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9")
+    );
+  });
+
+  it("should infer {} for more than 9 arguments", () => {
+    const o = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9"),
+      a("10")
+    );
+  });
+
+  it("should require a type assertion for more than 9 arguments", () => {
+    // $FlowExpectedError[incompatible-type-arg]
+    const o: Observable<"10"> = of("foo").pipe(
+      a("1"),
+      a("2"),
+      a("3"),
+      a("4"),
+      a("5"),
+      a("6"),
+      a("7"),
+      a("8"),
+      a("9"),
+      a("10")
+    );
+  });
+
+  // TODO I don't know what this test does or how to fix it
+  // it("should support operators that return generics", () => {
+  //   const customOperator = () => (a: Observable<*>) => a;
+  //   const o = of("foo").pipe(customOperator());
+  // });
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_audit.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_audit.js
new file mode 100644
index 0000000000..7db3d7a743
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_audit.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+
+import { of, NEVER } from "rxjs";
+import { audit } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(audit(() => of("foo")));
+  const p = of(1, 2, 3).pipe(audit(() => NEVER));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(audit(() => new Promise(() => {})));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(audit());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(audit((p: string) => of("foo")));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_auditTime.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_auditTime.js
new file mode 100644
index 0000000000..04afffba0d
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_auditTime.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { auditTime } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("a", "b", "c").pipe(auditTime(47));
+});
+
+it("should support a scheduler", () => {
+  const o = of("a", "b", "c").pipe(auditTime(47, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("a", "b", "c").pipe(auditTime());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("a", "b", "c").pipe(auditTime("47"));
+  // $FlowExpectedError[prop-missing]
+  const q = of("a", "b", "c").pipe(auditTime(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatAll.js
new file mode 100644
index 0000000000..0aea17bd47
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatAll.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(concatAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMap.js
new file mode 100644
index 0000000000..69be3b05b8
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMap.js
@@ -0,0 +1,47 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(concatMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(concatMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMapTo.js
new file mode 100644
index 0000000000..8b15053564
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_concatMapTo.js
@@ -0,0 +1,55 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { concatMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo")));
+});
+
+it("should infer correctly with multiple types", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(new Promise<string>(() => {})));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    concatMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(concatMapTo(of("foo"), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(concatMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(concatMapTo(4));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_count.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_count.js
new file mode 100644
index 0000000000..06ed56f43c
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_count.js
@@ -0,0 +1,19 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { count } from "rxjs/operators";
+
+it("should always infer number", () => {
+  const o = of(1, 2, 3).pipe(count(x => x > 1));
+  const j = of("a", "b", "c").pipe(count(x => x === "a"));
+});
+
+it("should accept empty parameter", () => {
+  const o = of(1, 2, 3).pipe(count());
+});
+
+it("should expect function parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(count(9));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounce.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounce.js
new file mode 100644
index 0000000000..9c2754c51f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounce.js
@@ -0,0 +1,20 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, timer } from "rxjs";
+import { debounce } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(debounce(() => timer(47)));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(debounce(() => new Promise<boolean>(() => {})));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(debounce());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(debounce(() => {}));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounceTime.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounceTime.js
new file mode 100644
index 0000000000..551eb7f621
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_debounceTime.js
@@ -0,0 +1,22 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { debounceTime } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(debounceTime(47));
+});
+
+it("should support a scheduler", () => {
+  const o = of(1, 2, 3).pipe(debounceTime(47, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(debounceTime());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(debounceTime("foo"));
+  // $FlowExpectedError[prop-missing]
+  const q = of(1, 2, 3).pipe(debounceTime(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_delay.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_delay.js
new file mode 100644
index 0000000000..4b8ce6c761
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_delay.js
@@ -0,0 +1,26 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { delay } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(delay(100));
+});
+
+it("should support date parameter", () => {
+  const o = of(1, 2, 3).pipe(delay(new Date(2018, 9, 18)));
+});
+
+it("should support a scheduler", () => {
+  const o = of(1, 2, 3).pipe(delay(100, asyncScheduler));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(delay());
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(delay("foo"));
+  // $FlowExpectedError[prop-missing]
+  const q = of(1, 2, 3).pipe(delay(47, "foo"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinct.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinct.js
new file mode 100644
index 0000000000..93eb08884f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinct.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinct } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(distinct());
+});
+
+it("should accept a keySelector", () => {
+  interface Person { name: string }
+  const o = of<Person>({ name: "Tim" }).pipe(distinct(person => person.name));
+});
+
+it("should accept flushes", () => {
+  const o = of(1, 2, 3).pipe(distinct(n => n, of("t", "i", "m")));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(distinct("F00D"));
+});
+
+it("should enforce types of keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  // $FlowExpectedError[implicit-inexact-object]
+  const o = of<{ id: string }>({ id: "F00D" }).pipe(distinct(item => item.foo));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilChanged.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilChanged.js
new file mode 100644
index 0000000000..fd1fdfeabc
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilChanged.js
@@ -0,0 +1,58 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinctUntilChanged } from "rxjs/operators";
+
+interface Person { name: string }
+const sample: Person = { name: "Tim" };
+
+it("should infer correctly", () => {
+  const o = of(sample).pipe(distinctUntilChanged());
+});
+
+it("should accept a compare", () => {
+  const o = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.name === p2.name)
+  );
+});
+
+it("should accept a keySelector", () => {
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1, name2) => name1 === name2, p => p.name)
+  );
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilChanged("F00D"));
+});
+
+it("should enforce types of compare", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.foo === p2.name)
+  );
+  // $FlowExpectedError[incompatible-call]
+  const p = of(sample).pipe(
+    distinctUntilChanged((p1, p2) => p1.name === p2.foo)
+  );
+});
+
+it("should enforce types of keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1, name2) => name1 === name2, p => p.foo)
+  );
+});
+
+it("should enforce types of compare in combination with keySelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(
+    distinctUntilChanged((name1: number, name2) => name1 === name2, p => p.name)
+  );
+  // $FlowExpectedError[incompatible-call]
+  const p = of(sample).pipe(
+    distinctUntilChanged((name1, name2: number) => name1 === name2, p => p.name)
+  );
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilKeyChanged.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilKeyChanged.js
new file mode 100644
index 0000000000..1e5a6b20ef
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_distinctUntilKeyChanged.js
@@ -0,0 +1,35 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { distinctUntilKeyChanged } from "rxjs/operators";
+
+const sample = { name: "foobar", num: 42 };
+
+it("should infer correctly", () => {
+  const o = of(sample).pipe(distinctUntilKeyChanged("name"));
+});
+
+it("should infer correctly with compare", () => {
+  const o = of(sample).pipe(distinctUntilKeyChanged("name", () => true));
+});
+
+it("should enforce key set", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something"));
+});
+
+it("should enforce key set with compare", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something", () => true));
+});
+
+it("should enforce compare's type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("name", (a: number, b: number) => true));
+});
+
+it("should enforce key set and compare's type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(sample).pipe(distinctUntilKeyChanged("something", (a: number, b: number) => true));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_endWith.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_endWith.js
new file mode 100644
index 0000000000..755f06982e
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_endWith.js
@@ -0,0 +1,41 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { endWith } from "rxjs/operators";
+
+it("should support a scheduler", () => {
+  const a = of(1, 2, 3).pipe(endWith(asyncScheduler));
+});
+
+it("should infer type for 1 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4));
+});
+
+it("should infer type for 2 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5));
+});
+
+it("should infer type for 3 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6));
+});
+
+it("should infer type for 4 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7));
+});
+
+it("should infer type for 5 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8));
+});
+
+it("should infer type for 6 parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8, 9));
+});
+
+it("should infer type for rest parameters", () => {
+  const a = of(1, 2, 3).pipe(endWith(4, 5, 6, 7, 8, 9, 10));
+});
+
+it("should accept empty parameter", () => {
+  const a = of(1, 2, 3).pipe(endWith());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaust.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaust.js
new file mode 100644
index 0000000000..9b50b1417f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaust.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { exhaust } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(exhaust());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaust());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaustMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaustMap.js
new file mode 100644
index 0000000000..ca30684325
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_exhaustMap.js
@@ -0,0 +1,47 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { exhaustMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    exhaustMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    exhaustMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(exhaustMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaustMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(exhaustMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_filter.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_filter.js
new file mode 100644
index 0000000000..a98d1ae215
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_filter.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { filter } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of(1, 2, 3).pipe(filter(value => value < 3));
+});
+
+it("should support a predicate with an index", () => {
+  const o = of(1, 2, 3).pipe(filter((value, index) => index < 3));
+});
+
+it("should support a predicate and an argument", () => {
+  const o = of(1, 2, 3).pipe(filter(value => value < 3, "bonjour"));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(filter());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(filter(value => value < "3"));
+  // $FlowExpectedError[invalid-compare]
+  const p = of(1, 2, 3).pipe(filter((value, index) => index < "3"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_find.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_find.js
new file mode 100644
index 0000000000..97cdc6b7b6
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_find.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { find } from "rxjs/operators";
+
+it("should support a user-defined type guard", () => {
+  const o = of("foo").pipe(find((s: "foo") => true));
+});
+
+it("should support a user-defined type guard that takes an index", () => {
+  const o = of("foo").pipe(find((s: "foo", index) => true));
+});
+
+it("should support a user-defined type guard that takes an index and the source", () => {
+  const o = of("foo").pipe(find((s: "foo", index, source) => true));
+});
+
+it("should support a predicate", () => {
+  const o = of("foo").pipe(find(s => true));
+});
+
+it("should support a predicate that takes an index", () => {
+  const o = of("foo").pipe(find((s, index) => true));
+});
+
+it("should support a predicate that takes an index and the source", () => {
+  const o = of("foo").pipe(find((s, index, source) => true));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_findIndex.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_findIndex.js
new file mode 100644
index 0000000000..4fa811a5f4
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_findIndex.js
@@ -0,0 +1,42 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of, Observable } from "rxjs";
+import { findIndex } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p === "foo"));
+});
+
+it("should support a predicate that takes an index ", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex((p, index) => index === 3));
+});
+
+it("should support a predicate that takes a source ", () => {
+  const o = of("foo", "bar", "baz").pipe(
+    findIndex((p, index, source) => p === "foo")
+  );
+});
+
+it("should support an argument ", () => {
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p === "foo", 123));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex((p: number) => p === 3));
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(findIndex((p, index: string) => p === 3));
+  // $FlowExpectedError[incompatible-call]
+  const q = of("foo", "bar", "baz").pipe(findIndex((p, index, source: Observable<number>) => p === 3));
+});
+
+it("should enforce predicate return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(findIndex(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_first.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_first.js
new file mode 100644
index 0000000000..c181449cd6
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_first.js
@@ -0,0 +1,67 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { first } from "rxjs/operators";
+
+const isFooBar = (value: "foo" | "bar") => /^(foo|bar)$/.test(value);
+
+it("should support an undefined predicate with no default", () => {
+  const o = of("foo").pipe(first(undefined));
+});
+
+it("should support an undefined predicate with a T default", () => {
+  const o = of("foo").pipe(first(undefined, "bar"));
+});
+
+it("should support an undefined predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(undefined, false));
+});
+
+it("should default D to T with an undfined predicate", () => {
+  const o = of("foo").pipe(first<string>(undefined));
+});
+
+it("should support a null predicate with no default", () => {
+  const o = of("foo").pipe(first(null));
+});
+
+it("should support a null predicate with a T default", () => {
+  const o = of("foo").pipe(first(null, "bar"));
+});
+
+it("should support a null predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(null, false));
+});
+
+it("should default D to T with a null predicate", () => {
+  const o = of("foo").pipe(first<string>(null));
+});
+
+it("should support a user-defined type guard with no default", () => {
+  const o = of("foo").pipe(first(isFooBar));
+});
+
+it("should support a user-defined type guard with an S default", () => {
+  const o = of("foo").pipe(first(isFooBar, "bar"));
+});
+
+it("should widen a user-defined type guard with a non-S default", () => {
+  const o = of("foo").pipe(first(isFooBar, false));
+});
+
+it("should support a predicate with no default", () => {
+  const o = of("foo").pipe(first(x => !!x));
+});
+
+it("should support a predicate with a T default", () => {
+  const o = of("foo").pipe(first(x => !!x, "bar"));
+});
+
+it("should support a predicate with a non-T default", () => {
+  const o = of("foo").pipe(first(x => !!x, false));
+});
+
+it("should default D to T with a predicate", () => {
+  const o = of("foo").pipe(first<string>(x => !!x)); // $Observable<string>
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_last.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_last.js
new file mode 100644
index 0000000000..bbd02e1009
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_last.js
@@ -0,0 +1,67 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { last } from "rxjs/operators";
+
+const isFooBar = (value: "foo" | "bar") => /^(foo|bar)$/.test(value);
+
+it("should support an undefined predicate with no default", () => {
+  const o = of("foo").pipe(last(undefined));
+});
+
+it("should support an undefined predicate with a T default", () => {
+  const o = of("foo").pipe(last(undefined, "bar"));
+});
+
+it("should support an undefined predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(undefined, false));
+});
+
+it("should default D to T with an undfined predicate", () => {
+  const o = of("foo").pipe(last<string>(undefined));
+});
+
+it("should support a null predicate with no default", () => {
+  const o = of("foo").pipe(last(null));
+});
+
+it("should support a null predicate with a T default", () => {
+  const o = of("foo").pipe(last(null, "bar"));
+});
+
+it("should support a null predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(null, false));
+});
+
+it("should default D to T with a null predicate", () => {
+  const o = of("foo").pipe(last<string>(null));
+});
+
+it("should support a user-defined type guard with no default", () => {
+  const o = of("foo").pipe(last(isFooBar));
+});
+
+it("should support a user-defined type guard with an S default", () => {
+  const o = of("foo").pipe(last(isFooBar, "bar"));
+});
+
+it("should widen a user-defined type guard with a non-S default", () => {
+  const o = of("foo").pipe(last(isFooBar, false));
+});
+
+it("should support a predicate with no default", () => {
+  const o = of("foo").pipe(last(x => !!x));
+});
+
+it("should support a predicate with a T default", () => {
+  const o = of("foo").pipe(last(x => !!x, "bar"));
+});
+
+it("should support a predicate with a non-T default", () => {
+  const o = of("foo").pipe(last(x => !!x, false));
+});
+
+it("should default D to T with a predicate", () => {
+  const o = of("foo").pipe(last<string>(x => !!x)); // $Observable<string>
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeAll.js
new file mode 100644
index 0000000000..7cff7afeba
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeAll.js
@@ -0,0 +1,14 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(mergeAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMap.js
new file mode 100644
index 0000000000..1005071dce
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMap.js
@@ -0,0 +1,74 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(mergeMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined));
+});
+
+it("should support a concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), 4));
+});
+
+it("should support a resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), (a, b) => b, 4));
+});
+
+it("should support a undefined resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined, 4));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => p));
+});
+
+it("should enforce types of the concurrent parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), "4"));
+});
+
+it("should enforce types of the concurrent parameter with a resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), a => a, "4"));
+});
+
+it("should enforce types of the concurrent parameter with an undefined resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMap(p => of(Boolean(p)), undefined, "4"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMapTo.js
new file mode 100644
index 0000000000..117d72a6e9
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_mergeMapTo.js
@@ -0,0 +1,69 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { mergeMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo")));
+});
+
+it("should infer correctly multiple types", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(new Promise<string>(() => {})));
+});
+
+it("should support a concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), 4));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    mergeMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support a resultSelector and concurrent parameter", () => {
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), (a, b) => b, 4));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(mergeMapTo(4));
+});
+
+it("should enforce types of the concurrent parameter", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), "4"));
+});
+
+it("should enforce types of the concurrent parameter with a resultSelector", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(mergeMapTo(of("foo"), a => a, "4"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retry.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retry.js
new file mode 100644
index 0000000000..8b2c4c1607
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retry.js
@@ -0,0 +1,18 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { retry } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(retry());
+});
+
+it("should accept a count parameter", () => {
+  const o = of(1, 2, 3).pipe(retry(47));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retry("aa"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retryWhen.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retryWhen.js
new file mode 100644
index 0000000000..35aace146f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_retryWhen.js
@@ -0,0 +1,23 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { retryWhen } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(retryWhen(errors => errors));
+});
+
+it("should infer correctly when the error observable has a different type", () => {
+  const o = of(1, 2, 3).pipe(retryWhen(errors => of("a", "b", "c")));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retryWhen());
+});
+
+it("should enforce types of the notifier", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(retryWhen(() => 8));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skip.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skip.js
new file mode 100644
index 0000000000..9b557ac496
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skip.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skip } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skip(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skip());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skip("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipLast.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipLast.js
new file mode 100644
index 0000000000..b71a71afe8
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipLast.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipLast } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skipLast(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipLast());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skipLast("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipUntil.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipUntil.js
new file mode 100644
index 0000000000..33e6c47744
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipUntil.js
@@ -0,0 +1,16 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipUntil } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of("foo", "bar", "baz").pipe(skipUntil(of(4, "RxJS", 7)));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipUntil());
+  // $FlowExpectedError[incompatible-call]
+  const p = of("foo", "bar", "baz").pipe(skipUntil("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipWhile.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipWhile.js
new file mode 100644
index 0000000000..c298bde435
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_skipWhile.js
@@ -0,0 +1,32 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { skipWhile } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value === "bar"));
+});
+
+it("should support a predicate with an index", () => {
+  const o = of("foo", "bar", "baz").pipe(
+    skipWhile((value, index) => index < 3)
+  );
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile());
+});
+
+it("should enforce predicate types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value < 3));
+  // $FlowExpectedError[invalid-compare]
+  const p = of("foo", "bar", "baz").pipe(skipWhile((value, index) => index < "3"));
+});
+
+it("should enforce predicate return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of("foo", "bar", "baz").pipe(skipWhile(value => value));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_startWith.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_startWith.js
new file mode 100644
index 0000000000..a59cc8a706
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_startWith.js
@@ -0,0 +1,33 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of, asyncScheduler } from "rxjs";
+import { startWith } from "rxjs/operators";
+
+it("should infer correctly with one value", () => {
+  const o = of(1, 2, 3).pipe(startWith(4));
+});
+
+it("should infer correctly with multiple values", () => {
+  const o = of(1, 2, 3).pipe(startWith(4, 5, 6));
+});
+
+it("should infer correctly with no value", () => {
+  const o = of(1, 2, 3).pipe(startWith());
+});
+
+it("should infer correctly with a value and a scheduler", () => {
+  const o = of(1, 2, 3).pipe(startWith(5, asyncScheduler));
+});
+
+it("should infer correctly with a different type", () => {
+  const o = of(1, 2, 3).pipe(startWith("foo"));
+});
+
+it("should infer correctly with multiple different types", () => {
+  const o = of(1, 2, 3).pipe(startWith("foo", 4, true));
+});
+
+it("should infer correctly with only a scheduler", () => {
+  const o = of(1, 2, 3).pipe(startWith(asyncScheduler));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchAll.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchAll.js
new file mode 100644
index 0000000000..1236a076a1
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchAll.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchAll } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(of(1, 2, 3)).pipe(switchAll());
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchAll());
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMap.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMap.js
new file mode 100644
index 0000000000..8f65e2120a
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMap.js
@@ -0,0 +1,47 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchMap } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p))));
+});
+
+it("should support a projector that takes an index", () => {
+  const o = of(1, 2, 3).pipe(switchMap((p, index) => of(Boolean(p))));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMap(p => of(Boolean(p)), (a, b, innnerIndex) => a)
+  );
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMap(p => of(Boolean(p)), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(switchMap(p => of(Boolean(p)), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMap());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMap(p => p));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMapTo.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMapTo.js
new file mode 100644
index 0000000000..8c75e9219f
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_switchMapTo.js
@@ -0,0 +1,55 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { switchMapTo } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo")));
+});
+
+it("should infer correctly with multiple types", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo", 4)));
+});
+
+it("should infer correctly with an array", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo([4, 5, 6]));
+});
+
+it("should infer correctly with a Promise", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(new Promise<string>(() => {})));
+});
+
+it("should infer correctly by using the resultSelector first parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), a => a));
+});
+
+it("should infer correctly by using the resultSelector second parameter", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), (a, b) => b));
+});
+
+it("should support a resultSelector that takes an inner index", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), (a, b, innnerIndex) => a));
+});
+
+it("should support a resultSelector that takes an inner and outer index", () => {
+  const o = of(1, 2, 3).pipe(
+    switchMapTo(of("foo"), (a, b, innnerIndex, outerIndex) => a)
+  );
+});
+
+it("should support an undefined resultSelector", () => {
+  const o = of(1, 2, 3).pipe(switchMapTo(of("foo"), undefined));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMapTo());
+});
+
+it("should enforce the return type", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(switchMapTo(p => p));
+  // $FlowExpectedError[incompatible-call]
+  const p = of(1, 2, 3).pipe(switchMapTo(4));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_take.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_take.js
new file mode 100644
index 0000000000..6f3ac98fa1
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_take.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { take } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(take(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(take("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeLast.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeLast.js
new file mode 100644
index 0000000000..35500716e0
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeLast.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeLast } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(takeLast(7));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(takeLast("7"));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeUntil.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeUntil.js
new file mode 100644
index 0000000000..b6c93bf319
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeUntil.js
@@ -0,0 +1,14 @@
+//@flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+
+it("should infer correctly", () => {
+  const o = of(1, 2, 3).pipe(takeUntil(of(1, 2, 3)));
+});
+
+it("should enforce types", () => {
+  // $FlowExpectedError[incompatible-call]
+  const o = of(1, 2, 3).pipe(takeUntil(value => value < 3));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeWhile.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeWhile.js
new file mode 100644
index 0000000000..8908b4a662
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_operator_takeWhile.js
@@ -0,0 +1,9 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { of } from "rxjs";
+import { takeWhile } from "rxjs/operators";
+
+it("should support a predicate", () => {
+  const o = of("foo").pipe(takeWhile(s => true, false));
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_pipe.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_pipe.js
new file mode 100644
index 0000000000..477f120739
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_pipe.js
@@ -0,0 +1,163 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { pipe, of, Observable } from "rxjs";
+
+function a<I: string, O: string>(
+  input: I,
+  output: O
+): rxjs$UnaryFunction<I, O> {
+  return i => output;
+}
+
+it("should infer {} for no arguments", () => {
+  const o = pipe();
+});
+
+it("should infer for 1 argument", () => {
+  const o = pipe(a("0", "1"));
+});
+
+it("should infer for 2 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2")
+  );
+});
+
+it("should infer for 3 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3")
+  );
+});
+
+it("should infer for 4 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4")
+  );
+});
+
+it("should infer for 5 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5")
+  );
+});
+
+it("should infer for 6 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6")
+  );
+});
+
+it("should infer for 7 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7")
+  );
+});
+
+it("should infer for 8 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8")
+  );
+});
+
+it("should infer for 9 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9")
+  );
+});
+
+it("should infer {} for more than 9 arguments", () => {
+  const o = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9"),
+    a("9", "10")
+  );
+});
+
+it("should require a type assertion for more than 9 arguments", () => {
+  // $FlowExpectedError[incompatible-type-arg]
+  const o: rxjs$UnaryFunction<"0", "10"> = pipe(
+    a("0", "1"),
+    a("1", "2"),
+    a("2", "3"),
+    a("3", "4"),
+    a("4", "5"),
+    a("5", "6"),
+    a("6", "7"),
+    a("7", "8"),
+    a("8", "9"),
+    a("9", "10")
+  );
+});
+
+it("should return generic OperatorFunction 1", () => {
+  const customOperator = p => (a: Observable<any>) => a;
+
+  const staticPipe = pipe(customOperator("infer"));
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic OperatorFunction 2", () => {
+  const customOperator = () => (a: Observable<string>) => a;
+
+  const staticPipe = pipe(customOperator());
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic OperatorFunction 3", () => {
+  const customOperator = () => (a: Observable<any>) => a;
+
+  const staticPipe = pipe(customOperator());
+  const o = of("foo").pipe(staticPipe);
+});
+
+it("should return generic function", () => {
+  const func = pipe(
+    (value: string) => value,
+    (value: string) => value + value
+  );
+  const value = func("foo");
+});
diff --git a/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_zip.js b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_zip.js
new file mode 100644
index 0000000000..b9ab0763c3
--- /dev/null
+++ b/definitions/npm/rxjs_v7.x.x/flow_v0.201.x-/test_zip.js
@@ -0,0 +1,29 @@
+// @flow
+
+import { it } from "flow-typed-test";
+import { Observable, of, zip } from "rxjs";
+
+it("should support observables", () => {
+  const a = of(1);
+  const b = of("foo");
+  const c = of(true);
+  const o1 = zip(a, b, c);
+});
+
+it("should support mixed observables and promises", () => {
+  const a = Promise.resolve(1);
+  const b = of("foo");
+  const c = of(true);
+  const d = of(["bar"]);
+  const o1 = zip(a, b, c, d);
+});
+
+it("should return Array<T> when given a single promise", () => {
+  const a = Promise.resolve(1);
+  const o1 = zip(a);
+});
+
+it("should return Array<T> when given a single observable", () => {
+  const a = of(1);
+  const o1 = zip(a);
+});
diff --git a/definitions/npm/storeon_v0.x.x/flow_v0.104.x-/storeon_v0.x.x.js b/definitions/npm/storeon_v0.x.x/flow_v0.104.x-v.200.x/storeon_v0.x.x.js
similarity index 100%
rename from definitions/npm/storeon_v0.x.x/flow_v0.104.x-/storeon_v0.x.x.js
rename to definitions/npm/storeon_v0.x.x/flow_v0.104.x-v.200.x/storeon_v0.x.x.js
diff --git a/definitions/npm/storeon_v0.x.x/flow_v0.104.x-/test_storeon.js b/definitions/npm/storeon_v0.x.x/flow_v0.104.x-v.200.x/test_storeon.js
similarity index 100%
rename from definitions/npm/storeon_v0.x.x/flow_v0.104.x-/test_storeon.js
rename to definitions/npm/storeon_v0.x.x/flow_v0.104.x-v.200.x/test_storeon.js
diff --git a/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/storeon_v0.x.x.js b/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/storeon_v0.x.x.js
new file mode 100644
index 0000000000..e7e9dea150
--- /dev/null
+++ b/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/storeon_v0.x.x.js
@@ -0,0 +1,112 @@
+
+type $npm$storeon$PropertyKey = string | number | Symbol;
+
+type $npm$storeon$Dispatch = (event: $npm$storeon$PropertyKey, data?: any) => void;
+
+type $npm$storeon$Store<State> = {
+    on: (
+        event: $npm$storeon$PropertyKey,
+        handler: (state: State, data: any) => $Shape<State> | Promise<void> | null
+    ) => () => void,
+    dispatch: $npm$storeon$Dispatch,
+    get: () => State,
+    ...
+}
+
+type $npm$storeon$Module<State> = (store: $npm$storeon$Store<State>) => void;
+
+declare function $npm$storeon$createStore<State>(
+    modules: Array<$npm$storeon$Module<State> | false>
+): $npm$storeon$Store<State>;
+
+type $npm$storeon$StoreData<State: {...}> = { dispatch: $npm$storeon$Dispatch, ... } & State;
+
+declare function $npm$storeon$useStoreon<State: {...}>(
+    ...keys: Array<$Keys<State>>
+): $npm$storeon$StoreData<State>;
+
+declare var $npm$storeon$StoreContext: React$Context<$npm$storeon$Store<any>>;
+
+declare function $npm$storeon$omit<
+    O, P, A, B, C, D, E
+    >(O, P): $Exact<$Call<
+    & (([A]) => { ...$Exact<$ObjMapi<O,
+    & (<K: A, V>(K, V) => void)
+    & (<K, V>(K, V) => V)
+    >>, ... })
+    & (([A, B]) => { ...$Exact<$ObjMapi<O,
+    & (<K: A | B, V>(K, V) => void)
+    & (<K, V>(K, V) => V)
+    >>, ... })
+    & (([A, B, C]) => { ...$Exact<$ObjMapi<O,
+    & (<K: A | B | C, V>(K, V) => void)
+    & (<K, V>(K, V) => V)
+    >>, ... })
+    & (([A, B, C, D]) => { ...$Exact<$ObjMapi<O,
+    & (<K: A | B | C | D, V>(K, V) => void)
+    & (<K, V>(K, V) => V)
+    >>, ... })
+    & (([A, B, C, D, E]) => { ...$Exact<$ObjMapi<O,
+    & (<K: A | B | C | D | E, V>(K, V) => void)
+    & (<K, V>(K, V) => V)
+    >>, ... })
+    , P>>
+
+declare type $npm$storeon$_Omit = typeof $npm$storeon$omit;
+
+declare type $npm$storeon$Omit<O, P> = $Call<$npm$storeon$_Omit, O, P>
+
+declare function $npm$storeon$connect<C>(
+    ...keysOrComponent: Array<$Keys<C> | React$ComponentType<C>>
+): React$ComponentType<$Shape<$npm$storeon$Omit<C, ["dispatch"]>>>;
+
+declare module "storeon" {
+    declare type Module<T> = $npm$storeon$Module<T>;
+    declare type Store<T> = $npm$storeon$Store<T>;
+    declare type Dispatch = $npm$storeon$Dispatch;
+
+    declare module.exports: typeof $npm$storeon$createStore;
+}
+
+declare module "storeon/react" {
+    declare module.exports: typeof $npm$storeon$useStoreon;
+}
+
+declare module "storeon/react/context" {
+
+    declare module.exports: typeof $npm$storeon$StoreContext;
+}
+
+declare module "storeon/react/connect" {
+    declare module.exports: typeof $npm$storeon$connect;
+}
+
+declare module "storeon/preact" {
+    declare module.exports: typeof $npm$storeon$useStoreon;
+}
+
+declare module "storeon/preact/context" {
+
+    declare module.exports: typeof $npm$storeon$StoreContext;
+}
+
+declare module "storeon/preact/connect" {
+    declare module.exports: typeof $npm$storeon$connect;
+}
+
+declare module "storeon/devtools" {
+    declare module.exports: {
+        <State>(store: $npm$storeon$Store<State>): void,
+        (): <State>(store: $npm$storeon$Store<State>) => void,
+        ...
+    };
+}
+
+declare module "storeon/devtools/logger.browser" {
+    declare module.exports: $npm$storeon$Module<any>;
+}
+
+declare module "storeon/devtools/logger" {
+    declare module.exports: $npm$storeon$Module<any>;
+}
+
diff --git a/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/test_storeon.js b/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/test_storeon.js
new file mode 100644
index 0000000000..e71fbfa7b7
--- /dev/null
+++ b/definitions/npm/storeon_v0.x.x/flow_v0.201.x-/test_storeon.js
@@ -0,0 +1,112 @@
+// @flow
+import React from "react";
+import createStore, { type Module, type Store} from "storeon";
+import devtools from "storeon/devtools";
+import logger from "storeon/devtools/logger";
+import loggerBrowser from "storeon/devtools/logger.browser";
+import useStoreon from "storeon/react";
+import StoreContext from "storeon/react/context";
+import connect from "storeon/react/connect";
+import { it, describe } from "flow-typed-test";
+import * as ReactDOM from "react-dom";
+
+describe("storeon", () => {
+  it('storeon', () => {
+      type State = {
+          a: number,
+          b: string,
+          ...
+      }
+
+      // Reducer typed as a Module
+      const init: Module<State> = (store) => {
+          store.on('@init', () => {
+              return { a: 0, b: '' }
+          })
+      }
+
+      // Duck-typed reducer
+      function setUp(store: Store<State>): void {
+          store.on('inc', (state) => ({ a: state.a + 1 }))
+      }
+
+      // Store
+      const store = createStore<State>([
+          init,
+          setUp,
+          logger,
+          loggerBrowser,
+          devtools,
+          devtools(),
+      ])
+
+      // String event dispatch
+      store.dispatch('inc')
+
+      // Symbolic event
+      const sym = Symbol('sym')
+      store.on(sym, (state, data: number) => ({ a: state.a + data }))
+      store.dispatch(sym, 2)
+
+      // Async reducer
+      store.on('comment:post', async (_, data: string) => {
+          store.dispatch('comment:posting')
+
+          try {
+              const response = await fetch('https://github.com', {
+                  body: data
+              })
+
+              const result = await response.json()
+              store.dispatch('comment:posted', result)
+          } catch (e) {
+              store.dispatch('comment:error', e)
+          }
+      })
+
+      const state = store.get()
+      state.a
+  });
+
+  it("storeon/react", () => {
+      type State = { a: number, ... }
+
+      function init(store: Store<State>) {
+          store.on('@init', () => ({ a: 0 }))
+          store.on('inc', (state, data: number) => ({a: state.a + data}))
+      }
+
+      const store = createStore([init])
+
+      function Button() {
+          const {dispatch, a} = useStoreon<State>('a')
+
+          const onClick = React.useCallback(() => dispatch('inc'), [])
+
+          return (
+              <button onClick={onClick}>Count: {a}</button>
+          )
+      }
+
+      const App = connect<State>('a', ({a}) => {
+          return (
+              <>
+                  <div>Count: {a}</div>
+                  <Button/>
+              </>
+          )
+      });
+
+      const el = document.getElementById("root");
+
+      if (el) {
+          ReactDOM.render(
+              <StoreContext.Provider value={store}>
+                  <App/>
+              </StoreContext.Provider>,
+              el
+          )
+      }
+
+  })
+});
diff --git a/definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-/storybook-host_v4.x.x.js b/definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-v.200.x/storybook-host_v4.x.x.js
similarity index 100%
rename from definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-/storybook-host_v4.x.x.js
rename to definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-v.200.x/storybook-host_v4.x.x.js
diff --git a/definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-/test_storybook-host_v4.x.x.js b/definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-v.200.x/test_storybook-host_v4.x.x.js
similarity index 100%
rename from definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-/test_storybook-host_v4.x.x.js
rename to definitions/npm/storybook-host_v4.x.x/flow_v0.104.x-v.200.x/test_storybook-host_v4.x.x.js
diff --git a/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/storybook-host_v4.x.x.js b/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/storybook-host_v4.x.x.js
new file mode 100644
index 0000000000..81077dfa34
--- /dev/null
+++ b/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/storybook-host_v4.x.x.js
@@ -0,0 +1,58 @@
+declare module "storybook-host" {
+  declare type Context = {
+    kind: string,
+    story: string,
+    ...
+  };
+  declare type Renderable = React$Element<any>;
+  declare type RenderFunction = () => Renderable | Array<Renderable>;
+
+  declare type StoryDecorator = (
+    story: RenderFunction,
+    context: Context
+  ) => Renderable | null;
+
+  declare type AlignEdge =
+    | "left"
+    | "center"
+    | "right"
+    | "top"
+    | "middle"
+    | "bottom"
+    | "left top"
+    | "left middle"
+    | "left bottom"
+    | "center top"
+    | "center middle"
+    | "center bottom"
+    | "right top"
+    | "right middle"
+    | "right bottom"
+    | "top left"
+    | "middle left"
+    | "bottom left"
+    | "top center"
+    | "middle center"
+    | "bottom center"
+    | "top right"
+    | "middle right"
+    | "bottom right";
+
+  declare type Props = {|
+    mobXDevTools?: boolean,
+    title?: string,
+    hr?: boolean,
+    align?: AlignEdge,
+    height?: number | string,
+    width?: number | string,
+    background?: boolean | number | string,
+    backdrop?: boolean | number | string,
+    cropMarks?: boolean,
+    border?: boolean | number | string,
+    padding?: number | string,
+    styles?: any,
+    flex?: boolean
+  |};
+
+  declare export function host(props: Props): StoryDecorator;
+}
diff --git a/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/test_storybook-host_v4.x.x.js b/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/test_storybook-host_v4.x.x.js
new file mode 100644
index 0000000000..cb2413c04a
--- /dev/null
+++ b/definitions/npm/storybook-host_v4.x.x/flow_v0.201.x-/test_storybook-host_v4.x.x.js
@@ -0,0 +1,46 @@
+// @flow
+
+import { describe, it } from "flow-typed-test";
+import React from "react";
+
+// $FlowExpectedError
+import { storiesOf } from "@storybook/react";
+import { host } from "storybook-host";
+
+describe("The `host` decorator", () => {
+  it("should validate on default usage", () => {
+    storiesOf("button", module)
+      .addDecorator(host({}))
+      .add("", () => <div />);
+  });
+
+  it("should accept valid options", () => {
+    host({
+      mobXDevTools: true,
+      title: "",
+      hr: true,
+      align: "left",
+      height: "",
+      width: "",
+      background: true,
+      backdrop: true,
+      cropMarks: true,
+      border: true,
+      padding: 123
+    });
+  });
+
+  it("should error on invalid options", () => {
+    // $FlowExpectedError
+    host({
+      title: 123
+    });
+  });
+
+  it("should error on unknown options", () => {
+    // $FlowExpectedError
+    host({
+      foobar: ""
+    });
+  });
+});
diff --git a/definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-/storybook-router_v0.x.x.js b/definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-v.200.x/storybook-router_v0.x.x.js
similarity index 100%
rename from definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-/storybook-router_v0.x.x.js
rename to definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-v.200.x/storybook-router_v0.x.x.js
diff --git a/definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-/test_storybook-router_v0.x.x.js b/definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-v.200.x/test_storybook-router_v0.x.x.js
similarity index 100%
rename from definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-/test_storybook-router_v0.x.x.js
rename to definitions/npm/storybook-router_v0.x.x/flow_v0.104.x-v.200.x/test_storybook-router_v0.x.x.js
diff --git a/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/storybook-router_v0.x.x.js b/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/storybook-router_v0.x.x.js
new file mode 100644
index 0000000000..dc1dab7806
--- /dev/null
+++ b/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/storybook-router_v0.x.x.js
@@ -0,0 +1,42 @@
+type LocationShape = {
+  pathname?: string,
+  search?: string,
+  hash?: string,
+  state?: any,
+  ...
+};
+
+type GetUserConfirmation = (
+  message: string,
+  callback: (confirmed: boolean) => void
+) => void;
+
+declare module "storybook-router" {
+  declare type Context = {
+    kind: string,
+    story: string,
+    ...
+  };
+  declare type Renderable = React$Element<any>;
+  declare type RenderFunction = () => Renderable | Array<Renderable>;
+
+  declare type StoryDecorator = (
+    story: RenderFunction,
+    context: Context
+  ) => Renderable | null;
+
+  declare type Links = { [key: string]: (kind: string, story: string) => Function, ... };
+
+  declare type RouterProps = {
+    initialEntry?: Array<string>,
+    autoRoute?: boolean,
+    initialEntries?: Array<LocationShape | string>,
+    initialIndex?: number,
+    getUserConfirmation?: GetUserConfirmation,
+    keyLength?: number,
+    children?: React$Element<any>,
+    ...
+  };
+
+  declare module.exports: { (links?: Links, routerProps?: RouterProps): StoryDecorator, ... };
+}
diff --git a/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/test_storybook-router_v0.x.x.js b/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/test_storybook-router_v0.x.x.js
new file mode 100644
index 0000000000..c0999d5ad5
--- /dev/null
+++ b/definitions/npm/storybook-router_v0.x.x/flow_v0.201.x-/test_storybook-router_v0.x.x.js
@@ -0,0 +1,77 @@
+// @flow
+
+import { describe, it } from "flow-typed-test";
+import React from "react";
+
+// $FlowExpectedError
+import { storiesOf } from "@storybook/react";
+import StoryRouter from "storybook-router";
+
+function linkTo(kind, story) {
+  return (...args) => {};
+}
+
+describe("The `StoryRouter` decorator", () => {
+  it("should validate on default usage", () => {
+    storiesOf("", module)
+      .addDecorator(StoryRouter())
+      .add("", () => <div />);
+  });
+
+  it("should accept valid options", () => {
+    StoryRouter({}, { autoRoute: false });
+
+    StoryRouter(
+      { "/about": linkTo },
+      { initialEntry: ["/"], autoRoute: false }
+    );
+
+    StoryRouter({
+      "/about": linkTo
+    });
+
+    StoryRouter({ "/": linkTo }, { initialEntry: ["/about"] });
+
+    StoryRouter(
+      {},
+      { getUserConfirmation: (message, cb) => cb(window.confirm(message)) }
+    );
+
+    StoryRouter(
+      {},
+      {
+        initialEntries: [
+          {
+            pathname: "string",
+            search: "string"
+          }
+        ]
+      }
+    );
+
+    StoryRouter({}, { getUserConfirmation: ("string", confirmed => {}) });
+  });
+
+  it("should error on invalid options", () => {
+    // $FlowExpectedError
+    StoryRouter(false);
+
+    // $FlowExpectedError
+    StoryRouter("string");
+
+    // $FlowExpectedError
+    StoryRouter({}, false);
+
+    // $FlowExpectedError
+    StoryRouter({}, { autoRoute: "string" });
+
+    // $FlowExpectedError
+    StoryRouter({}, { initialEntry: "string" });
+
+    // $FlowExpectedError
+    StoryRouter({}, { initialEntries: "string" });
+
+    // $FlowExpectedError
+    StoryRouter({}, { keyLength: "string" });
+  });
+});
diff --git a/definitions/npm/stringify-object_v3.x.x/flow_v0.104.x-/stringify-object_v3.x.x.js b/definitions/npm/stringify-object_v3.x.x/flow_v0.104.x-v.200.x/stringify-object_v3.x.x.js
similarity index 100%
rename from definitions/npm/stringify-object_v3.x.x/flow_v0.104.x-/stringify-object_v3.x.x.js
rename to definitions/npm/stringify-object_v3.x.x/flow_v0.104.x-v.200.x/stringify-object_v3.x.x.js
diff --git a/definitions/npm/stringify-object_v3.x.x/flow_v0.201.x-/stringify-object_v3.x.x.js b/definitions/npm/stringify-object_v3.x.x/flow_v0.201.x-/stringify-object_v3.x.x.js
new file mode 100644
index 0000000000..4da4db04db
--- /dev/null
+++ b/definitions/npm/stringify-object_v3.x.x/flow_v0.201.x-/stringify-object_v3.x.x.js
@@ -0,0 +1,19 @@
+declare module 'stringify-object' {
+  // Matches the `prop` parameter `mixed` type.
+  // Prevent errors when using computed properties.
+  declare type AnyObject = { [key: mixed]: mixed, ... };
+
+  declare type Options = {|
+    indent?: string,
+    singleQuotes?: boolean,
+    filter?: (obj: AnyObject, prop: mixed) => boolean,
+    transform?: (obj: AnyObject, prop: mixed, originalResult: string) => string,
+    inlineCharacterLimit?: number,
+  |};
+
+  declare module.exports: (
+    input: AnyObject | Array<any>,
+    options?: Options,
+    pad?: string
+  ) => string;
+}
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_fixture.js b/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_fixture.js
similarity index 100%
rename from definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_fixture.js
rename to definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_fixture.js
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_request_hooks.js b/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_request_hooks.js
similarity index 100%
rename from definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_request_hooks.js
rename to definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_request_hooks.js
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_testcontroller.js b/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_testcontroller.js
similarity index 100%
rename from definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/test_testcafe_v0.x.x_testcontroller.js
rename to definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/test_testcafe_v0.x.x_testcontroller.js
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/testcafe_v0.x.x.js b/definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/testcafe_v0.x.x.js
similarity index 100%
rename from definitions/npm/testcafe_v0.x.x/flow_v0.104.x-/testcafe_v0.x.x.js
rename to definitions/npm/testcafe_v0.x.x/flow_v0.104.x-v.200.x/testcafe_v0.x.x.js
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_fixture.js b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_fixture.js
new file mode 100644
index 0000000000..702266ec09
--- /dev/null
+++ b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_fixture.js
@@ -0,0 +1,61 @@
+fixture `123`
+fixture('123')
+// $FlowExpectedError
+fixture(123)
+
+fixture `123`.page `123`
+fixture `123`.page('123')
+// $FlowExpectedError
+fixture `123`.page(123)
+
+fixture
+    .skip
+    .only
+    ('Fixture1')
+    .page('http://example.com')
+    .httpAuth({
+        username: 'user',
+        password: 'pass',
+        domain: 'domain',
+        workstation: 'workstation'
+    })
+    .meta('fixture', 'fixture')
+    .meta({ foo: 'bar' })
+    .before(async() => {
+    })
+    .after(async() => {
+    })
+    .beforeEach(async t => {
+        t.ctx['1'] = 2;
+        t.ctx['someKey'] = [];
+        t.fixtureCtx['yo'] = 'hey';
+    })
+    .afterEach(async t => {
+        await t.click('#smth');
+    });
+
+test
+    .before(async t => {
+        await t.click('#smth');
+    })
+    .after(async t => {
+        await t.click('#smth');
+    })
+    ('Test1', async t => {
+        t.ctx['1'] = 2;
+        t.ctx['someKey'] = [];
+        t.fixtureCtx['yo'] = 'hey';
+
+        await t.click('#smth');
+    })
+    .skip
+    .only
+    .meta('test', 'test')
+    .meta({ foo: 'bar' })
+    .page('http://example.com')
+    .httpAuth({
+        username: 'user',
+        password: 'pass',
+        domain: 'domain',
+        workstation: 'workstation'
+    });
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_request_hooks.js b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_request_hooks.js
new file mode 100644
index 0000000000..47db5750a2
--- /dev/null
+++ b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_request_hooks.js
@@ -0,0 +1,40 @@
+import {RequestLogger, RequestMock, RequestHook} from 'testcafe';
+
+class CustomRequestHook extends RequestHook {
+    constructor() {
+        super();
+    }
+
+    onRequest(event) {
+
+    }
+
+    onResponse(event) {
+
+    }
+}
+
+const customHook = new CustomRequestHook();
+const logger     = RequestLogger('example.com', {logRequestBody: true});
+
+const mock = RequestMock()
+    .onRequestTo(/example.com/)
+    .respond()
+    .onRequestTo({url: 'https://example.com'})
+    .respond(null, 204)
+    .onRequestTo('https://example.com')
+    .respond(null, 200, {'x-frame-options': 'deny'});
+
+fixture `Request Hooks`
+    .requestHooks(mock, logger, customHook);
+
+test
+    .requestHooks(logger)
+    ('Request hook', async t => {
+        await t
+            .addRequestHooks(mock)
+            .removeRequestHooks(mock)
+            .expect(logger.contains(t => t.request.statusCode === 200)).ok()
+            .expect(logger.count(t => t.request.statusCode === 200)).eql(1)
+            .expect(logger.requests[0].request.body === 'test').ok();
+    });
\ No newline at end of file
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_testcontroller.js b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_testcontroller.js
new file mode 100644
index 0000000000..e7ce3df7d3
--- /dev/null
+++ b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/test_testcafe_v0.x.x_testcontroller.js
@@ -0,0 +1,760 @@
+import { Selector, ClientFunction } from 'testcafe';
+
+fixture(`TestController`)
+    .page(`http://localhost:3000/fixtures/api/es-next/assertions/pages/index.html`);
+
+test('.eql() assertion', async t => {
+    await t
+        .setPageLoadTimeout(30000)
+        .expect({a: 2}).eql({a: 2})
+        .expect('hey').eql('yo', 'testMessage');
+});
+
+test('.notEql() assertion', async t => {
+    await t
+        .expect({b: 3}).notEql({a: 2})
+        .expect(2).notEql(2);
+});
+
+test('.ok() assertion', async t => {
+    await t
+        .expect({}).ok()
+        .expect(false).ok();
+});
+
+test('.notOk() assertion', async t => {
+    await t
+        .expect(false).notOk()
+        .expect(1).notOk();
+});
+
+test('.contains() assertion', async t => {
+    await t
+        .expect('heyyo').contains('hey')
+        .expect([1, 2, 3]).contains(4);
+});
+
+test('.notContains() assertion', async t => {
+    await t
+        .expect([1, 2, 3]).notContains(4)
+        .expect('answer42').notContains('42');
+});
+
+test('.typeOf() assertion', async t => {
+    await t
+        .expect(void 0).typeOf('undefined')
+        .expect('hey').typeOf('string')
+        .expect(42).typeOf('function');
+});
+
+test('.notTypeOf() assertion', async t => {
+    await t
+        .expect(void 0).notTypeOf('string')
+        .expect('hey').notTypeOf('number')
+        .expect(42).notTypeOf('number');
+});
+
+test('.gt() assertion', async t => {
+    await t
+        .expect(42).gt(32)
+        .expect(42).gt(42);
+});
+
+test('.gte() assertion', async t => {
+    await t
+        .expect(42).gte(32)
+        .expect(42).gte(42)
+        .expect(42).gte(53);
+});
+
+test('.lt() assertion', async t => {
+    await t
+        .expect(32).lt(42)
+        .expect(42).lt(42);
+});
+
+test('.lte() assertion', async t => {
+    await t
+        .expect(32).lte(42)
+        .expect(42).lte(42)
+        .expect(42).lte(12);
+});
+
+test('.within() assertion', async t => {
+    await t
+        .expect(2.3).within(2, 3)
+        .expect(4.5).within(4.6, 7);
+});
+
+test('.notWithin() assertion', async t => {
+    await t
+        .expect(4.5).notWithin(4.6, 7)
+        .expect(2.3).notWithin(2, 3);
+});
+
+test('Selector result assertion', async t => {
+    const el = Selector('#el1');
+
+    await t
+        .click('#makeFloat')
+        .expect(el.getStyleProperty('float')).eql('left')
+        .click('#setClass')
+        .expect(el.hasClass('hey')).ok()
+        .click('#setAttr')
+        .expect(el.getAttribute('checked')).ok()
+        .click('#setTextContent')
+        .expect(el.textContent).eql('42');
+});
+
+test('Selector result assertion timeout', async t => {
+    const el = Selector('#el1');
+
+    await t
+        .click('#makeFloat')
+        .expect(el.getStyleProperty('float')).eql('left');
+});
+
+test('Missing await', async t => {
+    t.expect(42).eql(43);
+});
+
+
+test('"timeout" option', async t => {
+    const el = Selector('#el1');
+
+    await t
+        .click('#makeFloat')
+        .expect(el.getStyleProperty('float')).eql('left', {timeout: 500})
+        .click('#setClass')
+        .expect(el.hasClass('hey')).ok('message', {timeout: 500});
+});
+
+test('.match() assertion', async t => {
+    await t
+        .expect('42 hey').match(/\d+ hey/)
+        .expect('yo').match(/[x,z]o/);
+});
+
+test('.notMatch() assertion', async t => {
+    await t
+        .expect('yo').notMatch(/[x,z]o/)
+        .expect('42 hey').notMatch(/\d+ hey/);
+});
+
+test('ClientFunction result assertion', async t => {
+    const getSomeVar = ClientFunction(() => window.location);
+
+    await t.expect(getSomeVar()).eql(2);
+});
+
+
+test('Incorrect action option', async t => {
+    await t.click('#btn', {offsetX: -3.5});
+});
+
+test('Click button', async t => {
+    await t.click('#btn');
+});
+
+test('Click without offset options', async t=> {
+    await t.click('#div');
+});
+
+test('Error in selector', async t => {
+    await t.click(() => {
+        throw new Error('yo');
+    });
+});
+
+
+test('Double click on a button', async t => {
+    await t.doubleClick('#button');
+});
+
+test('Drag to offset', async t => {
+    await t.drag('#draggable-div-1', 10, 20, {
+        'offsetX': 10,
+        'offsetY': 10
+    });
+});
+
+test('Drag to offset with incorrect dragOffsetX', async t => {
+    await t.drag('#draggable-div-1', NaN, 20);
+});
+
+test('Drag to offset with incorrect dragOffsetY', async t => {
+    await t.drag('#draggable-div-1', 10, 3.14);
+});
+
+test('Drag to element', async t => {
+    await t.dragToElement('#draggable-div-2', '#destination-div', {
+        'offsetX': 10,
+        'offsetY': 10
+    });
+});
+
+test('Drag to element with incorrect selector', async t => {
+    // $FlowExpectedError
+    await t.dragToElement(void 0, '#destination-div');
+});
+
+test('Drag to element with incorrect destinationSelector', async t => {
+    // $FlowExpectedError
+    await t.dragToElement('#draggable-div-2', null);
+});
+
+test('Destination element selector returns text node', async t => {
+    const getDocument = Selector(() => document);
+
+    await t.dragToElement('#draggable-div-2', getDocument);
+});
+
+test('Get UA', async t => {
+    throw await t.eval(() => navigator.userAgent);
+});
+
+const getById = ClientFunction(id => document.getElementById(id));
+
+
+test('Eval with dependencies', async t => {
+    const answer = await t.eval(() => getById('answer'), {dependencies: {getById}});
+
+    await t.expect(answer).eql('42');
+});
+
+
+test('Error during execution', async t => {
+    await t.eval(() => {
+        throw new Error('Hi there!');
+    });
+});
+
+test('Hover over containers', async t => {
+    await t.hover('#container1');
+    await t.hover('#container2');
+});
+
+
+const getBtnClickCount = ClientFunction(() => window);
+const getIframeBtnClickCount = ClientFunction(() => window);
+const getNestedIframeBtnClickCount = ClientFunction(() => window);
+
+test('Click on an element in an iframe and return to the main window', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    const btnClickCount = await getBtnClickCount();
+    const iframeBtnClickCount = await getIframeBtnClickCount();
+
+    await t
+        .expect(btnClickCount).eql(1)
+        .expect(iframeBtnClickCount).eql(1);
+});
+
+test('Click on element in a nested iframe', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .switchToIframe('#iframe')
+        .click('#btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    var btnClickCount = await getBtnClickCount();
+    const nestedIframeBtnClickCount = await getNestedIframeBtnClickCount();
+
+    await t
+        .expect(btnClickCount).eql(1)
+        .expect(nestedIframeBtnClickCount).eql(1);
+
+    await t
+        .switchToIframe('#iframe')
+        .click('#btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    btnClickCount = await getBtnClickCount();
+    const iframeBtnClickCount = await getIframeBtnClickCount();
+
+    await t
+        .expect(btnClickCount).eql(2)
+        .expect(iframeBtnClickCount).eql(1);
+});
+
+test('Switch to a non-existent iframe', async t => {
+    await t.switchToIframe('#non-existent');
+});
+
+test('Click in a slowly loading iframe', async t => {
+    await t
+        .switchToIframe('#slowly-loading-iframe')
+        .click('#btn');
+
+    const iframeBtnClickCount = await ClientFunction(() => window.top)();
+
+    await t.expect(iframeBtnClickCount).eql(1);
+});
+
+test('Try to switch to an incorrect element', async t => {
+    await t.switchToIframe('body');
+});
+
+test('Remove an iframe during execution', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#remove-from-parent-btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    const btnClickCount = await getBtnClickCount();
+
+    await t.expect(btnClickCount).eql(1);
+});
+
+test('Click in a removed iframe', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#remove-from-parent-btn')
+        .click('#btn');
+});
+
+test('Click in an iframe with redirect', async t => {
+    const getSecondPageBtnClickCount = ClientFunction(() => window);
+    const getNestedSecondPageBtnClickCount = ClientFunction(() => window);
+
+    await t
+        .switchToIframe('#iframe')
+        .switchToIframe('#iframe')
+        .click('#link')
+        .click('#nested-second-page-btn');
+
+    const nestedSecondPageBtnClickCount = await getNestedSecondPageBtnClickCount();
+
+    await t
+        .switchToMainWindow()
+        .switchToIframe('#iframe')
+        .click('#link')
+        .click('#second-page-btn');
+
+    const secondPageBtnClickCount = await getSecondPageBtnClickCount();
+
+    await t
+        .expect(nestedSecondPageBtnClickCount).eql(1)
+        .expect(secondPageBtnClickCount).eql(1);
+});
+
+test('Reload the main page from an iframe', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#reload-top-page-btn')
+        .click('#btn')
+        .switchToMainWindow();
+
+    const iframeBtnClickCount = await getIframeBtnClickCount();
+
+    await t.expect(iframeBtnClickCount).eql(1);
+});
+
+test('Remove the parent iframe from the nested one', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .switchToIframe('#iframe')
+        .click('#remove-parent-iframe-btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    const btnClickCount = await getBtnClickCount();
+
+    await t.expect(btnClickCount).eql(1);
+});
+
+test('Click in an iframe without src', async t => {
+    const getIframeWithoutSrcBtnClickCount = ClientFunction(() => window.top);
+
+    await t
+        .click('#fill-iframe-without-src')
+        .switchToIframe('#iframe-without-src')
+        .click('#btn')
+        .switchToMainWindow()
+        .click('#btn');
+
+    const btnClickCount = await getBtnClickCount();
+    const iframeWithoutSrcBtnClickCount = await getIframeWithoutSrcBtnClickCount();
+
+    await t
+        .expect(btnClickCount).eql(1)
+        .expect(iframeWithoutSrcBtnClickCount).eql(1);
+});
+
+test('Click in a cross-domain iframe with redirect', async t => {
+    const getSecondPageBtnClickCount = ClientFunction(() => window);
+
+    await t
+        .switchToIframe('#cross-domain-iframe')
+        .click('#link')
+        .click('#second-page-btn');
+
+    const secondPageBtnClickCount = await getSecondPageBtnClickCount();
+
+    await t
+        .switchToMainWindow()
+        .click('#btn');
+
+    const btnClickCount = await getBtnClickCount();
+
+    await t
+        .expect(btnClickCount).eql(1)
+        .expect(secondPageBtnClickCount).eql(1);
+});
+
+test("Click in a iframe that's loading too slowly", async t => {
+    await t
+        .switchToIframe('#too-slowly-loading-iframe')
+        .click('#btn');
+
+    const iframeBtnClickCount = await ClientFunction(() => window.top)();
+
+    await t.expect(iframeBtnClickCount).eql(1);
+});
+
+test('Click in an invisible iframe', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#hide-iframe-btn')
+        .click('#btn');
+});
+
+test('Click in an iframe that is not loaded', async t => {
+    await t
+        .switchToIframe('#iframe')
+        .click('#too-long-loading-page-link')
+        .wait(3000)
+        .click('#second-page-btn');
+});
+
+test('Maximize window', async t => {
+    await t.maximizeWindow();
+});
+
+
+const getResult = ClientFunction(() => {
+  var element = document.getElementById('result');
+
+  return element ? element.textContent : '';
+});
+
+const pageUrl = 'http://localhost:3000/fixtures/api/es-next/native-dialogs-handling/pages/index.html';
+const promptPageUrl = 'http://localhost:3000/fixtures/api/es-next/native-dialogs-handling/pages/prompt.html';
+
+
+test('Without handler', async t => {
+    var info = await t
+        .getNativeDialogHistory();
+
+    await t.expect(info.length).eql(0)
+        .click('#buttonConfirm');
+});
+
+test('Expected confirm after an action', async t => {
+    await t
+        .setNativeDialogHandler((type, text) => {
+            if (type === 'confirm' && text === 'Confirm?')
+                return true;
+
+            return null;
+        })
+        .click('#buttonConfirm')
+        .expect(await getResult()).eql('true');
+});
+
+test('Expected confirm after an action (with dependencies)', async t => {
+    var dialogHandler = ClientFunction((type, text) => {
+        if (type === 'confirm' && text === 'Confirm?')
+            return true;
+
+        return null;
+    });
+
+    await t
+        .setNativeDialogHandler((type, text) => dialogHandler(type, text), {dependencies: { 'dialogHandler': dialogHandler }})
+        .click('#buttonConfirm')
+        .expect(await getResult()).eql('true');
+});
+
+test('Expected confirm after an action (client function)', async t => {
+    var dialogHandler = ClientFunction((type, text) => {
+        if (type === 'confirm' && text === 'Confirm?')
+            return true;
+
+        return null;
+    });
+
+    await t
+        .setNativeDialogHandler(dialogHandler)
+        .click('#buttonConfirm')
+        .expect(await getResult()).eql('true');
+});
+
+test('Different dialogs after actions', async t => {
+    await t
+        .setNativeDialogHandler(type => {
+            if (type === 'confirm')
+                throw new Error('Wrong dialog type');
+        })
+        .click('#buttonAlert')
+        .setNativeDialogHandler(type => {
+            if (type === 'alert')
+                throw new Error('Wrong dialog type');
+        })
+        .click('#buttonConfirm');
+});
+
+test('Confirm dialog with wrong text', async t => {
+    await t
+        .setNativeDialogHandler(() => {
+            throw new Error('Wrong dialog text');
+        })
+        .click('#buttonConfirm')
+        .expect(await getResult()).eql('true');
+});
+
+test('No expected confirm after an action', async t => {
+    await t
+        .click('#withoutDialog')
+        .setNativeDialogHandler(() => true);
+
+    var info = await t
+        .getNativeDialogHistory();
+
+    await t.expect(info.length).eql(1);
+});
+
+test('Expected beforeUnload after an action', async t => {
+    await t
+        .setNativeDialogHandler(() => {
+        })
+        .click('#enableBeforeUnload')
+        .click('#linkToThisPage');
+
+    var info = await t
+        .getNativeDialogHistory();
+
+    await t.expect(info).eql([{type: 'beforeunload', text: 'Before unload', url: pageUrl}]);
+});
+
+test('Expected alert and prompt after redirect', async t => {
+    await t
+        .setNativeDialogHandler((type, text, url) => {
+            if (type === 'prompt' && text === 'Prompt:' &&
+                url === 'http://localhost:3000/fixtures/api/es-next/native-dialogs-handling/pages/prompt.html')
+                return 'prompt result';
+
+            return null;
+        })
+        .click('#buttonRedirectPrompt');
+
+    await t.expect(await getResult()).eql('prompt result');
+
+    var info = await t
+        .getNativeDialogHistory();
+
+    await t.expect(info).eql([
+            {
+                type: 'prompt',
+                text: 'Prompt:',
+                url: promptPageUrl
+            },
+            {
+                type: 'alert',
+                text: 'Alert!',
+                url: pageUrl
+            }
+        ]);
+});
+
+test('Unexpected prompt after redirect', async t => {
+    await t.click('#linkToPromptPage');
+});
+
+//Dialogs during wait command execution
+test('Expected alert during a wait action', async t => {
+    await t
+        .setNativeDialogHandler(() => null)
+        .click('#buttonDialogAfterTimeout')
+        .wait(2000);
+
+    var info = await t
+        .getNativeDialogHistory();
+
+    await t.expect(info).eql([{type: 'alert', text: 'Alert!', url: pageUrl}]);
+});
+
+test('No expected alert during a wait action', async t => {
+    await t
+        .setNativeDialogHandler(() => null)
+        .click('#buttonDialogAfterTimeout')
+        .wait(10);
+
+    var info = await t
+      .getNativeDialogHistory();
+
+    await t.expect(info.length).eql(1);
+});
+
+test('Unexpected alert during a wait action', async t => {
+    await t
+        .click('#buttonDialogAfterTimeout')
+        .wait(2000);
+});
+
+test('Selector as dialogHandler', async t => {
+    var dialogHandler = Selector(() => document.body);
+
+    await t.setNativeDialogHandler(dialogHandler);
+});
+
+
+test('Null handler', async t => {
+    await t
+        .setNativeDialogHandler(() => true)
+        .click('#buttonAlert')
+        .setNativeDialogHandler(null)
+        .click('#buttonAlert');
+});
+
+const getLocation = ClientFunction(() => window.location.toString().toLowerCase().replace(/\/\/\//g, '//'));
+
+test('Navigate to absolute http page', async t => {
+    await t
+        .navigateTo('http://localhost:3000/fixtures/api/es-next/navigate-to-and-test-page/pages/navigation.html')
+        .click('#button')
+        .expect(getLocation()).eql('http://localhost:3000/fixtures/api/es-next/navigate-to-and-test-page/pages/navigation.html');
+});
+
+test('Navigate to relative http page', async t => {
+    await t
+        .navigateTo('navigation.html')
+        .click('#button')
+        .expect(getLocation()).eql('http://localhost:3000/fixtures/api/es-next/navigate-to-and-test-page/pages/navigation.html');
+});
+
+test('Navigate to scheme-less http page', async t => {
+    await t
+        .navigateTo('//localhost:3000/fixtures/api/es-next/navigate-to-and-test-page/pages/navigation.html')
+        .click('#button')
+        .expect(getLocation()).eql('http://localhost:3000/fixtures/api/es-next/navigate-to-and-test-page/pages/navigation.html');
+});
+
+const focusInput = ClientFunction(() => {
+  var input = document.getElementById('input');
+
+  if (input)
+      input.focus();
+});
+
+const getInputValue = ClientFunction(() => {
+    var input = document.getElementById('input');
+
+    return (input instanceof HTMLInputElement) ? input.value : '';
+});
+
+test('Press keys', async t => {
+    await focusInput();
+    await t
+        .pressKey('right shift+right shift+right delete')
+        .expect(await getInputValue()).eql('vue');
+});
+
+
+test('Resize the window', async t => {
+    await t.resizeWindow(150, 300);
+});
+
+test('Incorrect action height argument', async t => {
+    await t.resizeWindow(500, -5);
+});
+
+test('Resize the window to fit a device', async t => {
+    await t.resizeWindowToFitDevice('iPhone');
+});
+
+test('Resize the window to fit a device with portrait orientation', async t => {
+    await t.resizeWindowToFitDevice('iPhone', {portraitOrientation: true});
+});
+
+test('Right click button', async t => {
+    await t.rightClick('#button');
+});
+
+
+test('Select text in input', async t => {
+    await t.selectText('#input', 2, 4);
+});
+
+test('Select content in textarea', async t => {
+    await t.selectTextAreaContent('#textarea', 0, 2, 1, 3);
+});
+
+test('Select editable content', async t => {
+    await t.selectEditableContent('#p1', '#p2');
+});
+
+
+test('Take a screenshot with a custom path (DOS separator)', async t => {
+
+    await t.takeScreenshot('custom\\' + 123 + '.png').takeElementScreenshot('body', 'custom.png');
+});
+
+
+test('Take a screenshot in quarantine mode', async t => {
+    await t
+        .takeScreenshot()
+        .click('.notExist');
+});
+
+
+test('Type text in input', async t => {
+    await t.typeText('#input', 'a', { replace: true });
+});
+
+
+test('Upload the file', async t => {
+    await t
+        .setFilesToUpload('#file', '../test-data/file1.txt')
+        .click('#submit');
+});
+
+test('Clear the upload', async t => {
+    await t
+        .setFilesToUpload('#file', '../test-data/file1.txt')
+        .clearUpload('#file')
+        .click('#submit');
+});
+
+test('Wait', async t => {
+    await t
+        .click('#button1')
+        .wait(2000)
+        .click('#button2');
+});
+
+test('Chaining', async t => {
+    await t
+        .click('#btn1')
+        .click('#btn2');
+
+    await t
+        .click('#btn3')
+        .click('#page2-btn1')
+        .click('#page2-btn2');
+});
+
+test('Chaining callsites', async t => {
+    await t
+        .click('#btn1')
+        .click('#btn2')
+        .click('#error')
+        .click('#btn3');
+});
diff --git a/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/testcafe_v0.x.x.js b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/testcafe_v0.x.x.js
new file mode 100644
index 0000000000..b45c4ab620
--- /dev/null
+++ b/definitions/npm/testcafe_v0.x.x/flow_v0.201.x-/testcafe_v0.x.x.js
@@ -0,0 +1,696 @@
+/**
+ * Flowtype definitions for TestCafe
+ * Based on definitions generated by Flowgen
+ * Flowgen v1.2.0
+ * Author: [Joar Wilk](http://twitter.com/joarwilk)
+ * Repo: http://github.com/joarwilk/flowgen
+ */
+
+declare type TestCafe$CustomPropsSnapshotTypeTransform = <V>((node: HTMLElement) => V | Promise<V>) => V
+declare type TestCafe$CustomPropsSelectorTypeTransform = <V>((node: HTMLElement) => V | Promise<V>) => Promise<V>
+declare type TestCafe$CustomMethodsSelectorTypeTransform = <V>((node: HTMLElement, ...args: any) => V | Promise<V>) => ((...args: any) => Promise<V>)
+
+declare type TestCafe$ClientFunctionOptions = {
+    dependencies?: { [string]: any, ... },
+    boundTestRun?: TestCafe$TestController,
+    ...
+}
+
+declare interface TestCafe$TextRectangle {
+    bottom: number,
+    left: number,
+    right: number,
+    top: number,
+    width: number,
+    height: number
+}
+
+declare interface TestCafe$NodeSnapshot {
+    childElementCount: number,
+    childNodeCount: number,
+    hasChildElements: boolean,
+    hasChildNodes: boolean,
+    nodeType: number,
+    textContent: string,
+    attributes?: { [name: string]: string, ... },
+    boundingClientRect?: TestCafe$TextRectangle,
+    checked?: boolean | void,
+    classNames?: string[],
+    clientHeight?: number,
+    clientLeft?: number,
+    clientTop?: number,
+    clientWidth?: number,
+    focused?: boolean,
+    id?: string,
+    innerText?: string,
+    namespaceURI?: string | null,
+    offsetHeight?: number,
+    offsetLeft?: number,
+    offsetTop?: number,
+    offsetWidth?: number,
+    selected?: boolean | void,
+    selectedIndex?: number | void,
+    scrollHeight?: number,
+    scrollLeft?: number,
+    scrollTop?: number,
+    scrollWidth?: number,
+    style?: { [prop: string]: string, ... },
+    tagName?: string,
+    value?: string | void,
+    visible?: boolean,
+    hasClass(className: string): boolean,
+    getStyleProperty(propertyName: string): string,
+    getAttribute(attributeName: string): string,
+    getBoundingClientRectProperty(propertyName: string): number,
+    hasAttribute(attributeName: string): boolean
+}
+
+declare interface TestCafe$SelectorOptions {
+    boundTestRun?: TestCafe$TestController,
+    timeout?: number,
+    visibilityCheck?: boolean
+}
+
+declare interface TestCafe$SelectorAPI {
+    childElementCount: Promise<number>,
+    childNodeCount: Promise<number>,
+    hasChildElements: Promise<boolean>,
+    hasChildNodes: Promise<boolean>,
+    nodeType: Promise<number>,
+    textContent: Promise<string>,
+    attributes: Promise<{ [name: string]: string, ... }>,
+    boundingClientRect: Promise<TestCafe$TextRectangle>,
+    checked: Promise<boolean | void>,
+    classNames: Promise<string[]>,
+    clientHeight: Promise<number>,
+    clientLeft: Promise<number>,
+    clientTop: Promise<number>,
+    clientWidth: Promise<number>,
+    focused: Promise<boolean>,
+    id: Promise<string>,
+    innerText: Promise<string>,
+    namespaceURI: Promise<string | null>,
+    offsetHeight: Promise<number>,
+    offsetLeft: Promise<number>,
+    offsetTop: Promise<number>,
+    offsetWidth: Promise<number>,
+    selected: Promise<boolean | void>,
+    selectedIndex: Promise<number | void>,
+    scrollHeight: Promise<number>,
+    scrollLeft: Promise<number>,
+    scrollTop: Promise<number>,
+    scrollWidth: Promise<number>,
+    style: Promise<{ [prop: string]: string, ... }>,
+    tagName: Promise<string>,
+    value: Promise<string | void>,
+    visible: Promise<boolean>,
+
+    hasClass(className: string): Promise<boolean>,
+    getStyleProperty(propertyName: string): Promise<string>,
+    getAttribute(attributeName: string): Promise<string>,
+    getBoundingClientRectProperty(propertyName: string): Promise<number>,
+    hasAttribute(attributeName: string): Promise<boolean>,
+    nth(index: number): TestCafe$SelectorFn,
+    withText(text: string): TestCafe$SelectorFn,
+    withText(re: RegExp): TestCafe$SelectorFn,
+    withExactText(text: string): TestCafe$SelectorFn;
+    withAttribute(attrName: string | RegExp, attrValue?: string | RegExp): TestCafe$SelectorPromise,
+    filterVisible(): TestCafe$SelectorFn;
+    filterHidden(): TestCafe$SelectorFn;
+    filter(cssSelector: string): TestCafe$SelectorFn,
+    filter(
+        filterFn: (node: Element, idx: number) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+    find(cssSelector: string): TestCafe$SelectorFn,
+    find(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+    parent(): TestCafe$SelectorFn,
+    parent(index: number): TestCafe$SelectorFn,
+    parent(cssSelector: string): TestCafe$SelectorFn,
+    parent(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+    child(): TestCafe$SelectorFn,
+    child(index: number): TestCafe$SelectorFn,
+    child(cssSelector: string): TestCafe$SelectorFn,
+    child(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+    sibling(): TestCafe$SelectorFn,
+
+
+    sibling(index: number): TestCafe$SelectorFn,
+
+
+    sibling(cssSelector: string): TestCafe$SelectorFn,
+
+
+    sibling(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+
+    nextSibling(): TestCafe$SelectorFn,
+
+
+    nextSibling(index: number): TestCafe$SelectorFn,
+
+
+    nextSibling(cssSelector: string): TestCafe$SelectorFn,
+
+
+    nextSibling(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+
+    prevSibling(): TestCafe$SelectorFn,
+
+
+    prevSibling(index: number): TestCafe$SelectorFn,
+
+
+    prevSibling(cssSelector: string): TestCafe$SelectorFn,
+
+
+    prevSibling(
+        filterFn: (node: Element, idx: number, originNode: Element) => boolean,
+        dependencies?: { [string]: any, ... }): TestCafe$SelectorFn,
+
+
+    exists: Promise<boolean>,
+
+
+    count: Promise<number>,
+
+
+    addCustomDOMProperties<T>(props: T): TestCafe$CustomPropsSelectorFn<T>,
+
+
+    addCustomMethods<T>(methods: T): TestCafe$CustomMethodsSelectorFn<T>,
+
+
+    with(options?: TestCafe$SelectorOptions): TestCafe$SelectorFn
+}
+
+declare interface TestCafe$SelectorPromise extends TestCafe$SelectorAPI, Promise<TestCafe$NodeSnapshot> {
+
+}
+
+declare interface TestCafe$CustomMethodsSelectorPromiseI<T> extends TestCafe$SelectorAPI, Promise<TestCafe$NodeSnapshot & $ObjMap<T, TestCafe$CustomMethodsSelectorTypeTransform>> {
+
+}
+
+declare type TestCafe$CustomMethodsSelectorPromise<T> = TestCafe$CustomMethodsSelectorPromiseI<T> & $ObjMap<T, TestCafe$CustomMethodsSelectorTypeTransform>;
+
+declare interface TestCafe$CustomPropsSelectorPromiseI<T> extends TestCafe$SelectorAPI, Promise<TestCafe$NodeSnapshot & $ObjMap<T, TestCafe$CustomPropsSnapshotTypeTransform>> {
+
+}
+
+declare type TestCafe$CustomPropsSelectorPromise<T> = TestCafe$CustomPropsSelectorPromiseI<T> & $ObjMap<T, TestCafe$CustomPropsSelectorTypeTransform>;
+
+declare interface TestCafe$RoleOptions {
+    preseveUrl?: boolean
+}
+
+declare interface TestCafe$KeyModifiers {
+    ctrl?: boolean,
+    alt?: boolean,
+    shift?: boolean,
+    meta?: boolean
+}
+
+declare interface TestCafe$CropOptions {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+
+declare interface TestCafe$ActionOptions {
+    speed?: number
+}
+
+declare interface TestCafe$TakeElementScreenshotOptions extends TestCafe$ActionOptions {
+    crop?: TestCafe$CropOptions;
+    includeMargins?: boolean;
+    includeBorders?: boolean;
+    includePaddings?: boolean;
+    scrollTargetX?: number;
+    scrollTargetY?: number;
+}
+
+declare interface TestCafe$MouseActionOptions extends TestCafe$ActionOptions {
+    offsetX?: number,
+    offsetY?: number,
+    modifiers?: TestCafe$KeyModifiers
+}
+
+declare interface TestCafe$ClickActionOptions extends TestCafe$MouseActionOptions {
+    caretPos?: number
+}
+
+declare interface TestCafe$DragToElementOptions extends TestCafe$MouseActionOptions {
+    destinationOffsetX?: number;
+    destinationOffsetY?: number;
+}
+
+declare interface TestCafe$TypeActionOptions extends TestCafe$ClickActionOptions {
+    replace?: boolean,
+    paste?: boolean
+}
+
+declare interface TestCafe$ResizeToFitDeviceOptions {
+    portraitOrientation?: boolean
+}
+
+declare interface TestCafe$NativeDialogHistoryItem {
+    type: 'alert' | 'confirm' | 'beforeunload' | 'prompt',
+    text: string,
+    url: string
+}
+
+declare interface TestCafe$RequestLogger {
+    contains(predicate: Function): Promise<boolean>;
+    count(predicate: Function): Promise<number>;
+    clear(): void;
+
+    requests: TestCafe$Request[];
+}
+
+declare interface TestCafe$RequestLoggerOptions {
+    logRequestHeaders?: boolean;
+    logRequestBody?: boolean;
+    stringifyRequestBody?: boolean;
+    logResponseHeaders?: boolean;
+    logResponseBody?: boolean;
+    stringifyResponseBody?: boolean;
+}
+
+interface TestCafe$RequestMock {
+    onRequestTo(filter: string | RegExp | Object | (req: TestCafe$RequestData, res: TestCafe$ResponseData) => boolean): TestCafe$RequestMock;
+
+    respond(body?: null | Object | string | (req: TestCafe$RequestData, res: TestCafe$ResponseData) => any, statusCode?: number, headers?: Object): TestCafe$RequestMock;
+}
+
+interface TestCafe$Request {
+    userAgent: string;
+    request: TestCafe$RequestData;
+    response: TestCafe$ResponseData;
+}
+
+interface TestCafe$RequestData {
+    url: string;
+    method: string;
+    headers: Object;
+    body: string | any;
+}
+
+interface TestCafe$ResponseData {
+    statusCode: string;
+    headers: Object;
+    body: string | any;
+}
+
+declare type TestCafe$SelectorParameter =
+  string |
+  TestCafe$SelectorFn |
+  TestCafe$NodeSnapshot |
+  TestCafe$SelectorPromise |
+  (...args: any[]) => null | Node | Node[] | NodeList<any> | HTMLCollection<any>;
+
+declare interface TestCafe$TestController {
+    ctx: { [key: string]: any, ... },
+    fixtureCtx: { [key: string]: any, ... },
+
+    click(
+        selector: TestCafe$SelectorParameter,
+        options?: TestCafe$ClickActionOptions): TestCafe$TestControllerPromise,
+
+    rightClick(
+        selector: TestCafe$SelectorParameter,
+        options?: TestCafe$ClickActionOptions): TestCafe$TestControllerPromise,
+
+    doubleClick(
+        selector: TestCafe$SelectorParameter,
+        options?: TestCafe$ClickActionOptions): TestCafe$TestControllerPromise,
+
+    hover(
+        selector: TestCafe$SelectorParameter,
+        options?: TestCafe$MouseActionOptions): TestCafe$TestControllerPromise,
+
+    drag(
+        selector: TestCafe$SelectorParameter,
+        dragOffsetX: number,
+        dragOffsetY: number,
+        options?: TestCafe$DragToElementOptions): TestCafe$TestControllerPromise,
+
+    dragToElement(
+        selector: TestCafe$SelectorParameter,
+        destinationSelector: TestCafe$SelectorParameter,
+        options?: TestCafe$MouseActionOptions): TestCafe$TestControllerPromise,
+
+    typeText(
+        selector: TestCafe$SelectorParameter,
+        text: string,
+        options?: TestCafe$TypeActionOptions): TestCafe$TestControllerPromise,
+
+    selectText(
+        selector: TestCafe$SelectorParameter,
+        startPos?: number,
+        endPos?: number,
+        options?: TestCafe$ActionOptions): TestCafe$TestControllerPromise,
+
+    selectTextAreaContent(
+        selector: TestCafe$SelectorParameter,
+        startLine?: number,
+        startPos?: number,
+        endLine?: number,
+        endPos?: number,
+        options?: TestCafe$ActionOptions): TestCafe$TestControllerPromise,
+
+    selectEditableContent(
+        startSelector: TestCafe$SelectorParameter,
+        endSelector: TestCafe$SelectorParameter,
+        options?: TestCafe$ActionOptions): TestCafe$TestControllerPromise,
+
+    pressKey(keys: string, options?: TestCafe$ActionOptions): TestCafe$TestControllerPromise,
+
+    wait(timeout: number): TestCafe$TestControllerPromise,
+
+    navigateTo(url: string): TestCafe$TestControllerPromise,
+
+    setFilesToUpload(
+        selector: TestCafe$SelectorParameter,
+        filePath: string | string[]): TestCafe$TestControllerPromise,
+
+    clearUpload(selector: TestCafe$SelectorParameter): TestCafe$TestControllerPromise,
+
+    takeScreenshot(path?: string): TestCafe$TestControllerPromise,
+
+    takeElementScreenshot(selector: TestCafe$SelectorParameter,
+                          path?:    string,
+                          options?: TestCafe$TakeElementScreenshotOptions): TestCafe$TestControllerPromise,
+                          
+    resizeWindow(width: number, height: number): TestCafe$TestControllerPromise,
+
+    resizeWindowToFitDevice(deviceName: string, options?: TestCafe$ResizeToFitDeviceOptions): TestCafe$TestControllerPromise,
+
+    maximizeWindow(): TestCafe$TestControllerPromise,
+
+    switchToIframe(selector: TestCafe$SelectorParameter): TestCafe$TestControllerPromise,
+
+    switchToMainWindow(): TestCafe$TestControllerPromise,
+
+    eval(fn: Function, options?: TestCafe$ClientFunctionOptions): Promise<any>,
+
+    setNativeDialogHandler(
+        fn: ((
+            type: 'alert' | 'confirm' | 'beforeunload' | 'prompt',
+            text: string,
+            url: string) => any) | null,
+        options?: TestCafe$ClientFunctionOptions): TestCafe$TestControllerPromise,
+
+    getNativeDialogHistory(): Promise<TestCafe$NativeDialogHistoryItem[]>,
+
+    expect(actual: any): TestCafe$Assertion,
+
+    debug(): TestCafe$TestControllerPromise,
+
+    setTestSpeed(speed: number): TestCafe$TestControllerPromise,
+
+    setPageLoadTimeout(duration: number): TestCafe$TestControllerPromise,
+    
+    useRole(role: TestCafe$RoleFn): TestCafe$TestControllerPromise,
+    
+    addRequestHooks(...hooks: Object[]): TestCafe$TestControllerPromise,
+
+    removeRequestHooks(...hooks: Object[]): TestCafe$TestControllerPromise
+}
+
+declare interface TestCafe$TestControllerPromise extends TestCafe$TestController, Promise<any> {
+
+};
+
+declare interface TestCafe$AssertionOptions {
+    timeout?: number,
+    allowUnawaitedPromise?: boolean
+}
+
+declare interface TestCafe$Assertion {
+    eql(
+        expected: any,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    eql(expected: any, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notEql(
+        unexpected: any,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notEql(unexpected: any, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    ok(message?: string, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    ok(options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notOk(message?: string, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notOk(options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    contains(
+        expected: any,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    contains(expected: any, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notContains(
+        unexpected: any,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notContains(unexpected: any, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    typeOf(
+        typeName: string,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    typeOf(typeName: string, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notTypeOf(
+        typeName: string,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notTypeOf(typeName: string, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    gt(
+        expected: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    gt(expected: number, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    gte(
+        expected: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    gte(expected: number, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    lt(
+        expected: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    lt(expected: number, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    lte(
+        expected: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    lte(expected: number, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    within(
+        start: number,
+        finish: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    within(
+        start: number,
+        finish: number,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notWithin(
+        start: number,
+        finish: number,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notWithin(
+        start: number,
+        finish: number,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    match(
+        re: RegExp,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    match(re: RegExp, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notMatch(
+        re: RegExp,
+        message?: string,
+        options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise,
+
+    notMatch(re: RegExp, options?: TestCafe$AssertionOptions): TestCafe$TestControllerPromise
+}
+
+declare interface TestCafe$HTTPAuthCredentials {
+    username: string,
+    password: string,
+    domain?: string,
+    workstation?: string
+}
+
+declare interface TestCafe$FixtureFn {
+    (name: string|string[]): TestCafe$FixtureFn,
+    page(url: string|string[]): TestCafe$FixtureFn,
+    httpAuth(credentials: TestCafe$HTTPAuthCredentials): TestCafe$FixtureFn,
+    before(fn: (ctx: { [key: string]: any, ... }) => Promise<any>): TestCafe$FixtureFn,
+    after(fn: (ctx: { [key: string]: any, ... }) => Promise<any>): TestCafe$FixtureFn,
+    beforeEach(fn: (t: TestCafe$TestController) => Promise<any>): TestCafe$FixtureFn,
+    afterEach(fn: (t: TestCafe$TestController) => Promise<any>): TestCafe$FixtureFn,
+    skip: TestCafe$FixtureFn,
+    only: TestCafe$FixtureFn,
+    meta(key: string, value: string): TestCafe$FixtureFn,
+    meta(data: Object): TestCafe$FixtureFn,
+    requestHooks(...hooks: Object[]): TestCafe$TestFn
+}
+
+declare interface TestCafe$TestFn {
+    (name: string|string[], fn: (t: TestCafe$TestController) => Promise<any>): TestCafe$TestFn,
+    page(url: string|string[]): TestCafe$TestFn,
+    httpAuth(credentials: TestCafe$HTTPAuthCredentials): TestCafe$TestFn,
+    before(fn: (t: TestCafe$TestController) => Promise<any>): TestCafe$TestFn,
+    after(fn: (t: TestCafe$TestController) => Promise<any>): TestCafe$TestFn,
+    skip: TestCafe$TestFn,
+    only: TestCafe$TestFn,
+    meta(key: string, value: string): TestCafe$TestFn,
+    meta(data: Object): TestCafe$TestFn,
+    requestHooks(...hooks: Object[]): TestCafe$TestFn
+}
+
+declare interface TestCafe$SelectorCallable {
+  (...args: any[]): TestCafe$SelectorPromise
+}
+
+declare interface TestCafe$CustomSelectorCallable<T> {
+  (...args: any[]): T
+}
+
+declare type TestCafe$SelectorFn = TestCafe$SelectorAPI & TestCafe$SelectorCallable;
+
+declare type TestCafe$CustomSelectorFnI<T> = TestCafe$SelectorAPI & TestCafe$CustomSelectorCallable<T>;
+
+declare type TestCafe$CustomPropsSelectorFn<T> = TestCafe$CustomSelectorFnI<TestCafe$CustomPropsSelectorPromise<T>> & $ObjMap<T, TestCafe$CustomPropsSelectorTypeTransform>;
+
+declare type TestCafe$CustomMethodsSelectorFn<T> = TestCafe$CustomSelectorFnI<TestCafe$CustomMethodsSelectorPromise<T>> & $ObjMap<T, TestCafe$CustomMethodsSelectorTypeTransform>;
+
+declare interface TestCafe$ClientFunctionFn {
+    (...args: any[]): Promise<any>,
+    with(options: TestCafe$ClientFunctionOptions): TestCafe$ClientFunctionFn
+}
+
+declare interface TestCafe$RoleFn {
+    (url: string, fn: (t: TestCafe$TestController) => Promise<any>, options?: TestCafe$RoleOptions): TestCafe$RoleFn,
+    anonymous(): TestCafe$RoleFn
+};
+
+declare function TestCafe$RequestMockFn(): TestCafe$RequestMock;
+
+declare function TestCafe$RequestLoggerFn(filter?: string | RegExp | Object | (req: TestCafe$RequestData, res: TestCafe$ResponseData) => boolean, options?: TestCafe$RequestLoggerOptions): TestCafe$RequestLogger;
+
+declare class TestCafe$RequestHookClass {
+    constructor(requestFilterRules?: any[], responseEventConfigureOpts?: Object): TestCafe$RequestHookClass,
+    onRequest(requestEvent: Object): void,
+    onResponse(responseEvent: Object): void
+}
+    
+declare var fixture: TestCafe$FixtureFn;
+declare var test: TestCafe$TestFn;
+
+declare module 'testcafe' {
+    declare interface BrowserConnection {
+        url: string,
+        on(event: 'ready', handler: Function): BrowserConnection
+    }
+
+    declare type BrowserType = string | {
+        path: string,
+        cmd: string,
+        ...
+    } | BrowserConnection;
+
+    declare interface Stream {
+        write(chunk: string): any
+    }
+
+    declare interface CancelablePromise<T> extends Promise<T> {
+        cancel(): Promise<void>
+    }
+
+    declare class Runner {
+        src(...source: (string | string [])[]): Runner,
+        filter(callback: (testName: string, fixtureName: string, fixturePath: string) => boolean): Runner,
+        browsers(...browser: (BrowserType | BrowserType [])[]): Runner,
+        screenshots(path: string, takeOnFails?: boolean): Runner,
+        reporter(name: string, outStream?: Stream): Runner,
+        startApp(command: string, initDelay?: number): Runner,
+        useProxy(host: string, bypassRules?: string|string[]): Runner,
+
+        run(options?: {
+            skipJsErrors: boolean,
+            quarantineMode: boolean,
+            selectorTimeout: number,
+            assertionTimeout: number,
+            pageLoadTimeout: number,
+            speed: number,
+            debugMode: boolean,
+            debugOnFail: boolean,
+            ...
+        }): CancelablePromise<number>,
+
+        stop(): Promise<void>
+    }
+
+    declare interface TestCafe {
+        createBrowserConnection(): Promise<BrowserConnection>,
+        createRunner(): Runner,
+        close(): Promise<void>
+    }
+
+    declare module.exports: {
+        (hostname: string, port1: number, port2: number): Promise<TestCafe>,
+        Selector(init: TestCafe$SelectorParameter, options?: TestCafe$SelectorOptions): TestCafe$SelectorFn,
+        ClientFunction(fn: (...args: any) => any, options?: TestCafe$ClientFunctionOptions): TestCafe$ClientFunctionFn,
+        Role: TestCafe$RoleFn,
+        RequestMock: typeof TestCafe$RequestMockFn,
+        RequestLogger: typeof TestCafe$RequestLoggerFn,
+        RequestHook: Class<TestCafe$RequestHookClass>,
+        t: TestCafe$TestController,
+        ...
+    };
+}
diff --git a/definitions/npm/underscore.string_v3.x.x/flow_v0.104.x-/underscore.string_v3.x.x.js b/definitions/npm/underscore.string_v3.x.x/flow_v0.104.x-v.200.x/underscore.string_v3.x.x.js
similarity index 100%
rename from definitions/npm/underscore.string_v3.x.x/flow_v0.104.x-/underscore.string_v3.x.x.js
rename to definitions/npm/underscore.string_v3.x.x/flow_v0.104.x-v.200.x/underscore.string_v3.x.x.js
diff --git a/definitions/npm/underscore.string_v3.x.x/flow_v0.201.x-/underscore.string_v3.x.x.js b/definitions/npm/underscore.string_v3.x.x/flow_v0.201.x-/underscore.string_v3.x.x.js
new file mode 100644
index 0000000000..ddd31fa445
--- /dev/null
+++ b/definitions/npm/underscore.string_v3.x.x/flow_v0.201.x-/underscore.string_v3.x.x.js
@@ -0,0 +1,178 @@
+declare module "underscore.string" {
+
+  declare type $npm$wrap$options = {
+    width?: number,
+    seperator?: string,
+    trailingSpaces?: boolean,
+    cut?: boolean,
+    preserveSpaces?: boolean,
+    ...
+  };
+  declare type $npm$pad$type = 'left' | 'right' | 'both';
+
+  declare class Chain {
+    levenshtein(string2: string): number;
+    capitalize(lowercaseRest?: boolean): Chain;
+    decapitalize(): Chain;
+    chop(step: number): Array<string>;
+    clean(): Chain;
+    swapCase(): Chain;
+    include(substring: string): boolean;
+    contains(substring: string): boolean; // Alias
+    count(substring: string): number;
+    escapeHTML(): Chain;
+    unescapeHTML(): Chain;
+    insert(index: number, substring: string): Chain;
+    replaceAll(find: string, replace: string, ignorecase?: boolean): Chain;
+    isBlank(): boolean;
+    join(...strings: Array<string>): Chain,
+    lines(): Array<string>;
+    wrap(options: $npm$wrap$options): Chain;
+    dedent(pattern?: string): Chain;
+    reverse(): Chain;
+    splice(index: number, howmany: number, substring: string): Chain;
+    startsWith(starts: string, position?: number): boolean;
+    endsWith(ends: string, position?: number): boolean;
+    pred(): Chain;
+    succ(): Chain;
+    titleize(): Chain;
+    camelize(decapitalize?: boolean): Chain;
+    camelcase(decapitalize?: boolean): Chain, // Alia;
+    classify(): Chain;
+    underscored(): Chain;
+    dasherize(): Chain;
+    humanize(): Chain;
+    trim(characters?: string): Chain;
+    strip(characters?: string): Chain, // Alia;
+    ltrim(characters?: string): Chain;
+    lstrip(characters?: string): Chain, // Alia;
+    rtrim(characters?: string): Chain;
+    rstrip(characters?: string): Chain, // Alia;
+    truncate(length: number, truncateString?: string): Chain;
+    prune(length: number, pruneString: string): Chain;
+    words(delimiter: string|RegExp): Array<string>;
+    sprintf(...arguments: Array<any>): Chain;
+    pad(length: number, padStr?: string, type?: $npm$pad$type): Chain;
+    lpad(length: number, padStr?: string): Chain;
+    rjust(length: number, padStr?: string): Chain, // Alia;
+    rpad(length: number, padStr?: string): Chain;
+    ljust(length: number, padStr?: string): Chain, // Alia;
+    lrpad(length: number, padStr?: string): Chain;
+    center(length: number, padStr?: string): Chain, // Alia;
+    toNumber(decimals?: number): number;
+    strRight(pattern: string): Chain;
+    strRightBack(pattern: string): Chain;
+    strLeft(pattern: string): Chain;
+    strLeftBack(pattern: string): Chain;
+    stripTags(): Chain;
+    // --
+    repeat(count: number, separator?: string): Chain,
+    surround(wrap: string): Chain,
+    quote(quoteChar?: string): Chain,
+    q(quoteChar?: string): Chain, // Alias
+    unquote(quoteChar?: string): Chain,
+    slugify(): Chain,
+    naturalCmp(string2: string): number,
+    toBoolean(truthy?: Array<string|RegExp>, falsy?: Array<string|RegExp>): ?boolean,
+    toBool(truthy?: Array<string|RegExp>, falsy?: Array<string|RegExp>): ?boolean, // Alias
+    map(iteratee: (character: string) => string): Chain,
+
+    // native Javascript string methods
+    toUpperCase(): Chain,
+    toLowerCase(): Chain,
+    split(separator?: string, limit?: number): Array<string>,
+    replace(pattern: string|RegExp, replacement: string|((...params: Array<string|number>) => string)): Chain,
+    slice(beginSlice: number, endSlice?: number): Chain,
+    substring(indexStart: number, indexStart?: number): Chain,
+    substr(start: number, length?: number): Chain,
+    concat(...params: Array<string>): Chain,
+
+    // Chain specific methods
+    tap(fn: (string: string) => string): Chain;
+    value(): string;
+  }
+
+  declare module.exports: {
+    // If we're called, we're a function that returns an instance of Chain
+    (str: string): Chain,
+    // Otherwise lots of "static" methods...
+    numberFormat(number: number, decimals?: number, decimalSeparator?: string, orderSeparator?: string): string,
+    levenshtein(string1: string, string2: string): number,
+    capitalize(string: string, lowercaseRest?: boolean): string,
+    decapitalize(string: string): string,
+    chop(string: string, step: number): Array<string>,
+    clean(string: string): string,
+    swapCase(string: string): string,
+    include(string: string, substring: string): boolean,
+    // Alias
+    contains(string: string, substring: string): boolean,
+    count(string: string, substring: string): number,
+    escapeHTML(string: string): string,
+    unescapeHTML(string: string): string,
+    insert(string: string, index: number, substring: string): string,
+    replaceAll(string: string, find: string, replace: string, ignorecase?: boolean): string,
+    isBlank(string: string): boolean,
+    join(separator: string, ...strings: Array<string>): string,
+    lines(string: string): Array<string>,
+    wrap(string: string, options: $npm$wrap$options): string,
+    dedent(string: string, pattern?: string): string,
+    reverse(string: string): string,
+    splice(string: string, index: number, howmany: number, substring: string): string,
+    startsWith(string: string, starts: string, position?: number): boolean,
+    endsWith(string: string, ends: string, position?: number): boolean,
+    pred(string: string): string,
+    succ(string: string): string,
+    titleize(string: string): string,
+    camelize(string: string, decapitalize?: boolean): string,
+    // Alias
+    camelcase(string: string, decapitalize?: boolean): string,
+    classify(string: string): string,
+    underscored(string: string): string,
+    dasherize(string: string): string,
+    humanize(string: string): string,
+    trim(string: string, characters?: string): string,
+    // Alias
+    strip(string: string, characters?: string): string,
+    ltrim(string: string, characters?: string): string,
+    // Alias
+    lstrip(string: string, characters?: string): string,
+    rtrim(string: string, characters?: string): string,
+    // Alias
+    rstrip(string: string, characters?: string): string,
+    truncate(string: string, length: number, truncateString?: string): string,
+    prune(string: string, length: number, pruneString: string): string,
+    words(string: string, delimiter: string|RegExp): Array<string>,
+    sprintf(string: string, ...arguments: Array<any>): string,
+    pad(string: string, length: number, padStr?: string, type?: $npm$pad$type): string,
+    lpad(string: string, length: number, padStr?: string): string,
+    // Alias
+    rjust(string: string, length: number, padStr?: string): string,
+    rpad(string: string, length: number, padStr?: string): string,
+    // Alias
+    ljust(string: string, length: number, padStr?: string): string,
+    lrpad(string: string, length: number, padStr?: string): string,
+    // Alias
+    center(string: string, length: number, padStr?: string): string,
+    toNumber(string: string, decimals?: number): number,
+    strRight(string: string, pattern: string): string,
+    strRightBack(string: string, pattern: string): string,
+    strLeft(string: string, pattern: string): string,
+    strLeftBack(string: string, pattern: string): string,
+    stripTags(string: string): string,
+    toSentence(array: Array<string>, delimiter?: string, lastDelimiter?: string): string,
+    toSentenceSerial(array: Array<string>, delimiter?: string, lastDelimiter?: string): string,
+    repeat(string: string, count: number, separator?: string): string,
+    surround(string: string, wrap: string): string,
+    quote(string: string, quoteChar?: string): string,
+    // Alias
+    q(string: string, quoteChar?: string): string,
+    unquote(string: string, quoteChar?: string): string,
+    slugify(string: string): string,
+    naturalCmp(string1: string, string2: string): number,
+    toBoolean(string: string, truthy?: Array<string|RegExp>, falsy?: Array<string|RegExp>): ?boolean,
+    // Alias
+    toBool(string: string, truthy?: Array<string|RegExp>, falsy?: Array<string|RegExp>): ?boolean,
+    map(string: string, iteratee: (character: string) => string): string,
+    ...
+  }
+}
diff --git a/definitions/npm/unified_v6.x.x/flow_v0.104.x-/test_unified_v6.x.x.js b/definitions/npm/unified_v6.x.x/flow_v0.104.x-v.200.x/test_unified_v6.x.x.js
similarity index 100%
rename from definitions/npm/unified_v6.x.x/flow_v0.104.x-/test_unified_v6.x.x.js
rename to definitions/npm/unified_v6.x.x/flow_v0.104.x-v.200.x/test_unified_v6.x.x.js
diff --git a/definitions/npm/unified_v6.x.x/flow_v0.104.x-/unified_v6.x.x.js b/definitions/npm/unified_v6.x.x/flow_v0.104.x-v.200.x/unified_v6.x.x.js
similarity index 100%
rename from definitions/npm/unified_v6.x.x/flow_v0.104.x-/unified_v6.x.x.js
rename to definitions/npm/unified_v6.x.x/flow_v0.104.x-v.200.x/unified_v6.x.x.js
diff --git a/definitions/npm/unified_v6.x.x/flow_v0.201.x-/test_unified_v6.x.x.js b/definitions/npm/unified_v6.x.x/flow_v0.201.x-/test_unified_v6.x.x.js
new file mode 100644
index 0000000000..6abb5ba3aa
--- /dev/null
+++ b/definitions/npm/unified_v6.x.x/flow_v0.201.x-/test_unified_v6.x.x.js
@@ -0,0 +1,24 @@
+/* @flow */
+
+import unified from 'unified'
+
+var process = unified()
+  .use('markdown')
+  .use(['format'])
+  .use({settings: {position: false}})
+  .use(['html', ['html', {}]])
+  .data('property', 10)
+  .freeze()
+  .run({type: 'orthogonal'}, 'file', (err) => {});
+
+var node = unified().parse('File contents');
+var string_node = unified().stringify(node);
+
+unified().process('Document').then((output) => {})
+unified().process('Document', (output) => {})
+
+// $FlowExpectedError
+unified().process('Document', 'done')
+
+// $FlowExpectedError
+unified().data([],[])
diff --git a/definitions/npm/unified_v6.x.x/flow_v0.201.x-/unified_v6.x.x.js b/definitions/npm/unified_v6.x.x/flow_v0.201.x-/unified_v6.x.x.js
new file mode 100644
index 0000000000..eda42e6a37
--- /dev/null
+++ b/definitions/npm/unified_v6.x.x/flow_v0.201.x-/unified_v6.x.x.js
@@ -0,0 +1,40 @@
+interface Unified$Point {
+  line: mixed;
+  column: mixed;
+  offset?: mixed;
+}
+
+interface Unified$Position {
+  start: Unified$Point;
+  end: Unified$Point;
+  indent?: mixed;
+}
+
+interface Unified$Data {}
+
+interface Unified$Node {
+  type: string;
+  data?: Unified$Data;
+  position?: Unified$Position;
+}
+
+type Done = (err: Error) => void | ((doc: mixed, extra?: mixed) => void);
+
+declare class Unified {
+  data(key: string): mixed;
+  data(key: string, value: mixed): this;
+  freeze(): this;
+  use(plugin: mixed, options?: mixed): this;
+  parse(file: mixed): Unified$Node;
+  stringify(node: Unified$Node, file?: mixed): string;
+  run(node: Unified$Node, file?: mixed): Promise<any>;
+  run(node: Unified$Node, file: mixed, done: Done): void;
+  runSync(node: Unified$Node, file?: mixed): Unified$Node;
+  process(doc: mixed): Promise<any>;
+  process(doc: mixed, done: Done): void;
+  processSync(doc: mixed): mixed;
+}
+
+declare module "unified" {
+  declare module.exports: () => Unified;
+}
diff --git a/definitions/npm/universal-router_v5.x.x/flow_v0.104.x-/test_universal-router_v5.x.x.js b/definitions/npm/universal-router_v5.x.x/flow_v0.104.x-v.200.x/test_universal-router_v5.x.x.js
similarity index 100%
rename from definitions/npm/universal-router_v5.x.x/flow_v0.104.x-/test_universal-router_v5.x.x.js
rename to definitions/npm/universal-router_v5.x.x/flow_v0.104.x-v.200.x/test_universal-router_v5.x.x.js
diff --git a/definitions/npm/universal-router_v5.x.x/flow_v0.104.x-/universal-router_v5.x.x.js b/definitions/npm/universal-router_v5.x.x/flow_v0.104.x-v.200.x/universal-router_v5.x.x.js
similarity index 100%
rename from definitions/npm/universal-router_v5.x.x/flow_v0.104.x-/universal-router_v5.x.x.js
rename to definitions/npm/universal-router_v5.x.x/flow_v0.104.x-v.200.x/universal-router_v5.x.x.js
diff --git a/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/test_universal-router_v5.x.x.js b/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/test_universal-router_v5.x.x.js
new file mode 100644
index 0000000000..7e1ef21396
--- /dev/null
+++ b/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/test_universal-router_v5.x.x.js
@@ -0,0 +1,49 @@
+/* @flow */
+
+import UniversalRouter from "universal-router";
+import generateUrls from "universal-router/generateUrls";
+
+const routes = [
+  {
+    path: "", // optional
+    action: () => `<h1>Home</h1>`
+  },
+  {
+    path: "/posts",
+    action: () => console.log("checking child routes for /posts"),
+    children: [
+      {
+        path: "", // optional, matches both "/posts" and "/posts/"
+        action: () => `<h1>Posts</h1>`
+      },
+      {
+        path: "/:id",
+        action: context => `<h1>Post #${context.params.id}</h1>`
+      }
+    ]
+  }
+];
+
+type RouterType = UniversalRouterType<
+  UniversalRouterRoute,
+  UniversalRouterContext,
+  string
+>;
+
+const router: RouterType = new UniversalRouter(routes);
+
+let postsResult: Promise<string> = router.resolve("/posts");
+postsResult = router.resolve({ pathname: "/posts" });
+
+// $FlowExpectedError
+const wrongPostsResult: Promise<number> = router.resolve("/posts");
+
+const url = generateUrls(router);
+
+// $FlowExpectedError
+const wrongUrl = generateUrls({});
+
+const usersUrl: string = url("users");
+
+// $FlowExpectedError
+const wrongUsersUrl: number = url("users");
diff --git a/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/universal-router_v5.x.x.js b/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/universal-router_v5.x.x.js
new file mode 100644
index 0000000000..2b0448b4c1
--- /dev/null
+++ b/definitions/npm/universal-router_v5.x.x/flow_v0.201.x-/universal-router_v5.x.x.js
@@ -0,0 +1,78 @@
+type UniversalRouterKey = {
+  name: string | number,
+  prefix?: string,
+  delimiter?: string,
+  optional: boolean,
+  repeat: boolean,
+  partial: boolean,
+  pattern?: string,
+  ...
+};
+
+type UniversalRouterContext = {
+  router: UniversalRouterType<any, any, any, any>,
+  route: UniversalRouterRoute,
+  next: (all?: boolean) => Promise<UniversalRouterRoute>,
+  pathname: string,
+  baseUrl: string,
+  path: string,
+  params: Object,
+  keys: Array<UniversalRouterKey>,
+  ...
+};
+
+type UniversalRouterRoute = {
+  path?: string,
+  name?: string,
+  parent?: ?UniversalRouterRoute,
+  children?: ?Array<UniversalRouterRoute>,
+  action?: (context: UniversalRouterContext, params: Object) => any,
+  ...
+};
+
+type UniversalRouterResolveRoute<R, C, O> = (context: C, params: Object) => O;
+
+type UniversalRouterOptions<R, C, O> = {
+  context?: C,
+  baseUrl?: string,
+  resolveRoute?: UniversalRouterResolveRoute<R, C, O>,
+  ...
+};
+
+type UniversalRouterResolveParams = { pathname: string, ... };
+
+declare class UniversalRouterType<
+  R, // Route type
+  C, // Context type
+  O, // Resolve output type
+  RP: UniversalRouterResolveParams = UniversalRouterResolveParams
+> {
+  constructor(
+    routes: R | Array<R>,
+    options?: UniversalRouterOptions<R, C, O>
+  ): UniversalRouterType<R, C, O, RP>;
+  resolve(params: RP | string): Promise<O>;
+  root: R;
+}
+
+declare module "universal-router" {
+  declare module.exports: Class<UniversalRouterType<any, any, any, any>>;
+}
+
+type UniversalRouterGenerateUrl = (
+  routeName: string,
+  routeParams?: Object
+) => string;
+type UniversalRouterGenerateUrlsFnOpts = {
+  encode?: string => string,
+  stringifyQueryParams?: (params: Object) => string,
+  ...
+};
+type UniversalRouterGenerateUrlsFn = (
+  router: UniversalRouterType<any, any, any, any>,
+  options?: UniversalRouterGenerateUrlsFnOpts
+) => UniversalRouterGenerateUrl;
+
+declare module "universal-router/generateUrls" {
+  declare module.exports: UniversalRouterGenerateUrlsFn;
+}
diff --git a/definitions/npm/uuid-js_v0.7.x/flow_v0.104.x-/uuid-js_v0.7.x.js b/definitions/npm/uuid-js_v0.7.x/flow_v0.104.x-v.200.x/uuid-js_v0.7.x.js
similarity index 100%
rename from definitions/npm/uuid-js_v0.7.x/flow_v0.104.x-/uuid-js_v0.7.x.js
rename to definitions/npm/uuid-js_v0.7.x/flow_v0.104.x-v.200.x/uuid-js_v0.7.x.js
diff --git a/definitions/npm/uuid-js_v0.7.x/flow_v0.201.x-/uuid-js_v0.7.x.js b/definitions/npm/uuid-js_v0.7.x/flow_v0.201.x-/uuid-js_v0.7.x.js
new file mode 100644
index 0000000000..2e4cde32fe
--- /dev/null
+++ b/definitions/npm/uuid-js_v0.7.x/flow_v0.201.x-/uuid-js_v0.7.x.js
@@ -0,0 +1,24 @@
+declare module "uuid-js" {
+  declare class UUID<V> {
+    fromParts(
+      timeLow: mixed,
+      timeMid: mixed,
+      timeHiAndVersion: mixed,
+      clockSeqHiAndReserved: mixed,
+      clockSeqLow: mixed,
+      node: mixed
+    ): mixed;
+    hex: string;
+    toBytes(): Array<mixed>;
+    toString(): string;
+    toURN(): string;
+    version: V;
+  }
+  declare function create(version?: 4): UUID<4>;
+  declare function create(version: 1): UUID<1>;
+  declare function firstFromTime(time: number): UUID<1>;
+  declare function fromBinary(binary: mixed): UUID<any>;
+  declare function fromBytes(bytes: number[]): UUID<any>;
+  declare function fromURN(string: string): UUID<any>;
+  declare function lastFromTime(time: number): UUID<1>;
+}
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.104.x-/test_winston_v3.x.x_format.js b/definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/test_winston_v3.x.x_format.js
similarity index 100%
rename from definitions/npm/winston_v3.x.x/flow_v0.104.x-/test_winston_v3.x.x_format.js
rename to definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/test_winston_v3.x.x_format.js
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.104.x-/test_winston_v3.x.x_profiler.js b/definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/test_winston_v3.x.x_profiler.js
similarity index 100%
rename from definitions/npm/winston_v3.x.x/flow_v0.104.x-/test_winston_v3.x.x_profiler.js
rename to definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/test_winston_v3.x.x_profiler.js
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.104.x-/winston_v3.x.x.js b/definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/winston_v3.x.x.js
similarity index 100%
rename from definitions/npm/winston_v3.x.x/flow_v0.104.x-/winston_v3.x.x.js
rename to definitions/npm/winston_v3.x.x/flow_v0.104.x-v.200.x/winston_v3.x.x.js
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_format.js b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_format.js
new file mode 100644
index 0000000000..922f4cc40d
--- /dev/null
+++ b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_format.js
@@ -0,0 +1,46 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import type { Logger, Levels, NpmLogLevels, Profiler, Info, Format } from 'winston';
+import { format } from 'winston';
+
+describe('format', () => {
+  describe('prettyPrint', () => {
+    it('should option be optional', () => {
+      const f1: Format = format.prettyPrint();
+    });
+    it('should colorize be a boolean', (options) => {
+      const f1: Format = format.prettyPrint({ colorize: true });
+      const f2: Format = format.prettyPrint({ colorize: false });
+      // $FlowExpectedError
+      const f3: Format = format.prettyPrint({ colorize: 1 });
+    });
+    it('should depth be a number', (options) => {
+      const f1: Format = format.prettyPrint({ depth: 0 });
+      const f2: Format = format.prettyPrint({ depth: 5 });
+      // $FlowExpectedError
+      const f3: Format = format.prettyPrint({ depth: true });
+    });
+    it('should not accept extra options', (options) => {
+      // $FlowExpectedError
+      const f1: Format = format.prettyPrint({ nope: true });
+      const f2: Format = format.prettyPrint({ depth: 5, colorize: true });
+    });
+  });
+
+  describe('errors', () => {
+    it('should option be optional', () => {
+      const f1: Format = format.errors();
+    });
+    it('should stack be a boolean', (options) => {
+      const f1: Format = format.errors({ stack: true });
+      const f2: Format = format.errors({ stack: false });
+      // $FlowExpectedError
+      const f3: Format = format.errors({ stack: 1 });
+    });
+    it('should not accept extra options', (options) => {
+      // $FlowExpectedError
+      const f1: Format = format.prettyPrint({ nope: true });
+    });
+  });
+});
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_profiler.js b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_profiler.js
new file mode 100644
index 0000000000..e10709e514
--- /dev/null
+++ b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/test_winston_v3.x.x_profiler.js
@@ -0,0 +1,40 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import type { Logger, Levels, NpmLogLevels, Profiler, Info } from 'winston';
+
+describe('profiler', () => {
+  describe('profile method', () => {
+    it('should accept name string param', <T: Levels>(logger: Logger<T>) => {
+      logger.profile('test');
+      // $FlowExpectedError
+      logger.profiler(1);
+      // $FlowExpectedError
+      logger.profiler();
+    });
+
+    it('should accept valid level option', (logger: Logger<NpmLogLevels>) => {
+      logger.profile('test', { level: 'debug' });
+      logger.profile('test', { level: 'debug', message: 'hello', extra: 'some-value' });
+      // $FlowExpectedError
+      logger.profiler('test', { level: 'no-a-level' });
+    });
+  });
+
+  describe('startTimer', (logger: Logger<NpmLogLevels>) => {
+    it('should return a Profiler instance', () => {
+      const profiler: Profiler<NpmLogLevels> = logger.startTimer();
+      // $FlowExpectedError
+      const invalidProfilerLevels: Profiler<{ nope: number, ... }> = logger.startTimer();
+    });
+  });
+
+  describe('Profiler instance', (profiler: Profiler<NpmLogLevels>) => {
+    it('should done method should accept InfoObject', (info: Info<NpmLogLevels>) => {
+      profiler.done(info);
+      const invalidInfoLevels: Info<{ nope: number, ... }> = { level: 'nope', message: 'hello' };
+      // $FlowExpectedError
+      profiler.done(invalidInfoLevels);
+    });
+  })
+});
\ No newline at end of file
diff --git a/definitions/npm/winston_v3.x.x/flow_v0.201.x-/winston_v3.x.x.js b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/winston_v3.x.x.js
new file mode 100644
index 0000000000..81030e69a6
--- /dev/null
+++ b/definitions/npm/winston_v3.x.x/flow_v0.201.x-/winston_v3.x.x.js
@@ -0,0 +1,153 @@
+declare type $winstonLevels = { [string]: number, ... };
+
+declare type $winstonNpmLogLevels = {
+  error: number,
+  warn: number,
+  info: number,
+  verbose: number,
+  debug: number,
+  silly: number,
+  ...
+};
+
+declare type $winstonInfo<T: $winstonLevels> = {
+  [optionName: string]: mixed,
+  level: $Keys<T>,
+  message: string,
+  ...
+};
+
+declare type $winstonFormat = Object;
+
+declare type $winstonFileTransportConfig<T: $winstonLevels> = {
+  filename: string,
+  level?: $Keys<T>,
+  ...
+};
+
+declare class $winstonTransport {
+  level?: string;
+  silent?: boolean;
+}
+
+declare class $winstonFileTransport<T> extends $winstonTransport {
+  constructor($winstonFileTransportConfig<T>): $winstonFileTransport<T>;
+}
+
+declare type $winstonConsoleTransportConfig<T: $winstonLevels> = { level?: $Keys<T>, ... };
+
+declare class $winstonConsoleTransport<T> extends $winstonTransport {
+  constructor(
+    config?: $winstonConsoleTransportConfig<T>
+  ): $winstonConsoleTransport<T>;
+}
+
+declare type $winstonLoggerConfig<T: $winstonLevels> = {
+  exitOnError?: boolean,
+  format?: $winstonFormat,
+  level?: $Keys<T>,
+  levels?: T,
+  transports?: Array<$winstonTransport>,
+  ...
+};
+
+declare type $winstonLogger<T: $winstonLevels> = {
+  [$Keys<T>]: (message: string, meta?: Object) => $winstonLogger<T>,
+  add: $winstonTransport => $winstonLogger<T>,
+  remove: $winstonTransport => $winstonLogger<T>,
+  clear: () => $winstonLogger<T>,
+  close: () => $winstonLogger<T>,
+  configure: ($winstonLoggerConfig<T>) => void,
+  log: (message: $winstonInfo<T>) => $winstonLogger<T>,
+  startTimer: () => $winstonProfiler<T>,
+  profile: (name: string, info?: $Shape<$winstonInfo<T>>) => void,
+  ...
+};
+
+declare type $winstonConfigSubModule = { npm: () => $winstonNpmLogLevels, ... };
+
+declare type $winstonFormatJsonOptions = {
+  replacer?: (key: string, value: mixed) => mixed,
+  space?: number,
+  stable?: boolean,
+  ...
+};
+
+declare type $winstonFormatPrettyPrintOptions = {|
+  depth?: number,
+  colorize?: boolean,
+|};
+
+declare type $winstonFormatErrorsOptions = {|
+  stack?: boolean,
+|};
+
+declare type $winstonFormatSubModule = {
+  <T: $winstonLevels>((info: $winstonInfo<T>) => $winstonInfo<T>): () => $winstonFormat,
+  combine: (...args: Array<$winstonFormat>) => $winstonFormat,
+  json: (options?: $winstonFormatJsonOptions) => $winstonFormat,
+  label: (config?: Object) => $winstonFormat,
+  metadata: () => $winstonFormat,
+  prettyPrint: (options?: $winstonFormatPrettyPrintOptions) => $winstonFormat,
+  simple: () => $winstonFormat,
+  splat: () => $winstonFormat,
+  timestamp: (?{
+    alias?: string,
+    format?: string | () => string,
+    ...
+  }) => $winstonFormat,
+  colorize: () => $winstonFormat,
+  logstash: () => $winstonFormat,
+  printf: ((args: $winstonInfo<Object>) => string) => $winstonFormat,
+  errors: (options?: $winstonFormatErrorsOptions) => $winstonFormat,
+  ...
+};
+
+declare type $winstonDefaultLogger = $winstonLogger<$winstonNpmLogLevels>;
+
+declare class $winstonContainer<T> {
+  constructor(config?: $winstonLoggerConfig<T>): $winstonContainer<T>;
+  add(loggerId: string, config?: $winstonLoggerConfig<T>): $winstonLogger<T>;
+  get(loggerId: string): $winstonLogger<T>;
+  has(loggerId: string): boolean;
+  close(loggerId?: string): void;
+}
+
+declare interface $winstonProfiler<T: $winstonNpmLogLevels> {
+  logger: $winstonLogger<T>;
+  start: Date;
+  done(info?: $Shape<$winstonInfo<T>>): void;
+};
+
+declare module "winston" {
+  declare export type Levels = $winstonLevels;
+  declare export type NpmLogLevels = $winstonNpmLogLevels;
+  declare export type Info<T: Levels > = $winstonInfo<T>;
+  declare export type Format = $winstonFormat;
+  declare export type FileTransportConfig<T: Levels> = $winstonFileTransportConfig<T>;
+  declare export type Transport = $winstonTransport;
+  declare export type FileTransport<T: Levels> = $winstonFileTransport<T>;
+  declare export type ConsoleTransportConfig<T: Levels> = $winstonConsoleTransportConfig<T>;
+  declare export type ConsoleTransport<T: Levels> = $winstonConsoleTransport<T>;
+  declare export type LoggerConfig<T: Levels> = $winstonLoggerConfig<T>;
+  declare export type Logger<T: Levels> = $winstonLogger<T>;
+  declare export type ConfigSubModule = $winstonConfigSubModule;
+  declare export type FormatSubModule = $winstonFormatSubModule;
+  declare export type DefaultLogger = $winstonDefaultLogger;
+  declare export type Container<T: Levels> = $winstonContainer<T>;
+  declare export type Profiler<T: Levels> = $winstonProfiler<T>;
+
+  declare module.exports: {
+    ...$Exact<$winstonDefaultLogger>,
+    format: $winstonFormatSubModule,
+    transports: {
+      Console: typeof $winstonConsoleTransport,
+      File: typeof $winstonFileTransport,
+      ...
+    },
+    createLogger: <T>($winstonLoggerConfig<T>) => $winstonLogger<T>,
+    Container: typeof $winstonContainer,
+    loggers: $winstonContainer<any>,
+    ...
+  };
+}
diff --git a/definitions/npm/xstream_v6.x.x/flow_v0.104.x-/xstream_v6.x.x.js b/definitions/npm/xstream_v6.x.x/flow_v0.104.x-v.200.x/xstream_v6.x.x.js
similarity index 100%
rename from definitions/npm/xstream_v6.x.x/flow_v0.104.x-/xstream_v6.x.x.js
rename to definitions/npm/xstream_v6.x.x/flow_v0.104.x-v.200.x/xstream_v6.x.x.js
diff --git a/definitions/npm/xstream_v6.x.x/flow_v0.201.x-/xstream_v6.x.x.js b/definitions/npm/xstream_v6.x.x/flow_v0.201.x-/xstream_v6.x.x.js
new file mode 100644
index 0000000000..d455cb56e0
--- /dev/null
+++ b/definitions/npm/xstream_v6.x.x/flow_v0.201.x-/xstream_v6.x.x.js
@@ -0,0 +1,74 @@
+declare class xstream$Stream<T> {
+  addListener(listener: xstream$Listener<T>): void;
+  removeListener(listener: xstream$Listener<T>): void;
+  subscribe(listener: xstream$Listener<T>): xstream$Subscription;
+  map<R>(project: (value: T) => R): xstream$Stream<R>;
+  mapTo<R>(projectedValue: R): xstream$Stream<R>;
+  filter(passes: (value: T) => boolean): xstream$Stream<T>;
+  take(amount: number): xstream$Stream<T>;
+  drop(amount: number): xstream$Stream<T>;
+  last(): xstream$Stream<T>;
+  startWith(initial: T): xstream$Stream<T>;
+  endWhen(other: xstream$Stream<any>): xstream$Stream<T>;
+  fold<R>(accumulate: (acc: R, x: T) => R, seed: R): xstream$Stream<R>;
+  replaceError(replace: xstream$Stream<T>): xstream$Stream<T>;
+  flatten(): T;
+  compose<R>(operator: (stream: xstream$Stream<T>) => xstream$Stream<R>): xstream$Stream<R>;
+  remember(): xstream$MemoryStream<T>;
+  debug(labelOrSpy: string | (x: T) => void): xstream$Stream<T>;
+  imitate(target: xstream$Stream<T>): void;
+  shamefullySendNext(value: T): void;
+  shamefullySendError(error: any): void;
+  shamefullySendComplete(): void;
+  setDebugListener(listener: xstream$Listener<T>): void;
+}
+
+declare class xstream$MemoryStream<T> extends xstream$Stream<T> {
+}
+
+declare type xstream$Listener<T> = {
+  next<T>(value: T): void,
+  error(error: Error): void,
+  complete(): void,
+  ...
+}
+
+declare class xstream$Subscription {
+  unsubscribe(): void;
+}
+
+declare type xstream$Producer<T> = {
+  start: (listener: xstream$Listener<T>) => void,
+  stop: () => void,
+  ...
+}
+
+declare function xstream$combineResult<T>(s: xstream$Stream<T>): T;
+
+declare type xstream$exports = {
+  default: xstream$exports,
+  create<T>(producer?: xstream$Producer<T>): xstream$Stream<T>,
+  createWithMemory<T>(producer: xstream$Producer<T>): xstream$MemoryStream<T>,
+  never<T>(): xstream$Stream<T>,
+  empty<T>(): xstream$Stream<T>,
+  throw<T>(error: any): xstream$Stream<T>,
+  from<T>(arrayOrPromise: T[] | Promise<T>): xstream$Stream<T>,
+  of<T>(...values: T[]): xstream$Stream<T>,
+  fromArray<T>(array: T[]): xstream$Stream<T>,
+  fromPromise<T>(promise: Promise<T>): xstream$Stream<T>,
+  periodic(period: number): xstream$Stream<number>,
+  merge<T>(stream1: xstream$Stream<T>, stream2: xstream$Stream<T>): xstream$Stream<T>,
+  merge<T>(...streams: Array<xstream$Stream<T>>): xstream$Stream<T>,
+  combine<T, R>(stream1: xstream$Stream<T>, stream2: xstream$Stream<R>): xstream$Stream<[T, R]>,
+  combine<T>(...streams: Array<xstream$Stream<T>>): xstream$Stream<T[]>,
+  Stream: typeof xstream$Stream,
+  MemoryStream: typeof xstream$MemoryStream,
+  Listener: xstream$Listener<any>,
+  Producer: xstream$Producer<any>,
+  Subscription: typeof xstream$Subscription,
+  ...
+}
+
+declare module "xstream" {
+  declare module.exports: xstream$exports;
+}
diff --git a/definitions/npm/xstream_v7.x.x/flow_v0.104.x-/xstream_v7.x.x.js b/definitions/npm/xstream_v7.x.x/flow_v0.104.x-v.200.x/xstream_v7.x.x.js
similarity index 100%
rename from definitions/npm/xstream_v7.x.x/flow_v0.104.x-/xstream_v7.x.x.js
rename to definitions/npm/xstream_v7.x.x/flow_v0.104.x-v.200.x/xstream_v7.x.x.js
diff --git a/definitions/npm/xstream_v7.x.x/flow_v0.201.x-/xstream_v7.x.x.js b/definitions/npm/xstream_v7.x.x/flow_v0.201.x-/xstream_v7.x.x.js
new file mode 100644
index 0000000000..d455cb56e0
--- /dev/null
+++ b/definitions/npm/xstream_v7.x.x/flow_v0.201.x-/xstream_v7.x.x.js
@@ -0,0 +1,74 @@
+declare class xstream$Stream<T> {
+  addListener(listener: xstream$Listener<T>): void;
+  removeListener(listener: xstream$Listener<T>): void;
+  subscribe(listener: xstream$Listener<T>): xstream$Subscription;
+  map<R>(project: (value: T) => R): xstream$Stream<R>;
+  mapTo<R>(projectedValue: R): xstream$Stream<R>;
+  filter(passes: (value: T) => boolean): xstream$Stream<T>;
+  take(amount: number): xstream$Stream<T>;
+  drop(amount: number): xstream$Stream<T>;
+  last(): xstream$Stream<T>;
+  startWith(initial: T): xstream$Stream<T>;
+  endWhen(other: xstream$Stream<any>): xstream$Stream<T>;
+  fold<R>(accumulate: (acc: R, x: T) => R, seed: R): xstream$Stream<R>;
+  replaceError(replace: xstream$Stream<T>): xstream$Stream<T>;
+  flatten(): T;
+  compose<R>(operator: (stream: xstream$Stream<T>) => xstream$Stream<R>): xstream$Stream<R>;
+  remember(): xstream$MemoryStream<T>;
+  debug(labelOrSpy: string | (x: T) => void): xstream$Stream<T>;
+  imitate(target: xstream$Stream<T>): void;
+  shamefullySendNext(value: T): void;
+  shamefullySendError(error: any): void;
+  shamefullySendComplete(): void;
+  setDebugListener(listener: xstream$Listener<T>): void;
+}
+
+declare class xstream$MemoryStream<T> extends xstream$Stream<T> {
+}
+
+declare type xstream$Listener<T> = {
+  next<T>(value: T): void,
+  error(error: Error): void,
+  complete(): void,
+  ...
+}
+
+declare class xstream$Subscription {
+  unsubscribe(): void;
+}
+
+declare type xstream$Producer<T> = {
+  start: (listener: xstream$Listener<T>) => void,
+  stop: () => void,
+  ...
+}
+
+declare function xstream$combineResult<T>(s: xstream$Stream<T>): T;
+
+declare type xstream$exports = {
+  default: xstream$exports,
+  create<T>(producer?: xstream$Producer<T>): xstream$Stream<T>,
+  createWithMemory<T>(producer: xstream$Producer<T>): xstream$MemoryStream<T>,
+  never<T>(): xstream$Stream<T>,
+  empty<T>(): xstream$Stream<T>,
+  throw<T>(error: any): xstream$Stream<T>,
+  from<T>(arrayOrPromise: T[] | Promise<T>): xstream$Stream<T>,
+  of<T>(...values: T[]): xstream$Stream<T>,
+  fromArray<T>(array: T[]): xstream$Stream<T>,
+  fromPromise<T>(promise: Promise<T>): xstream$Stream<T>,
+  periodic(period: number): xstream$Stream<number>,
+  merge<T>(stream1: xstream$Stream<T>, stream2: xstream$Stream<T>): xstream$Stream<T>,
+  merge<T>(...streams: Array<xstream$Stream<T>>): xstream$Stream<T>,
+  combine<T, R>(stream1: xstream$Stream<T>, stream2: xstream$Stream<R>): xstream$Stream<[T, R]>,
+  combine<T>(...streams: Array<xstream$Stream<T>>): xstream$Stream<T[]>,
+  Stream: typeof xstream$Stream,
+  MemoryStream: typeof xstream$MemoryStream,
+  Listener: xstream$Listener<any>,
+  Producer: xstream$Producer<any>,
+  Subscription: typeof xstream$Subscription,
+  ...
+}
+
+declare module "xstream" {
+  declare module.exports: xstream$exports;
+}